Recherche avancée

Sur d’autres sites (4854)

• Recording a video using MediaRecorder

  21 juillet 2016, par Cédric Portmann

  I am currently using the TextureFromCameraActivity from Grafika to record a video in square ( 1:1 ) resolution. Therefor I the GLES20.glViewport so that the video gets moved to the top and it appears to be squared. Now I would like to record this square view using the MediaRecorder or at least record the camera with normal resolutiona and then crop it using FFmpeg. However I get the same error over and over again and I cant figure out why.

  The error I get :

  start called in an invalid state : 4

  And yes I added all the necessary permissions.

  android.permission.WRITE_EXTERNAL_STORAGE android.permission.CAMERA
  android.permission.RECORD_VIDEO android.permission.RECORD_AUDIO
  android.permission.STORAGE android.permission.READ_EXTERNAL_STORAGE

  Here the modified code :

  https://github.com/google/grafika

  Thanks for your help :D

  package com.android.grafika;
  
  
  
  import android.graphics.SurfaceTexture;
  
  import android.hardware.Camera;
  
  import android.media.CamcorderProfile;
  
  import android.media.MediaRecorder;
  
  import android.opengl.GLES20;
  
  import android.opengl.Matrix;
  
  import android.os.Bundle;
  
  import android.os.Environment;
  
  import android.os.Handler;
  
  import android.os.Looper;
  
  import android.os.Message;
  
  import android.util.Log;
  
  import android.view.MotionEvent;
  
  import android.view.Surface;
  
  import android.view.SurfaceHolder;
  
  import android.view.SurfaceView;
  
  import android.view.View;
  
  import android.widget.Button;
  
  import android.widget.SeekBar;
  
  import android.widget.TextView;
  
  import android.app.Activity;
  
  import android.widget.Toast;
  
  
  
  import com.android.grafika.gles.Drawable2d;
  
  import com.android.grafika.gles.EglCore;
  
  import com.android.grafika.gles.GlUtil;
  
  import com.android.grafika.gles.Sprite2d;
  
  import com.android.grafika.gles.Texture2dProgram;
  
  import com.android.grafika.gles.WindowSurface;
  
  
  
  import java.io.File;
  
  import java.io.IOException;
  
  import java.lang.ref.WeakReference;
  
  
  
  
  
  public class TextureFromCameraActivity extends Activity implements View.OnClickListener, SurfaceHolder.Callback,
  
          SeekBar.OnSeekBarChangeListener {
  
  
  
  
  
      private static final int DEFAULT_ZOOM_PERCENT = 0;      // 0-100
  
      private static final int DEFAULT_SIZE_PERCENT = 80;     // 0-100
  
      private static final int DEFAULT_ROTATE_PERCENT = 75;    // 0-100
  
  
  
      // Requested values; actual may differ.
  
      private static final int REQ_CAMERA_WIDTH = 720;
  
      private static final int REQ_CAMERA_HEIGHT = 720;
  
      private static final int REQ_CAMERA_FPS = 30;
  
  
  
      // The holder for our SurfaceView.  The Surface can outlive the Activity (e.g. when
  
      // the screen is turned off and back on with the power button).
  
      //
  
      // This becomes non-null after the surfaceCreated() callback is called, and gets set
  
      // to null when surfaceDestroyed() is called.
  
      private static SurfaceHolder sSurfaceHolder;
  
  
  
      // Thread that handles rendering and controls the camera.  Started in onResume(),
  
      // stopped in onPause().
  
      private RenderThread mRenderThread;
  
  
  
      // Receives messages from renderer thread.
  
      private MainHandler mHandler;
  
  
  
      // User controls.
  
      private SeekBar mZoomBar;
  
      private SeekBar mSizeBar;
  
      private SeekBar mRotateBar;
  
  
  
      // These values are passed to us by the camera/render thread, and displayed in the UI.
  
      // We could also just peek at the values in the RenderThread object, but we'd need to
  
      // synchronize access carefully.
  
      private int mCameraPreviewWidth, mCameraPreviewHeight;
  
      private float mCameraPreviewFps;
  
      private int mRectWidth, mRectHeight;
  
      private int mZoomWidth, mZoomHeight;
  
      private int mRotateDeg;
  
      SurfaceHolder sh;
  
      MediaRecorder recorder;
  
      SurfaceHolder holder;
  
      boolean recording = false;
  
  
  
      public static final String TAG = "VIDEOCAPTURE";
  
  
  
      private static final File OUTPUT_DIR = Environment.getExternalStorageDirectory();
  
  
  
  
  
      @Override
  
      protected void onCreate(Bundle savedInstanceState) {
  
          super.onCreate(savedInstanceState);
  
  
  
          recorder = new MediaRecorder();
  
  
  
  
  
  
  
          setContentView(R.layout.activity_texture_from_camera);
  
  
  
          mHandler = new MainHandler(this);
  
  
  
          SurfaceView cameraView = (SurfaceView) findViewById(R.id.cameraOnTexture_surfaceView);
  
          sh = cameraView.getHolder();
  
          cameraView.setClickable(true);// make the surface view clickable
  
          sh.addCallback(this);
  
  
  
  
  
          //prepareRecorder();
  
  
  
  
  
          mZoomBar = (SeekBar) findViewById(R.id.tfcZoom_seekbar);
  
          mSizeBar = (SeekBar) findViewById(R.id.tfcSize_seekbar);
  
          mRotateBar = (SeekBar) findViewById(R.id.tfcRotate_seekbar);
  
          mZoomBar.setProgress(DEFAULT_ZOOM_PERCENT);
  
          mSizeBar.setProgress(DEFAULT_SIZE_PERCENT);
  
          mRotateBar.setProgress(DEFAULT_ROTATE_PERCENT);
  
          mZoomBar.setOnSeekBarChangeListener(this);
  
          mSizeBar.setOnSeekBarChangeListener(this);
  
          mRotateBar.setOnSeekBarChangeListener(this);
  
  
  
          Button record_btn = (Button)findViewById(R.id.button);
  
          record_btn.setOnClickListener(this);
  
          initRecorder();
  
  
  
  
  
          updateControls();
  
  
  
  
  
  
  
  
  
      }
  
  
  
  
  
  
  
  
  
  
  
      @Override
  
      protected void onResume() {
  
          Log.d(TAG, "onResume BEGIN");
  
          super.onResume();
  
  
  
          mRenderThread = new RenderThread(mHandler);
  
          mRenderThread.setName("TexFromCam Render");
  
          mRenderThread.start();
  
          mRenderThread.waitUntilReady();
  
  
  
          RenderHandler rh = mRenderThread.getHandler();
  
          rh.sendZoomValue(mZoomBar.getProgress());
  
          rh.sendSizeValue(mSizeBar.getProgress());
  
          rh.sendRotateValue(mRotateBar.getProgress());
  
  
  
          if (sSurfaceHolder != null) {
  
              Log.d(TAG, "Sending previous surface");
  
              rh.sendSurfaceAvailable(sSurfaceHolder, false);
  
          } else {
  
              Log.d(TAG, "No previous surface");
  
          }
  
          Log.d(TAG, "onResume END");
  
      }
  
  
  
      @Override
  
      protected void onPause() {
  
          Log.d(TAG, "onPause BEGIN");
  
          super.onPause();
  
  
  
          RenderHandler rh = mRenderThread.getHandler();
  
          rh.sendShutdown();
  
          try {
  
              mRenderThread.join();
  
          } catch (InterruptedException ie) {
  
              // not expected
  
              throw new RuntimeException("join was interrupted", ie);
  
          }
  
          mRenderThread = null;
  
          Log.d(TAG, "onPause END");
  
      }
  
  
  
      @Override   // SurfaceHolder.Callback
  
      public void surfaceCreated(SurfaceHolder holder) {
  
          Log.d(TAG, "surfaceCreated holder=" + holder + " (static=" + sSurfaceHolder + ")");
  
          if (sSurfaceHolder != null) {
  
              throw new RuntimeException("sSurfaceHolder is already set");
  
          }
  
  
  
          sSurfaceHolder = holder;
  
  
  
          if (mRenderThread != null) {
  
              // Normal case -- render thread is running, tell it about the new surface.
  
              RenderHandler rh = mRenderThread.getHandler();
  
              rh.sendSurfaceAvailable(holder, true);
  
          } else {
  
              // Sometimes see this on 4.4.x N5: power off, power on, unlock, with device in
  
              // landscape and a lock screen that requires portrait.  The surface-created
  
              // message is showing up after onPause().
  
              //
  
              // Chances are good that the surface will be destroyed before the activity is
  
              // unpaused, but we track it anyway.  If the activity is un-paused and we start
  
              // the RenderThread, the SurfaceHolder will be passed in right after the thread
  
              // is created.
  
              Log.d(TAG, "render thread not running");
  
          }
  
  
  
          recorder.setPreviewDisplay(holder.getSurface());
  
  
  
      }
  
  
  
      @Override   // SurfaceHolder.Callback
  
      public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
  
          Log.d(TAG, "surfaceChanged fmt=" + format + " size=" + width + "x" + height +
  
                  " holder=" + holder);
  
  
  
          if (mRenderThread != null) {
  
              RenderHandler rh = mRenderThread.getHandler();
  
              rh.sendSurfaceChanged(format, width, height);
  
          } else {
  
              Log.d(TAG, "Ignoring surfaceChanged");
  
              return;
  
          }
  
      }
  
  
  
      @Override   // SurfaceHolder.Callback
  
      public void surfaceDestroyed(SurfaceHolder holder) {
  
          // In theory we should tell the RenderThread that the surface has been destroyed.
  
          if (mRenderThread != null) {
  
              RenderHandler rh = mRenderThread.getHandler();
  
              rh.sendSurfaceDestroyed();
  
          }
  
          Log.d(TAG, "surfaceDestroyed holder=" + holder);
  
          sSurfaceHolder = null;
  
      }
  
  
  
      @Override   // SeekBar.OnSeekBarChangeListener
  
      public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
  
          if (mRenderThread == null) {
  
              // Could happen if we programmatically update the values after setting a listener
  
              // but before starting the thread.  Also, easy to cause this by scrubbing the seek
  
              // bar with one finger then tapping "recents" with another.
  
              Log.w(TAG, "Ignoring onProgressChanged received w/o RT running");
  
              return;
  
          }
  
          RenderHandler rh = mRenderThread.getHandler();
  
  
  
          // "progress" ranges from 0 to 100
  
          if (seekBar == mZoomBar) {
  
              //Log.v(TAG, "zoom: " + progress);
  
              rh.sendZoomValue(progress);
  
          } else if (seekBar == mSizeBar) {
  
              //Log.v(TAG, "size: " + progress);
  
              rh.sendSizeValue(progress);
  
          } else if (seekBar == mRotateBar) {
  
              //Log.v(TAG, "rotate: " + progress);
  
              rh.sendRotateValue(progress);
  
          } else {
  
              throw new RuntimeException("unknown seek bar");
  
          }
  
  
  
          // If we're getting preview frames quickly enough we don't really need this, but
  
          // we don't want to have chunky-looking resize movement if the camera is slow.
  
          // OTOH, if we get the updates too quickly (60fps camera?), this could jam us
  
          // up and cause us to run behind.  So use with caution.
  
          rh.sendRedraw();
  
      }
  
  
  
      @Override   // SeekBar.OnSeekBarChangeListener
  
      public void onStartTrackingTouch(SeekBar seekBar) {}
  
      @Override   // SeekBar.OnSeekBarChangeListener
  
      public void onStopTrackingTouch(SeekBar seekBar) {}
  
      @Override
  
  
  
      /**
  
       * Handles any touch events that aren't grabbed by one of the controls.
  
       */
  
      public boolean onTouchEvent(MotionEvent e) {
  
          float x = e.getX();
  
          float y = e.getY();
  
  
  
          switch (e.getAction()) {
  
              case MotionEvent.ACTION_MOVE:
  
              case MotionEvent.ACTION_DOWN:
  
                  //Log.v(TAG, "onTouchEvent act=" + e.getAction() + " x=" + x + " y=" + y);
  
                  if (mRenderThread != null) {
  
                      RenderHandler rh = mRenderThread.getHandler();
  
                      rh.sendPosition((int) x, (int) y);
  
  
  
                      // Forcing a redraw can cause sluggish-looking behavior if the touch
  
                      // events arrive quickly.
  
                      //rh.sendRedraw();
  
                  }
  
                  break;
  
              default:
  
                  break;
  
          }
  
  
  
          return true;
  
      }
  
  
  
      /**
  
       * Updates the current state of the controls.
  
       */
  
      private void updateControls() {
  
          String str = getString(R.string.tfcCameraParams, mCameraPreviewWidth,
  
                  mCameraPreviewHeight, mCameraPreviewFps);
  
          TextView tv = (TextView) findViewById(R.id.tfcCameraParams_text);
  
          tv.setText(str);
  
  
  
          str = getString(R.string.tfcRectSize, mRectWidth, mRectHeight);
  
          tv = (TextView) findViewById(R.id.tfcRectSize_text);
  
          tv.setText(str);
  
  
  
          str = getString(R.string.tfcZoomArea, mZoomWidth, mZoomHeight);
  
          tv = (TextView) findViewById(R.id.tfcZoomArea_text);
  
          tv.setText(str);
  
      }
  
  
  
      @Override
  
      public void onClick(View view) {
  
  
  
          if (recording) {
  
              recorder.stop();
  
              recording = false;
  
  
  
              // Let's initRecorder so we can record again
  
              initRecorder();
  
              prepareRecorder();
  
          } else {
  
              recording = true;
  
              recorder.start();
  
          }
  
      }
  
  
  
  
  
      private void initRecorder() {
  
          recorder.setAudioSource(MediaRecorder.AudioSource.DEFAULT);
  
          recorder.setVideoSource(MediaRecorder.VideoSource.DEFAULT);
  
  
  
          CamcorderProfile cpHigh = CamcorderProfile
  
                  .get(CamcorderProfile.QUALITY_HIGH);
  
          recorder.setProfile(cpHigh);
  
          String path = Environment.getExternalStorageDirectory() + File.separator
  
                  + Environment.DIRECTORY_DCIM + File.separator + "AlphaRun";
  
  
  
          recorder.setOutputFile(path);
  
          recorder.setMaxDuration(50000); // 50 seconds
  
          recorder.setMaxFileSize(5000000); // Approximately 5 megabytes
  
  
  
      }
  
  
  
      private void prepareRecorder() {
  
  
  
  
  
          try {
  
              recorder.prepare();
  
          } catch (IllegalStateException e) {
  
              e.printStackTrace();
  
              finish();
  
          } catch (IOException e) {
  
              e.printStackTrace();
  
              finish();
  
          }
  
      }
  
  
  
  
  
  
  
  
  
      /**
  
       * Thread that handles all rendering and camera operations.
  
       */
  
      private static class RenderThread extends Thread implements
  
              SurfaceTexture.OnFrameAvailableListener {
  
          // Object must be created on render thread to get correct Looper, but is used from
  
          // UI thread, so we need to declare it volatile to ensure the UI thread sees a fully
  
          // constructed object.
  
          private volatile RenderHandler mHandler;
  
  
  
          // Used to wait for the thread to start.
  
          private Object mStartLock = new Object();
  
          private boolean mReady = false;
  
  
  
          private MainHandler mMainHandler;
  
  
  
          private Camera mCamera;
  
          private int mCameraPreviewWidth, mCameraPreviewHeight;
  
  
  
          private EglCore mEglCore;
  
          private WindowSurface mWindowSurface;
  
          private int mWindowSurfaceWidth;
  
          private int mWindowSurfaceHeight;
  
  
  
          // Receives the output from the camera preview.
  
          private SurfaceTexture mCameraTexture;
  
  
  
          // Orthographic projection matrix.
  
          private float[] mDisplayProjectionMatrix = new float[16];
  
  
  
          private Texture2dProgram mTexProgram;
  
          private final ScaledDrawable2d mRectDrawable =
  
                  new ScaledDrawable2d(Drawable2d.Prefab.RECTANGLE);
  
          private final Sprite2d mRect = new Sprite2d(mRectDrawable);
  
  
  
          private int mZoomPercent = DEFAULT_ZOOM_PERCENT;
  
          private int mSizePercent = DEFAULT_SIZE_PERCENT;
  
          private int mRotatePercent = DEFAULT_ROTATE_PERCENT;
  
          private float mPosX, mPosY;
  
  
  
  
  
          /**
  
           * Constructor.  Pass in the MainHandler, which allows us to send stuff back to the
  
           * Activity.
  
           */
  
          public RenderThread(MainHandler handler) {
  
              mMainHandler = handler;
  
  
  
          }
  
  
  
          /**
  
           * Thread entry point.
  
           */
  
          @Override
  
          public void run() {
  
              Looper.prepare();
  
  
  
              // We need to create the Handler before reporting ready.
  
              mHandler = new RenderHandler(this);
  
              synchronized (mStartLock) {
  
                  mReady = true;
  
                  mStartLock.notify();    // signal waitUntilReady()
  
              }
  
  
  
              // Prepare EGL and open the camera before we start handling messages.
  
              mEglCore = new EglCore(null, 0);
  
              openCamera(REQ_CAMERA_WIDTH, REQ_CAMERA_HEIGHT, REQ_CAMERA_FPS);
  
  
  
              Looper.loop();
  
  
  
              Log.d(TAG, "looper quit");
  
              releaseCamera();
  
              releaseGl();
  
              mEglCore.release();
  
  
  
              synchronized (mStartLock) {
  
                  mReady = false;
  
              }
  
          }
  
  
  
          /**
  
           * Waits until the render thread is ready to receive messages.
  
           * <p>
  
           * Call from the UI thread.
  
           */
  
          public void waitUntilReady() {
  
              synchronized (mStartLock) {
  
                  while (!mReady) {
  
                      try {
  
                          mStartLock.wait();
  
                      } catch (InterruptedException ie) { /* not expected */ }
  
                  }
  
              }
  
          }
  
  
  
          /**
  
           * Shuts everything down.
  
           */
  
          private void shutdown() {
  
              Log.d(TAG, "shutdown");
  
              Looper.myLooper().quit();
  
          }
  
  
  
          /**
  
           * Returns the render thread's Handler.  This may be called from any thread.
  
           */
  
          public RenderHandler getHandler() {
  
              return mHandler;
  
          }
  
  
  
          /**
  
           * Handles the surface-created callback from SurfaceView.  Prepares GLES and the Surface.
  
           */
  
          private void surfaceAvailable(SurfaceHolder holder, boolean newSurface) {
  
  
  
              Surface surface = holder.getSurface();
  
              mWindowSurface = new WindowSurface(mEglCore, surface, false);
  
              mWindowSurface.makeCurrent();
  
  
  
              // Create and configure the SurfaceTexture, which will receive frames from the
  
              // camera.  We set the textured rect's program to render from it.
  
              mTexProgram = new Texture2dProgram(Texture2dProgram.ProgramType.TEXTURE_EXT);
  
              int textureId = mTexProgram.createTextureObject();
  
              mCameraTexture = new SurfaceTexture(textureId);
  
              mRect.setTexture(textureId);
  
  
  
              if (!newSurface) {
  
                  // This Surface was established on a previous run, so no surfaceChanged()
  
                  // message is forthcoming.  Finish the surface setup now.
  
                  //
  
                  // We could also just call this unconditionally, and perhaps do an unnecessary
  
                  // bit of reallocating if a surface-changed message arrives.
  
                  mWindowSurfaceWidth = mWindowSurface.getWidth();
  
                  mWindowSurfaceHeight = mWindowSurface.getWidth();
  
                  finishSurfaceSetup();
  
              }
  
  
  
              mCameraTexture.setOnFrameAvailableListener(this);
  
  
  
  
  
  
  
          }
  
  
  
          /**
  
           * Releases most of the GL resources we currently hold (anything allocated by
  
           * surfaceAvailable()).
  
           * </p><p>
  
           * Does not release EglCore.
  
           */
  
          private void releaseGl() {
  
              GlUtil.checkGlError("releaseGl start");
  
  
  
              if (mWindowSurface != null) {
  
                  mWindowSurface.release();
  
                  mWindowSurface = null;
  
              }
  
              if (mTexProgram != null) {
  
                  mTexProgram.release();
  
                  mTexProgram = null;
  
              }
  
              GlUtil.checkGlError("releaseGl done");
  
  
  
              mEglCore.makeNothingCurrent();
  
          }
  
  
  
          /**
  
           * Handles the surfaceChanged message.
  
           * </p><p>
  
           * We always receive surfaceChanged() after surfaceCreated(), but surfaceAvailable()
  
           * could also be called with a Surface created on a previous run.  So this may not
  
           * be called.
  
           */
  
          private void surfaceChanged(int width, int height) {
  
              Log.d(TAG, "RenderThread surfaceChanged " + width + "x" + height);
  
  
  
              mWindowSurfaceWidth = width;
  
              mWindowSurfaceHeight = width;
  
              finishSurfaceSetup();
  
          }
  
  
  
          /**
  
           * Handles the surfaceDestroyed message.
  
           */
  
          private void surfaceDestroyed() {
  
              // In practice this never appears to be called -- the activity is always paused
  
              // before the surface is destroyed.  In theory it could be called though.
  
              Log.d(TAG, "RenderThread surfaceDestroyed");
  
              releaseGl();
  
          }
  
  
  
          /**
  
           * Sets up anything that depends on the window size.
  
           * </p><p>
  
           * Open the camera (to set mCameraAspectRatio) before calling here.
  
           */
  
          private void finishSurfaceSetup() {
  
              int width = mWindowSurfaceWidth;
  
              int height = mWindowSurfaceHeight;
  
              Log.d(TAG, "finishSurfaceSetup size=" + width + "x" + height +
  
                      " camera=" + mCameraPreviewWidth + "x" + mCameraPreviewHeight);
  
  
  
              // Use full window.
  
              GLES20.glViewport(0, 700, width, height);
  
  
  
              // Simple orthographic projection, with (0,0) in lower-left corner.
  
              Matrix.orthoM(mDisplayProjectionMatrix, 0, 0, width, 0, height, -1, 1);
  
  
  
              // Default position is center of screen.
  
              mPosX = width / 2.0f;
  
              mPosY = height / 2.0f;
  
  
  
              updateGeometry();
  
  
  
              // Ready to go, start the camera.
  
              Log.d(TAG, "starting camera preview");
  
              try {
  
                  mCamera.setPreviewTexture(mCameraTexture);
  
  
  
              } catch (IOException ioe) {
  
                  throw new RuntimeException(ioe);
  
              }
  
              mCamera.startPreview();
  
          }
  
  
  
          /**
  
           * Updates the geometry of mRect, based on the size of the window and the current
  
           * values set by the UI.
  
           */
  
          private void updateGeometry() {
  
              int width = mWindowSurfaceWidth;
  
              int height = mWindowSurfaceHeight;
  
  
  
  
  
              int smallDim = Math.min(width, height);
  
              // Max scale is a bit larger than the screen, so we can show over-size.
  
              float scaled = smallDim * (mSizePercent / 100.0f) * 1.25f;
  
              float cameraAspect = (float) mCameraPreviewWidth / mCameraPreviewHeight;
  
              int newWidth = Math.round(scaled * cameraAspect);
  
              int newHeight = Math.round(scaled);
  
  
  
              float zoomFactor = 1.0f - (mZoomPercent / 100.0f);
  
              int rotAngle = Math.round(360 * (mRotatePercent / 100.0f));
  
  
  
              mRect.setScale(newWidth, newHeight);
  
              mRect.setPosition(mPosX, mPosY);
  
              mRect.setRotation(rotAngle);
  
              mRectDrawable.setScale(zoomFactor);
  
  
  
              mMainHandler.sendRectSize(newWidth, newHeight);
  
              mMainHandler.sendZoomArea(Math.round(mCameraPreviewWidth * zoomFactor),
  
                      Math.round(mCameraPreviewHeight * zoomFactor));
  
              mMainHandler.sendRotateDeg(rotAngle);
  
          }
  
  
  
          @Override   // SurfaceTexture.OnFrameAvailableListener; runs on arbitrary thread
  
          public void onFrameAvailable(SurfaceTexture surfaceTexture) {
  
              mHandler.sendFrameAvailable();
  
          }
  
  
  
          /**
  
           * Handles incoming frame of data from the camera.
  
           */
  
          private void frameAvailable() {
  
              mCameraTexture.updateTexImage();
  
  
  
              draw();
  
          }
  
  
  
          /**
  
           * Draws the scene and submits the buffer.
  
           */
  
          private void draw() {
  
              GlUtil.checkGlError("draw start");
  
  
  
              GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  
              GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
  
              mRect.draw(mTexProgram, mDisplayProjectionMatrix);
  
              mWindowSurface.swapBuffers();
  
  
  
              GlUtil.checkGlError("draw done");
  
          }
  
  
  
          /**
  
           * Opens a camera, and attempts to establish preview mode at the specified width
  
           * and height with a fixed frame rate.
  
           * </p><p>
  
           * Sets mCameraPreviewWidth / mCameraPreviewHeight.
  
           */
  
          private void openCamera(int desiredWidth, int desiredHeight, int desiredFps) {
  
              if (mCamera != null) {
  
                  throw new RuntimeException("camera already initialized");
  
              }
  
  
  
              Camera.CameraInfo info = new Camera.CameraInfo();
  
  
  
              // Try to find a front-facing camera (e.g. for videoconferencing).
  
              int numCameras = Camera.getNumberOfCameras();
  
              for (int i = 0; i &lt; numCameras; i++) {
  
                  Camera.getCameraInfo(i, info);
  
                  if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
  
                      mCamera = Camera.open(i);
  
                      break;
  
                  }
  
              }
  
              if (mCamera == null) {
  
                  Log.d(TAG, "No front-facing camera found; opening default");
  
                  mCamera = Camera.open();    // opens first back-facing camera
  
              }
  
              if (mCamera == null) {
  
                  throw new RuntimeException("Unable to open camera");
  
              }
  
  
  
              Camera.Parameters parms = mCamera.getParameters();
  
  
  
              CameraUtils.choosePreviewSize(parms, desiredWidth, desiredHeight);
  
              parms.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
  
              // Try to set the frame rate to a constant value.
  
              int thousandFps = CameraUtils.chooseFixedPreviewFps(parms, desiredFps * 1000);
  
  
  
              // Give the camera a hint that we're recording video.  This can have a big
  
              // impact on frame rate.
  
              parms.setRecordingHint(true);
  
  
  
              mCamera.setParameters(parms);
  
  
  
              int[] fpsRange = new int[2];
  
              Camera.Size mCameraPreviewSize = parms.getPreviewSize();
  
              parms.getPreviewFpsRange(fpsRange);
  
              String previewFacts = mCameraPreviewSize.width + "x" + mCameraPreviewSize.height;
  
              if (fpsRange[0] == fpsRange[1]) {
  
                  previewFacts += " @" + (fpsRange[0] / 1000.0) + "fps";
  
              } else {
  
                  previewFacts += " @[" + (fpsRange[0] / 1000.0) +
  
                          " - " + (fpsRange[1] / 1000.0) + "] fps";
  
              }
  
              Log.i(TAG, "Camera config: " + previewFacts);
  
  
  
              mCameraPreviewWidth = mCameraPreviewSize.width;
  
              mCameraPreviewHeight = mCameraPreviewSize.height;
  
              mMainHandler.sendCameraParams(mCameraPreviewWidth, mCameraPreviewHeight,
  
                      thousandFps / 1000.0f);
  
          }
  
  
  
          /**
  
           * Stops camera preview, and releases the camera to the system.
  
           */
  
          private void releaseCamera() {
  
              if (mCamera != null) {
  
                  mCamera.stopPreview();
  
                  mCamera.release();
  
                  mCamera = null;
  
                  Log.d(TAG, "releaseCamera -- done");
  
              }
  
          }
  
      }
  
  
  
  }
  
  </p>

• Encode Frames to Video with C Library

  31 juillet 2018, par NetherGranite

  For the sake of continuity, let us assume "RGB values" are the following :

  typedef struct RGB {
  
      uint8_t r, g, b;
  
  } rgb;

  However, if you feel that a different color space is more appropriate for this question, please use that instead.

  How might I go about writing 2D arrays of RGB values to a video in C given an output format and framerate ?

  Before I continue, I should specify that I wish to be able to do this all within one program. I am trying to add functionality to an application that would allow it to compile videos frame by frame without having to leave it.

  Additionally, my needs for this functionality are extremely basic ; I simply need to be able to set individual pixels to certain colors.

  The closest I have come to a solution so far is the C library FFmpeg. Allow me to describe what I was able to learn on my own :

  After looking through its documentation, I came across the function avcodec_send_frame(avctx, frame), whose parameters are of the types AVCodexContext* and const AVFrame* respectively. If these are not the right tools for what I am trying to do, please ignore the rest of the question and instead point me towards what I should be using.

  However, I do not know which fields of avctx and frame must be set manually and which do not. The reason I assume some do not is because both are extremely large structures, but correct me if I am wrong.

  Question 1 : What values of an AVCodecContext and AVFrame must be set ? Of these, what is/are the recommended value(s) for each of them ?

  Additionally, I was only able to find instructions on how to initialize an AVFrame (using av_frame_alloc() and av_frame_get_buffer()) but not for an AVCodexConstant.

  Question 2 : Is there a proper way to initialize an AVCodexConstant ? And just in case, is the method of initializing an AVFrame described above correct ? Do any of the fields of either have a proper method of initialization ?

  Also, I was not able to find official documentation on how to take this AVCodexConstant (which I assume contains the video information) and turn it into a video. I apologize if the documentation for this is easy to find and I just missed it.

  Question 3 : How do I turn an AVCodexConstant into a file of a given format ?

  And, given my limited knowledge :

  Question 4 : Are there any other parts to this process that I am missing, and do I have any of the above parts wrong ?

  ---

  Please keep in mind that I found out about FFmpeg for the first time very recently, and as a result, I am a complete beginner to this. Additionally, my experience with C is very limited, so I would greatly appreciate it if you could note which files need to be included with #include.

  Feel free to even go as far as recommending something other than FFmpeg, just as long as it is written in C. I do not need power-user options, but I would greatly prefer flexibility in what audio and video file types the library can handle.

  ---

  Addressing Potential Duplicates

  I appologize for how long this section is ; I just want to have my bases covered. I heavily apologize, however, if this is in fact a duplicate of a question that I was just unable to find.

  • ffmpeg C API documentation/tutorial [closed] — This question was too open-ended and received answers pointing the asker towards a tutorial at dranger.com, a tutorial that confusingly muddied the waters by focusing heavily on a graphics library of choice. Please do not take this as me saying it is bad ; I am just enough of a beginner that I could not wade through it all.
  • Encoding frames to video with ffmpeg — Although this question seems to have been asking the same thing, it is geared towards Unreal Engine 4, and the asker provided sample code, making it difficult for me to understand which of parts of the accepted answer were necessary for me and which were not.
  • How to write frames to a video file ? — While this also asked the same thing, the accepted answer simply provides a command instead of an explanation of code.
  • YUV Raw frames to video stream — While the accepted answer for this question is a command, the question states that it is looking for a way to encode frames generated by C++ code. Is there some way to run commands in code that I haven’t been able to find ?
  • Converting sequenced frames to video — Not only is the asker’s code written in Python, but it also seems to use already-existing image files as frames.
  • How to write bitmaps as frames to H.264 with x264 in C\C++ ? — The accepted answer seems to describe a process that would take multiple applications, but I could be wrong as I am enough of a beginner that I am not sure exactly what it means other than Step 3.
  • How to write bitmaps as frames to Ogg Theora in C\C++ ? — Although it isn’t a problem that the question specifies the ogg format, it is a problem that the accepted answer suggests libtheora, which appears to only work with ogg files.

• Revision 30227 : oups

  25 juillet 2009, par kent1@… — Log

  oups