Recherche avancée

Sur d’autres sites (5990)

• 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>

• How to Crop the visible portion of landscape video in android ?

  30 août 2016, par Deepak
  1. I am working on Panning and cropping the landscape video using Texture View.I am in a half way that I can pan the landscape video from left to right vice versa by using this example
     https://github.com/crust87/Android-VideoCropView.

  

  

  2. FFMPEG can crop the particular portion of the video by using this command
     ffmpeg -i /sdcard/videokit/in.mp4 -filter:v crop=720:1088:0:0 -c:a
copy /sdcard/videokit/out.mp4

  How can I crop only the video which is visible in Texture View and save it local storage in Android.

  crop=720:1088:0:0 is a hard coded width and height of the video and it is cropping fine.But how can I get the width and height of the visible video in Texture View to crop the visible video and Save it to the local storage in android.

  public class MainActivity extends Activity {
  
  
  
      // Layout Components
  
      private FrameLayout top_frame;
  
  
  
      // Attributes
  
      private String originalPath;
  
      @Override
  
      protected void onCreate(Bundle savedInstanceState) {
  
          super.onCreate(savedInstanceState);
  
          setContentView(R.layout.check);
  
          top_frame = (FrameLayout)findViewById(R.id.top_frame);
  
      }
  
  
  
      @Override
  
      protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  
          if (requestCode == 1000 && resultCode == RESULT_OK) {
  
              final VideoCropView mVideoCropView = new VideoCropView(this);
  
              mVideoCropView.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
  
  
  
                  @Override
  
                  public void onPrepared(MediaPlayer mp) {
  
                      mVideoCropView.start();
  
                  }
  
              });
  
              top_frame.addView(mVideoCropView);
  
              Uri selectedVideoUri = data.getData();
  
  
  
              originalPath = getRealPathFromURI(selectedVideoUri);
  
  
  
              mVideoCropView.setVideoURI(selectedVideoUri);
  
  
  
              mVideoCropView.seekTo(1);
  
          }
  
      }
  
  
  
      public void onButtonLoadClick(View v) {
  
          top_frame.removeAllViews();
  
          Intent lIntent = new Intent(Intent.ACTION_PICK);
  
          lIntent.setType("video/*");
  
          lIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
  
          startActivityForResult(lIntent, 1000);
  
      }
  
  
  
      public String getRealPathFromURI(Uri contentUri) {    // getting image path from gallery.
  
          Cursor cursor = null;
  
          try {
  
              String[] proj = { MediaStore.Images.Media.DATA };
  
              cursor = getApplicationContext().getContentResolver().query(contentUri, proj, null, null, null);
  
              int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
  
              cursor.moveToFirst();
  
              return cursor.getString(column_index);
  
          } finally {
  
              if (cursor != null) {
  
                  cursor.close();
  
              }
  
          }
  
      }
  
  
  
  }

  CropVideoView

  public class VideoCropView extends TextureView implements MediaPlayerControl {
  
      // Constants
  
      private static final String LOG_TAG = "VideoCropView";
  
      private static final int STATE_ERROR = -1;
  
      private static final int STATE_IDLE = 0;
  
      private static final int STATE_PREPARING = 1;
  
      private static final int STATE_PREPARED = 2;
  
      private static final int STATE_PLAYING = 3;
  
      private static final int STATE_PAUSED = 4;
  
      private static final int STATE_PLAYBACK_COMPLETED = 5;
  
  
  
      // MediaPlayer Components
  
      protected Context mContext;
  
      private MediaPlayer mMediaPlayer;
  
      private Surface mSurface;
  
      private OnInfoListener mOnInfoListener;
  
      private OnCompletionListener mOCompletionListener;
  
      private OnErrorListener mOnErrorListener;
  
      private OnPreparedListener mOnPreparedListener;
  
      private OnTranslatePositionListener mOnTranslatePositionListener;
  
  
  
      // CropView Components
  
      private Matrix mMatrix;
  
  
  
      // MediaPlayer Attributes
  
      protected Uri mUri;
  
      private int mCurrentBufferPercentage;
  
      private int mSeekWhenPrepared;
  
      protected int mVideoWidth;
  
      protected int mVideoHeight;
  
  
  
      // CropView Attributes
  
      private float mRatioWidth;
  
      private float mRatioHeight;
  
      private float mPositionX;
  
      private float mPositionY;
  
      private float mBoundX;
  
      private float mBoundY;
  
      private int mRotate;
  
      private float mScaleX;
  
      private float mScaleY;
  
      private float mScale;
  
  
  
      // Working Variables
  
      private int mCurrentState = STATE_IDLE;
  
      private int mTargetState = STATE_IDLE;
  
  
  
      // Touch Event
  
      // past position x, y and move point
  
      float mPastX;
  
      float mPastY;
  
      float mTouchDistance;
  
      private Context context;
  
  
  
      // Constructors
  
      public VideoCropView(final Context context) {
  
          super(context);
  
          mContext = context;
  
  
  
          initAttributes();
  
          initVideoView();
  
      }
  
  
  
      public VideoCropView(final Context context, final AttributeSet attrs) {
  
          super(context, attrs);
  
          mContext = context;
  
  
  
          initAttributes(context, attrs, 0);
  
          initVideoView();
  
      }
  
  
  
      public VideoCropView(Context context, AttributeSet attrs, int defStyleAttr) {
  
          super(context, attrs, defStyleAttr);
  
          mContext = context;
  
  
  
          initAttributes(context, attrs, defStyleAttr);
  
          initVideoView();
  
      }
  
  
  
      private void initAttributes() {
  
          mRatioWidth = 1;
  
          mRatioHeight = 1;
  
      }
  
  
  
      private void initAttributes(Context context, AttributeSet attrs, int defStyleAttr) {
  
          TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.VideoCropView, defStyleAttr, 0);
  
  
  
          mRatioWidth = typedArray.getInteger(R.styleable.VideoCropView_ratio_width, 3);
  
          mRatioHeight = typedArray.getInteger(R.styleable.VideoCropView_ratio_height, 4);
  
      }
  
  
  
      @Override
  
      protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
  
          int heightLayout;
  
          int widthLayout;
  
          widthLayout = MeasureSpec.getSize(widthMeasureSpec);
  
          heightLayout = MeasureSpec.getSize(heightMeasureSpec);
  
          setMeasuredDimension(widthLayout, heightLayout);
  
  
  
          /*if(widthMeasureSpec < heightMeasureSpec){
  
  
  
              int width = MeasureSpec.getSize(widthMeasureSpec);
  
              int height = (int) ((width / mRatioWidth) * mRatioHeight);
  
  
  
  
  
              setMeasuredDimension(width, height);
  
  
  
          }else{
  
  
  
              int width = MeasureSpec.getSize(widthMeasureSpec);
  
              int height =MeasureSpec.getSize(heightMeasureSpec);
  
              setMeasuredDimension(width, height);
  
  
  
          }
  
  */
  
      }
  
  
  
      @Override
  
      public boolean onTouchEvent(MotionEvent event) {
  
          if(mCurrentState == STATE_ERROR || mCurrentState == STATE_IDLE || mCurrentState == STATE_PREPARING) {
  
              return false;
  
          }
  
  
  
          switch (event.getAction()) {
  
              case MotionEvent.ACTION_DOWN:
  
                  mPastX = event.getX();
  
                  mPastY = event.getY();
  
                  mTouchDistance = 0;
  
              case MotionEvent.ACTION_MOVE:
  
                  if(mBoundX!=0 || mBoundY!=0) {
  
                      float dx = event.getX() - mPastX;
  
                      float dy = event.getY() - mPastY;
  
                      updateViewPosition(dx, dy);
  
                      mPastX = event.getX();
  
                      mPastY = event.getY();
  
                      mTouchDistance += (Math.abs(dx) + Math.abs(dy));
  
                  }
  
                  break;
  
              case MotionEvent.ACTION_UP:
  
                  if (mTouchDistance < 25) {
  
                      if (isPlaying()) {
  
                          pause();
  
                      } else {
  
                          start();
  
                      }
  
                  }
  
  
  
                  mTouchDistance = 0;
  
                  break;
  
          }
  
  
  
          return true;
  
      }
  
  
  
      @Override
  
      public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
  
          super.onInitializeAccessibilityEvent(event);
  
          event.setClassName(VideoView.class.getName());
  
      }
  
  
  
      @Override
  
      public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
  
          super.onInitializeAccessibilityNodeInfo(info);
  
          info.setClassName(VideoView.class.getName());
  
      }
  
  
  
      public int resolveAdjustedSize(int desiredSize, int measureSpec) {
  
          Log.d(LOG_TAG, "Resolve called.");
  
          int result = desiredSize;
  
          int specMode = MeasureSpec.getMode(measureSpec);
  
          int specSize = MeasureSpec.getSize(measureSpec);
  
  
  
          switch (specMode) {
  
              case MeasureSpec.UNSPECIFIED:
  
              /*
  
               * Parent says we can be as big as we want. Just don't be larger
  
               * than max size imposed on ourselves.
  
               */
  
                  result = desiredSize;
  
                  break;
  
  
  
              case MeasureSpec.AT_MOST:
  
              /*
  
               * Parent says we can be as big as we want, up to specSize. Don't be
  
               * larger than specSize, and don't be larger than the max size
  
               * imposed on ourselves.
  
               */
  
                  result = Math.min(desiredSize, specSize);
  
                  break;
  
  
  
              case MeasureSpec.EXACTLY:
  
                  // No choice. Do what we are told.
  
                  result = specSize;
  
                  break;
  
          }
  
          return result;
  
      }
  
  
  
      public void initVideoView() {
  
  
  
          mVideoHeight = 0;
  
          mVideoWidth = 0;
  
          setFocusable(false);
  
          setSurfaceTextureListener(mSurfaceTextureListener);
  
          mCurrentState = STATE_IDLE;
  
          mTargetState = STATE_IDLE;
  
  
  
      }
  
  
  
      public void setVideoPath(String path) {
  
          if (path != null) {
  
              setVideoURI(Uri.parse(path));
  
          }
  
      }
  
  
  
      public void setVideoURI(Uri pVideoURI) {
  
          mUri = pVideoURI;
  
          mSeekWhenPrepared = 0;
  
  
  
          MediaMetadataRetriever retriever = new MediaMetadataRetriever();
  
          retriever.setDataSource(mContext, pVideoURI);
  
  
  
          // create thumbnail bitmap
  
          if(android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR1) {
  
              String rotation = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION);
  
  
  
              try {
  
                  mRotate = Integer.parseInt(rotation);
  
              } catch(NumberFormatException e) {
  
                  mRotate = 0;
  
              }
  
          }
  
  
  
          retriever.release();
  
  
  
          openVideo();
  
          requestLayout();
  
          invalidate();
  
      }
  
  
  
      public void stopPlayback() {
  
          if (mMediaPlayer != null) {
  
              mMediaPlayer.stop();
  
              mMediaPlayer.release();
  
              mMediaPlayer = null;
  
              mCurrentState = STATE_IDLE;
  
              mTargetState = STATE_IDLE;
  
          }
  
      }
  
  
  
      public void openVideo() {
  
          if ((mUri == null) || (mSurface == null)) {
  
              // not ready for playback just yet, will try again later
  
              return;
  
          }
  
          // Tell the music playback service to pause
  
          // TODO: these constants need to be published somewhere in the
  
          // framework.
  
          Intent intent = new Intent("com.android.music.musicservicecommand");
  
          intent.putExtra("command", "pause");
  
          mContext.sendBroadcast(intent);
  
  
  
          // we shouldn't clear the target state, because somebody might have
  
          // called start() previously
  
          release(false);
  
          try {
  
              mMediaPlayer = new MediaPlayer();
  
              // TODO: create SubtitleController in MediaPlayer, but we need
  
              // a context for the subtitle renderers
  
  
  
              mMediaPlayer.setOnPreparedListener(mPreparedListener);
  
              mMediaPlayer.setOnVideoSizeChangedListener(mSizeChangedListener);
  
              mMediaPlayer.setOnCompletionListener(mCompletionListener);
  
              mMediaPlayer.setOnErrorListener(mErrorListener);
  
              mMediaPlayer.setOnInfoListener(mInfoListener);
  
              mMediaPlayer.setOnBufferingUpdateListener(mBufferingUpdateListener);
  
              mCurrentBufferPercentage = 0;
  
              mMediaPlayer.setDataSource(mContext, mUri);
  
              mMediaPlayer.setSurface(mSurface);
  
              mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  
  
  
              mMediaPlayer.setScreenOnWhilePlaying(true);
  
              mMediaPlayer.prepareAsync();
  
              mMediaPlayer.setLooping(true);
  
              mCurrentState = STATE_PREPARING;
  
          } catch (IllegalStateException e) {
  
              mCurrentState = STATE_ERROR;
  
              mTargetState = STATE_ERROR;
  
              e.printStackTrace();
  
          } catch (IOException e) {
  
              mCurrentState = STATE_ERROR;
  
              mTargetState = STATE_ERROR;
  
              e.printStackTrace();
  
          }
  
      }
  
  
  
      private OnVideoSizeChangedListener mSizeChangedListener = new OnVideoSizeChangedListener() {
  
          @Override
  
          public void onVideoSizeChanged(final MediaPlayer mp, final int width,
  
                                         final int height) {
  
              mVideoWidth = mp.getVideoWidth();
  
              mVideoHeight = mp.getVideoHeight();
  
  
  
              if (mVideoWidth != 0 && mVideoHeight != 0) {
  
                  requestLayout();
  
                  if(mVideoWidth >= mVideoHeight)
  
                  initVideo();
  
              }
  
          }
  
      };
  
  
  
      private OnPreparedListener mPreparedListener = new OnPreparedListener() {
  
          @Override
  
          public void onPrepared(final MediaPlayer mp) {
  
              mCurrentState = STATE_PREPARED;
  
  
  
              if (mOnPreparedListener != null) {
  
                  mOnPreparedListener.onPrepared(mp);
  
              }
  
  
  
              mVideoWidth = mp.getVideoWidth();
  
              mVideoHeight = mp.getVideoHeight();
  
  
  
              int seekToPosition = mSeekWhenPrepared; // mSeekWhenPrepared may be
  
              // changed after seekTo()
  
              if (seekToPosition != 0) {
  
                  seekTo(seekToPosition);
  
              }
  
  
  
              if ((mVideoWidth != 0) && (mVideoHeight != 0)) {
  
                  if(mVideoWidth >= mVideoHeight) initVideo();
  
  
  
                  if (mTargetState == STATE_PLAYING) {
  
                      start();
  
                  }
  
              } else {
  
                  // We don't know the video size yet, but should start anyway.
  
                  // The video size might be reported to us later.
  
                  if (mTargetState == STATE_PLAYING) {
  
                      start();
  
                  }
  
              }
  
          }
  
      };
  
  
  
      private OnCompletionListener mCompletionListener = new OnCompletionListener() {
  
          @Override
  
          public void onCompletion(final MediaPlayer mp) {
  
              mCurrentState = STATE_PLAYBACK_COMPLETED;
  
              mTargetState = STATE_PLAYBACK_COMPLETED;
  
  
  
              if (mOCompletionListener != null) {
  
                  mOCompletionListener.onCompletion(mMediaPlayer);
  
              }
  
          }
  
      };
  
  
  
      private OnInfoListener mInfoListener = new OnInfoListener() {
  
          public boolean onInfo(MediaPlayer mp, int arg1, int arg2) {
  
              if (mOnInfoListener != null) {
  
                  mOnInfoListener.onInfo(mp, arg1, arg2);
  
              }
  
              return true;
  
          }
  
      };
  
  
  
      private OnErrorListener mErrorListener = new OnErrorListener() {
  
          @Override
  
          public boolean onError(MediaPlayer mp, int framework_err, int impl_err) {
  
              Log.d(LOG_TAG, "Error: " + framework_err + "," + impl_err);
  
              mCurrentState = STATE_ERROR;
  
              mTargetState = STATE_ERROR;
  
  
  
              /* If an error handler has been supplied, use it and finish. */
  
              if (mOnErrorListener != null) {
  
                  if (mOnErrorListener.onError(mMediaPlayer, framework_err,
  
                          impl_err)) {
  
                      return true;
  
                  }
  
              }
  
              return true;
  
          }
  
      };
  
  
  
      private OnBufferingUpdateListener mBufferingUpdateListener = new OnBufferingUpdateListener() {
  
          @Override
  
          public void onBufferingUpdate(final MediaPlayer mp, final int percent) {
  
              mCurrentBufferPercentage = percent;
  
          }
  
      };
  
  
  
      public void setOnPreparedListener(OnPreparedListener listener) {
  
          mOnPreparedListener = listener;
  
      }
  
  
  
      public void setOnCompletionListener(OnCompletionListener listener) {
  
          mOCompletionListener = listener;
  
      }
  
  
  
      public void setOnErrorListener(OnErrorListener listener) {
  
          mOnErrorListener = listener;
  
      }
  
  
  
      public void setOnInfoListener(OnInfoListener listener) {
  
          mOnInfoListener = listener;
  
      }
  
  
  
      private void release(boolean cleartargetstate) {
  
          if (mMediaPlayer != null) {
  
              mMediaPlayer.reset();
  
              mMediaPlayer.release();
  
              mMediaPlayer = null;
  
              mCurrentState = STATE_IDLE;
  
              if (cleartargetstate) {
  
                  mTargetState = STATE_IDLE;
  
              }
  
          }
  
      }
  
  
  
      @Override
  
      public void start() {
  
          if (isInPlaybackState()) {
  
              mMediaPlayer.start();
  
              mCurrentState = STATE_PLAYING;
  
  
  
          }
  
          mTargetState = STATE_PLAYING;
  
      }
  
  
  
      @Override
  
      public void pause() {
  
          if (isInPlaybackState()) {
  
              if (mMediaPlayer.isPlaying()) {
  
                  mMediaPlayer.pause();
  
                  mCurrentState = STATE_PAUSED;
  
              }
  
          }
  
  
  
          mTargetState = STATE_PAUSED;
  
      }
  
  
  
      @Override
  
      public int getDuration() {
  
          if (isInPlaybackState()) {
  
              return mMediaPlayer.getDuration();
  
          }
  
  
  
          return -1;
  
      }
  
  
  
      @Override
  
      public int getCurrentPosition() {
  
          if (isInPlaybackState()) {
  
              return mMediaPlayer.getCurrentPosition();
  
          }
  
          return 0;
  
      }
  
  
  
      @Override
  
      public void seekTo(int msec) {
  
          if (isInPlaybackState()) {
  
              mMediaPlayer.seekTo(msec);
  
              mSeekWhenPrepared = 0;
  
          } else {
  
              mSeekWhenPrepared = msec;
  
          }
  
      }
  
  
  
      @Override
  
      public boolean isPlaying() {
  
          return isInPlaybackState() && mMediaPlayer.isPlaying();
  
      }
  
  
  
      @Override
  
      public int getBufferPercentage() {
  
          if (mMediaPlayer != null) {
  
              return mCurrentBufferPercentage;
  
          }
  
          return 0;
  
      }
  
  
  
      private boolean isInPlaybackState() {
  
          return (mMediaPlayer != null && mCurrentState != STATE_ERROR
  
                  && mCurrentState != STATE_IDLE && mCurrentState != STATE_PREPARING);
  
      }
  
  
  
      @Override
  
      public boolean canPause() {
  
          return false;
  
      }
  
  
  
      @Override
  
      public boolean canSeekBackward() {
  
          return false;
  
      }
  
  
  
      @Override
  
      public boolean canSeekForward() {
  
          return false;
  
      }
  
  
  
      @Override
  
      public int getAudioSessionId() {
  
          return -1;
  
      }
  
  
  
      SurfaceTextureListener mSurfaceTextureListener = new SurfaceTextureListener() {
  
          @Override
  
          public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
  
              mSurface = new Surface(surface);
  
              openVideo();
  
          }
  
  
  
          @Override
  
          public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
  
              boolean isValidState = (mTargetState == STATE_PLAYING);
  
              boolean hasValidSize = (mVideoWidth == width && mVideoHeight == height);
  
              if (mMediaPlayer != null && isValidState && hasValidSize) {
  
                  start();
  
              }
  
          }
  
  
  
          @Override
  
          public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
  
              if (mMediaPlayer != null) {
  
                  mMediaPlayer.reset();
  
                  mMediaPlayer.release();
  
                  mMediaPlayer = null;
  
              }
  
  
  
              if (mSurface != null) {
  
                  mSurface.release();
  
                  mSurface = null;
  
              }
  
  
  
              return true;
  
          }
  
  
  
          @Override
  
          public void onSurfaceTextureUpdated(final SurfaceTexture surface) {
  
  
  
          }
  
      };
  
  
  
      @Override
  
      protected void onVisibilityChanged(View changedView, int visibility) {
  
          super.onVisibilityChanged(changedView, visibility);
  
  
  
          if (visibility == View.INVISIBLE || visibility == View.GONE) {
  
              if (isPlaying()) {
  
                  stopPlayback();
  
              }
  
          }
  
      }
  
  
  
      public float getScale() {
  
          return mScale;
  
      }
  
  
  
      private void initVideo() {
  
          try {
  
                  int width = getWidth();
  
                  int height = getHeight();
  
                  mScaleX = 1.0f;
  
                  mScaleY = 1.0f;
  
                  mPositionX = 0;
  
                  mPositionY = 0;
  
                  mBoundX = 0;
  
                  mBoundY = 0;
  
                  mMatrix = new Matrix();
  
  
  
                  mScaleX = (float) mVideoWidth / width;
  
                  mScaleY = (float) mVideoHeight / height;
  
  
  
                  mBoundX = width - mVideoWidth / mScaleY;
  
                  mBoundY = height - mVideoHeight / mScaleX;
  
  
  
                  if (mScaleX < mScaleY) {
  
                      mScale = mScaleX;
  
                      mScaleY = mScaleY * (1.0f / mScaleX);
  
                      mScaleX = 1.0f;
  
                      mBoundX = 0;
  
                  } else {
  
                      mScale = mScaleY;
  
                      mScaleX = mScaleX * (1.0f / mScaleY);
  
                      mScaleY = 1.0f;
  
                      mBoundY = 0;
  
                  }
  
  
  
                  mMatrix = new Matrix();
  
                  mMatrix.setScale(mScaleX, mScaleY);
  
                  setTransform(mMatrix);
  
          } catch (NumberFormatException e) {
  
              e.printStackTrace();
  
          }
  
      }
  
  
  
      public void updateViewPosition(float x, float y) {
  
  
  
          float nextX = mPositionX + x;
  
          float nextY = mPositionY + y;
  
  
  
          if(mScaleX == 1.0f) {
  
              x = 0;
  
          } else {
  
              if(nextX > 0) {
  
                  x = -mPositionX;
  
                  mPositionX = mPositionX + x;
  
              } else if(nextX < mBoundX) {
  
                  x = mBoundX - mPositionX;
  
                  mPositionX = mPositionX + x;
  
              } else {
  
                  mPositionX = nextX;
  
              }
  
          }
  
  
  
          if(mScaleY == 1.0f) {
  
              y = 0;
  
          } else {
  
              if(nextY > 0) {
  
                  y = -mPositionY;
  
                  mPositionY = mPositionY + y;
  
              } else if(nextY < mBoundY) {
  
                  y = mBoundY - mPositionY;
  
                  mPositionY = mPositionY + y;
  
              } else {
  
                  mPositionY = nextY;
  
              }
  
          }
  
  
  
          if(mOnTranslatePositionListener != null) {
  
              mOnTranslatePositionListener.onTranslatePosition(mPositionX, mPositionY, mPositionX * -mScale, mPositionY * -mScale);
  
          }
  
  
  
          mMatrix.postTranslate(x, y);
  
          setTransform(mMatrix);
  
          invalidate();
  
      }
  
  
  
  //  public void setOriginalRatio() {
  
  //      if(mVideoWidth != 0 && mVideoHeight != 0) {
  
  //          int gcd = gcd(mVideoWidth, mVideoHeight);
  
  //          setRatio(mVideoWidth / gcd, mVideoHeight / gcd);
  
  //      }
  
  //  }
  
  
  
      public int gcd(int n, int m) {
  
          while (m != 0) {
  
              int t = n % m;
  
              n = m;
  
              m = t;
  
          }
  
  
  
          return Math.abs(n);
  
      }
  
  
  
  //  public void setRatio(float ratioWidth, float ratioHeight) {
  
  //      mRatioWidth = ratioWidth;
  
  //      mRatioHeight = ratioHeight;
  
  //
  
  //      int seek = getCurrentPosition();
  
  //
  
  //      requestLayout();
  
  //      invalidate();
  
  //      openVideo();
  
  //
  
  //      seekTo(seek);
  
  //  }
  
  
  
  
  
      public float getRatioWidth() {
  
          return mRatioWidth;
  
      }
  
  
  
      public float getRatioHeight() {
  
          return mRatioHeight;
  
      }
  
  
  
      public float getRealPositionX() {
  
          return mPositionX * -mScale;
  
      }
  
  
  
      public float getRealPositionY() {
  
          return mPositionY * -mScale;
  
      }
  
  
  
      public int getVideoWidth() {
  
          return mVideoWidth;
  
      }
  
  
  
      public int getVideoHeight() {
  
          return mVideoHeight;
  
      }
  
  
  
      public int getRotate() {
  
          return mRotate;
  
      }
  
  
  
      public void setOnTranslatePositionListener(OnTranslatePositionListener pOnTranslatePositionListener) {
  
          mOnTranslatePositionListener = pOnTranslatePositionListener;
  
      }
  
  
  
      public void setContext(Context context) {
  
          this.context = context;
  
      }
  
  
  
      public interface OnTranslatePositionListener {
  
          public abstract void onTranslatePosition(float x, float y, float rx, float ry);
  
      }
  
  }

  FFMPEG for cropping particular portion

  ffmpeg -i /sdcard/videokit/in.mp4 -filter:v crop=720:1088:0:0 -c:a copy /sdcard/videokit/out.mp4

  public class SimpleExample extends Activity {
  
  
  
      String workFolder = null;
  
      String demoVideoFolder = null;
  
      String demoVideoPath = null;
  
      String vkLogPath = null;
  
      private boolean commandValidationFailedFlag = false;
  
  
  
  
  
      @Override
  
      public void onCreate(Bundle savedInstanceState) {
  
          super.onCreate(savedInstanceState);
  
          setContentView(R.layout.ffmpeg_demo_client_1);
  
  
  
          demoVideoFolder = Environment.getExternalStorageDirectory().getAbsolutePath() + "/videokit/";
  
          demoVideoPath = demoVideoFolder + "in.mp4";
  
  
  
          Log.i(Prefs.TAG, getString(R.string.app_name) + " version: " + GeneralUtils.getVersionName(getApplicationContext()) );
  
          workFolder = getApplicationContext().getFilesDir().getAbsolutePath() + "/";
  
          //Log.i(Prefs.TAG, "workFolder: " + workFolder);
  
          vkLogPath = workFolder + "vk.log";
  
  
  
          GeneralUtils.copyLicenseFromAssetsToSDIfNeeded(this, workFolder);
  
          GeneralUtils.copyDemoVideoFromAssetsToSDIfNeeded(this, demoVideoFolder);
  
  
  
          Button invoke =  (Button)findViewById(R.id.invokeButton);
  
          invoke.setOnClickListener(new OnClickListener() {
  
              public void onClick(View v){
  
                  Log.i(Prefs.TAG, "run clicked.");
  
                  if (GeneralUtils.checkIfFileExistAndNotEmpty(demoVideoPath)) {
  
                      new TranscdingBackground(SimpleExample.this).execute();
  
                  }
  
                  else {
  
                      Toast.makeText(getApplicationContext(), demoVideoPath + " not found", Toast.LENGTH_LONG).show();
  
                  }
  
              }
  
          });
  
  
  
          int rc = GeneralUtils.isLicenseValid(getApplicationContext(), workFolder);
  
          Log.i(Prefs.TAG, "License check RC: " + rc);
  
      }
  
  
  
      public class TranscdingBackground extends AsyncTask
  
      {
  
  
  
          ProgressDialog progressDialog;
  
          Activity _act;
  
          String commandStr;
  
  
  
          public TranscdingBackground (Activity act) {
  
              _act = act;
  
          }
  
  
  
  
  
  
  
          @Override
  
          protected void onPreExecute() {
  
              EditText commandText = (EditText)findViewById(R.id.CommandText);
  
              commandStr = commandText.getText().toString();
  
  
  
              progressDialog = new ProgressDialog(_act);
  
              progressDialog.setMessage("FFmpeg4Android Transcoding in progress...");
  
              progressDialog.show();
  
  
  
          }
  
  
  
          protected Integer doInBackground(String... paths) {
  
              Log.i(Prefs.TAG, "doInBackground started...");
  
  
  
              // delete previous log
  
              boolean isDeleted = GeneralUtils.deleteFileUtil(workFolder + "/vk.log");
  
              Log.i(Prefs.TAG, "vk deleted: " + isDeleted);
  
  
  
              PowerManager powerManager = (PowerManager)_act.getSystemService(Activity.POWER_SERVICE);
  
              WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "VK_LOCK");
  
              Log.d(Prefs.TAG, "Acquire wake lock");
  
              wakeLock.acquire();
  
  
  
              ///////////// Set Command using code (overriding the UI EditText) /////
  
              //commandStr = "ffmpeg -y -i /sdcard/videokit/in.mp4 -strict experimental -s 320x240 -r 30 -aspect 3:4 -ab 48000 -ac 2 -ar 22050 -vcodec mpeg4 -b 2097152 /sdcard/videokit/out.mp4";
  
              //String[] complexCommand = {"ffmpeg", "-y" ,"-i", "/sdcard/videokit/in.mp4","-strict","experimental","-s", "160x120","-r","25", "-vcodec", "mpeg4", "-b", "150k", "-ab","48000", "-ac", "2", "-ar", "22050", "/sdcard/videokit/out.mp4"};
  
              ///////////////////////////////////////////////////////////////////////
  
  
  
  
  
              LoadJNI vk = new LoadJNI();
  
              try {
  
  
  
  
  
                  vk.run(GeneralUtils.utilConvertToComplex(commandStr), workFolder, getApplicationContext());
  
  
  
  
  
  
  
  
  
                  GeneralUtils.copyFileToFolder(vkLogPath, demoVideoFolder);
  
  
  
  
  
              } catch (Throwable e) {
  
                  Log.e(Prefs.TAG, "vk run exeption.", e);
  
              }
  
              finally {
  
                  if (wakeLock.isHeld())
  
                      wakeLock.release();
  
                  else{
  
                      Log.i(Prefs.TAG, "Wake lock is already released, doing nothing");
  
                  }
  
              }
  
              Log.i(Prefs.TAG, "doInBackground finished");
  
              return Integer.valueOf(0);
  
          }
  
  
  
          protected void onProgressUpdate(Integer... progress) {
  
          }
  
  
  
          @Override
  
          protected void onCancelled() {
  
              Log.i(Prefs.TAG, "onCancelled");
  
              //progressDialog.dismiss();
  
              super.onCancelled();
  
          }
  
  
  
  
  
          @Override
  
          protected void onPostExecute(Integer result) {
  
              Log.i(Prefs.TAG, "onPostExecute");
  
              progressDialog.dismiss();
  
              super.onPostExecute(result);
  
  
  
              // finished Toast
  
              String rc = null;
  
              if (commandValidationFailedFlag) {
  
                  rc = "Command Vaidation Failed";
  
              }
  
              else {
  
                  rc = GeneralUtils.getReturnCodeFromLog(vkLogPath);
  
              }
  
              final String status = rc;
  
              SimpleExample.this.runOnUiThread(new Runnable() {
  
                  public void run() {
  
                      Toast.makeText(SimpleExample.this, status, Toast.LENGTH_LONG).show();
  
                      if (status.equals("Transcoding Status: Failed")) {
  
                          Toast.makeText(SimpleExample.this, "Check: " + vkLogPath + " for more information.", Toast.LENGTH_LONG).show();
  
                      }
  
                  }
  
              });
  
          }
  
  
  
      }
  
  
  
  
  
  }

• Should H.264 bit rate be multiples of 8 ?

  31 août 2016, par Dan Sharp

  I’m working on a video platform receiving H.264 video and building an HLS stream (transmuxing the H.264 to Mpeg2 TS segments via calls to ffmpeg).

  I wanted to set the bit rate to be about 2000 kbps, but I’m wondering : does it matter if it’s 2000 or 2048 ?

  In other words, do things calculate better if the bit rate is multiples of 8, like 512 or 2024 or 2048 ?

  I don’t know enough about how the bit rate is used, either on the sending side (camera) or on the processing side (ffmpeg).

  From tests... I can’t see any noticeable difference between 2000 and 2048, but maybe one is slightly better than another for the transmuxing and segmenting ?

  I welcome any thoughts/advice.