Recherche avancée

Sur d’autres sites (8538)

• Trouble syncing libavformat/ffmpeg with x264 and RTP

  26 décembre 2012, par Jacob Peddicord

  I've been working on some streaming software that takes live feeds
  from various kinds of cameras and streams over the network using
  H.264. To accomplish this, I'm using the x264 encoder directly (with
  the "zerolatency" preset) and feeding NALs as they are available to
  libavformat to pack into RTP (ultimately RTSP). Ideally, this
  application should be as real-time as possible. For the most part,
  this has been working well.

  Unfortunately, however, there is some sort of synchronization issue :
  any video playback on clients seems to show a few smooth frames,
  followed by a short pause, then more frames ; repeat. Additionally,
  there appears to be approximately a 4-second delay. This happens with
  every video player I've tried : Totem, VLC, and basic gstreamer pipes.

  I've boiled it all down to a somewhat small test case :

  #include 
  
  #include 
  
  #include 
  
  #include 
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libswscale></libswscale>swscale.h>
  
  
  
  #define WIDTH       640
  
  #define HEIGHT      480
  
  #define FPS         30
  
  #define BITRATE     400000
  
  #define RTP_ADDRESS "127.0.0.1"
  
  #define RTP_PORT    49990
  
  
  
  struct AVFormatContext* avctx;
  
  struct x264_t* encoder;
  
  struct SwsContext* imgctx;
  
  
  
  uint8_t test = 0x80;
  
  
  
  
  
  void create_sample_picture(x264_picture_t* picture)
  
  {
  
      // create a frame to store in
  
      x264_picture_alloc(picture, X264_CSP_I420, WIDTH, HEIGHT);
  
  
  
      // fake image generation
  
      // disregard how wrong this is; just writing a quick test
  
      int strides = WIDTH / 8;
  
      uint8_t* data = malloc(WIDTH * HEIGHT * 3);
  
      memset(data, test, WIDTH * HEIGHT * 3);
  
      test = (test &lt;&lt; 1) | (test >> (8 - 1));
  
  
  
      // scale the image
  
      sws_scale(imgctx, (const uint8_t* const*) &amp;data, &amp;strides, 0, HEIGHT,
  
                picture->img.plane, picture->img.i_stride);
  
  }
  
  
  
  int encode_frame(x264_picture_t* picture, x264_nal_t** nals)
  
  {
  
      // encode a frame
  
      x264_picture_t pic_out;
  
      int num_nals;
  
      int frame_size = x264_encoder_encode(encoder, nals, &amp;num_nals, picture, &amp;pic_out);
  
  
  
      // ignore bad frames
  
      if (frame_size &lt; 0)
  
      {
  
          return frame_size;
  
      }
  
  
  
      return num_nals;
  
  }
  
  
  
  void stream_frame(uint8_t* payload, int size)
  
  {
  
      // initalize a packet
  
      AVPacket p;
  
      av_init_packet(&amp;p);
  
      p.data = payload;
  
      p.size = size;
  
      p.stream_index = 0;
  
      p.flags = AV_PKT_FLAG_KEY;
  
      p.pts = AV_NOPTS_VALUE;
  
      p.dts = AV_NOPTS_VALUE;
  
  
  
      // send it out
  
      av_interleaved_write_frame(avctx, &amp;p);
  
  }
  
  
  
  int main(int argc, char* argv[])
  
  {
  
      // initalize ffmpeg
  
      av_register_all();
  
  
  
      // set up image scaler
  
      // (in-width, in-height, in-format, out-width, out-height, out-format, scaling-method, 0, 0, 0)
  
      imgctx = sws_getContext(WIDTH, HEIGHT, PIX_FMT_MONOWHITE,
  
                              WIDTH, HEIGHT, PIX_FMT_YUV420P,
  
                              SWS_FAST_BILINEAR, NULL, NULL, NULL);
  
  
  
      // set up encoder presets
  
      x264_param_t param;
  
      x264_param_default_preset(&amp;param, "ultrafast", "zerolatency");
  
  
  
      param.i_threads = 3;
  
      param.i_width = WIDTH;
  
      param.i_height = HEIGHT;
  
      param.i_fps_num = FPS;
  
      param.i_fps_den = 1;
  
      param.i_keyint_max = FPS;
  
      param.b_intra_refresh = 0;
  
      param.rc.i_bitrate = BITRATE;
  
      param.b_repeat_headers = 1; // whether to repeat headers or write just once
  
      param.b_annexb = 1;         // place start codes (1) or sizes (0)
  
  
  
      // initalize
  
      x264_param_apply_profile(&amp;param, "high");
  
      encoder = x264_encoder_open(&amp;param);
  
  
  
      // at this point, x264_encoder_headers can be used, but it has had no effect
  
  
  
      // set up streaming context. a lot of error handling has been ommitted
  
      // for brevity, but this should be pretty standard.
  
      avctx = avformat_alloc_context();
  
      struct AVOutputFormat* fmt = av_guess_format("rtp", NULL, NULL);
  
      avctx->oformat = fmt;
  
  
  
      snprintf(avctx->filename, sizeof(avctx->filename), "rtp://%s:%d", RTP_ADDRESS, RTP_PORT);
  
      if (url_fopen(&amp;avctx->pb, avctx->filename, URL_WRONLY) &lt; 0)
  
      {
  
          perror("url_fopen failed");
  
          return 1;
  
      }
  
      struct AVStream* stream = av_new_stream(avctx, 1);
  
  
  
      // initalize codec
  
      AVCodecContext* c = stream->codec;
  
      c->codec_id = CODEC_ID_H264;
  
      c->codec_type = AVMEDIA_TYPE_VIDEO;
  
      c->flags = CODEC_FLAG_GLOBAL_HEADER;
  
      c->width = WIDTH;
  
      c->height = HEIGHT;
  
      c->time_base.den = FPS;
  
      c->time_base.num = 1;
  
      c->gop_size = FPS;
  
      c->bit_rate = BITRATE;
  
      avctx->flags = AVFMT_FLAG_RTP_HINT;
  
  
  
      // write the header
  
      av_write_header(avctx);
  
  
  
      // make some frames
  
      for (int frame = 0; frame &lt; 10000; frame++)
  
      {
  
          // create a sample moving frame
  
          x264_picture_t* pic = (x264_picture_t*) malloc(sizeof(x264_picture_t));
  
          create_sample_picture(pic);
  
  
  
          // encode the frame
  
          x264_nal_t* nals;
  
          int num_nals = encode_frame(pic, &amp;nals);
  
  
  
          if (num_nals &lt; 0)
  
              printf("invalid frame size: %d\n", num_nals);
  
  
  
          // send out NALs
  
          for (int i = 0; i &lt; num_nals; i++)
  
          {
  
              stream_frame(nals[i].p_payload, nals[i].i_payload);
  
          }
  
  
  
          // free up resources
  
          x264_picture_clean(pic);
  
          free(pic);
  
  
  
          // stream at approx 30 fps
  
          printf("frame %d\n", frame);
  
          usleep(33333);
  
      }
  
  
  
      return 0;
  
  }

  This test shows black lines on a white background that
  should move smoothly to the left. It has been written for ffmpeg 0.6.5
  but the problem can be reproduced on 0.8 and 0.10 (from what I've tested so far). I've taken some shortcuts in error handling to make this example as short as
  possible while still showing the problem, so please excuse some of the
  nasty code. I should also note that while an SDP is not used here, I
  have tried using that already with similar results. The test can be
  compiled with :

  gcc -g -std=gnu99 streamtest.c -lswscale -lavformat -lx264 -lm -lpthread -o streamtest

  It can be played with gtreamer directly :

  gst-launch udpsrc port=49990 ! application/x-rtp,payload=96,clock-rate=90000 ! rtph264depay ! decodebin ! xvimagesink

  You should immediately notice the stuttering. One common "fix" I've
  seen all over the Internet is to add sync=false to the pipeline :

  gst-launch udpsrc port=49990 ! application/x-rtp,payload=96,clock-rate=90000 ! rtph264depay ! decodebin ! xvimagesink sync=false

  This causes playback to be smooth (and near-realtime), but is a
  non-solution and only works with gstreamer. I'd like to fix the
  problem at the source. I've been able to stream with near-identical
  parameters using raw ffmpeg and haven't had any issues :

  ffmpeg -re -i sample.mp4 -vcodec libx264 -vpre ultrafast -vpre baseline -b 400000 -an -f rtp rtp://127.0.0.1:49990 -an

  So clearly I'm doing something wrong. But what is it ?

• ffmpeg-Create the video slideshow with effect ? [on hold]

  1er octobre 2013, par Lily Shukla

  I want to make video slide show with image using the ffmpeg.
  i try the code

  Using a single image as an input

  If you want to create a video out of just one image, this will do (output video duration is set to 30 seconds with -t 30) :

  ffmpeg -loop 1 -i img.png -c:v libx264 -t 30 -pix_fmt yuv420p out.mp4

  but sir it only showing the picture without any effect.
  i want to add effect like we see in power point.
  plz sie how to do it
  ffmpeg-Create the video slideshow with effect ???

• Audio & Video not synchronized properly if i merged more videos in mp4parser

  1er octobre 2013, par maniya

  I have used mp4parser for merging video with dynamic pause and record video capture for max 6 second recording. In preview its working fine when recorded video with minimum pause/record, If i tried with more than 3 pause/record mean the last video file not get merged properly with audio.At the start of the video the sync is ok but at the end the video hanged and audio playing in screen for the remaining file duration about 1sec.

  My Recording manager

  public class RecordingManager implements Camera.ErrorCallback, MediaRecorder.OnErrorListener, MediaRecorder.OnInfoListener {
  
  
  
      private static final String TAG = RecordingManager.class.getSimpleName();
  
      private static final int FOCUS_AREA_RADIUS = 32;
  
      private static final int FOCUS_MAX_VALUE = 1000;
  
      private static final int FOCUS_MIN_VALUE = -1000;
  
      private static final long MINIMUM_RECORDING_TIME = 2000;
  
      private static final int MAXIMUM_RECORDING_TIME = 70 * 1000;
  
      private static final long LOW_STORAGE_THRESHOLD = 5 * 1024 * 1024;
  
      private static final long RECORDING_FILE_LIMIT = 100 * 1024 * 1024;
  
  
  
      private boolean paused = true;
  
  
  
      private MediaRecorder mediaRecorder = null;
  
      private boolean recording = false;
  
  
  
      private FrameLayout previewFrame = null;
  
  
  
      private boolean mPreviewing = false;
  
  
  
  //    private TextureView mTextureView = null;
  
  //    private SurfaceTexture mSurfaceTexture = null;
  
  //    private boolean mSurfaceTextureReady = false;
  
  //
  
      private SurfaceView surfaceView = null;
  
      private SurfaceHolder surfaceHolder = null;
  
      private boolean surfaceViewReady = false;
  
  
  
      private Camera camera = null;
  
      private Camera.Parameters cameraParameters = null;
  
      private CamcorderProfile camcorderProfile = null;
  
  
  
      private int mOrientation = -1;
  
      private OrientationEventListener mOrientationEventListener = null;
  
  
  
      private long mStartRecordingTime;
  
      private int mVideoWidth;
  
      private int mVideoHeight;
  
      private long mStorageSpace;
  
  
  
      private Handler mHandler = new Handler();
  
  //    private Runnable mUpdateRecordingTimeTask = new Runnable() {
  
  //        @Override
  
  //        public void run() {
  
  //            long recordingTime = System.currentTimeMillis() - mStartRecordingTime;
  
  //            Log.d(TAG, String.format("Recording time:%d", recordingTime));
  
  //            mHandler.postDelayed(this, CLIP_GRAPH_UPDATE_INTERVAL);
  
  //        }
  
  //    };
  
      private Runnable mStopRecordingTask = new Runnable() {
  
          @Override
  
          public void run() {
  
              stopRecording();
  
          }
  
      };
  
  
  
      private static RecordingManager mInstance = null;
  
      private Activity currentActivity = null;
  
      private String destinationFilepath = "";
  
      private String snapshotFilepath = "";
  
  
  
      public static RecordingManager getInstance(Activity activity, FrameLayout previewFrame) {
  
          if (mInstance == null || mInstance.currentActivity != activity) {
  
              mInstance = new RecordingManager(activity, previewFrame);
  
          }
  
          return mInstance;
  
      }
  
  
  
      private RecordingManager(Activity activity, FrameLayout previewFrame) {
  
          currentActivity = activity;
  
          this.previewFrame = previewFrame;
  
      }
  
  
  
      public int getVideoWidth() {
  
          return this.mVideoWidth;
  
      }
  
      public int getVideoHeight() {
  
          return this.mVideoHeight;
  
      }
  
      public void setDestinationFilepath(String filepath) {
  
          this.destinationFilepath = filepath;
  
      }
  
      public String getDestinationFilepath() {
  
          return this.destinationFilepath;
  
      }
  
      public void setSnapshotFilepath(String filepath) {
  
          this.snapshotFilepath = filepath;
  
      }
  
      public String getSnapshotFilepath() {
  
          return this.snapshotFilepath;
  
      }
  
      public void init(String videoPath, String snapshotPath) {
  
          Log.v(TAG, "init.");
  
          setDestinationFilepath(videoPath);
  
          setSnapshotFilepath(snapshotPath);
  
          if (!Utils.isExternalStorageAvailable()) {
  
              showStorageErrorAndFinish();
  
              return;
  
          }
  
  
  
          openCamera();
  
          if (camera == null) {
  
              showCameraErrorAndFinish();
  
              return;
  
          }
  
  
  
  
  
  
  
      public void onResume() {
  
          Log.v(TAG, "onResume.");
  
          paused = false;
  
  
  
          // Open the camera
  
          if (camera == null) {
  
              openCamera();
  
              if (camera == null) {
  
                  showCameraErrorAndFinish();
  
                  return;
  
              }
  
          }
  
  
  
          // Initialize the surface texture or surface view
  
  //        if (useTexture() && mTextureView == null) {
  
  //            initTextureView();
  
  //            mTextureView.setVisibility(View.VISIBLE);
  
  //        } else if (!useTexture() && mSurfaceView == null) {
  
              initSurfaceView();
  
              surfaceView.setVisibility(View.VISIBLE);
  
  //        }
  
  
  
          // Start the preview
  
          if (!mPreviewing) {
  
              startPreview();
  
          }
  
      }
  
  
  
      private void openCamera() {
  
          Log.v(TAG, "openCamera");
  
          try {
  
              camera = Camera.open();
  
              camera.setErrorCallback(this);
  
              camera.setDisplayOrientation(90); // Since we only support portrait mode
  
              cameraParameters = camera.getParameters();
  
          } catch (RuntimeException e) {
  
              e.printStackTrace();
  
              camera = null;
  
          }
  
      }
  
  
  
      private void closeCamera() {
  
          Log.v(TAG, "closeCamera");
  
          if (camera == null) {
  
              Log.d(TAG, "Already stopped.");
  
              return;
  
          }
  
  
  
          camera.setErrorCallback(null);
  
          if (mPreviewing) {
  
              stopPreview();
  
          }
  
          camera.release();
  
          camera = null;
  
      }
  
  
  
  
  
  
  
  
  
      private void initSurfaceView() {
  
          surfaceView = new SurfaceView(currentActivity);
  
          surfaceView.getHolder().addCallback(new SurfaceViewCallback());
  
          surfaceView.setVisibility(View.GONE);
  
          FrameLayout.LayoutParams params = new LayoutParams(
  
                  LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT, Gravity.CENTER);
  
          surfaceView.setLayoutParams(params);
  
          Log.d(TAG, "add surface view to preview frame");
  
          previewFrame.addView(surfaceView);
  
      }
  
  
  
      private void releaseSurfaceView() {
  
          if (surfaceView != null) {
  
              previewFrame.removeAllViews();
  
              surfaceView = null;
  
              surfaceHolder = null;
  
              surfaceViewReady = false;
  
          }
  
      }
  
  
  
      private void startPreview() {
  
  //        if ((useTexture() && !mSurfaceTextureReady) || (!useTexture() && !mSurfaceViewReady)) {
  
  //            return;
  
  //        }
  
  
  
          Log.v(TAG, "startPreview.");
  
          if (mPreviewing) {
  
              stopPreview();
  
          }
  
  
  
          setCameraParameters();
  
          resizePreview();
  
  
  
          try {
  
  //            if (useTexture()) {
  
  //                mCamera.setPreviewTexture(mSurfaceTexture);
  
  //            } else {
  
                  camera.setPreviewDisplay(surfaceHolder);
  
  //            }
  
              camera.startPreview();
  
              mPreviewing = true;
  
          } catch (Exception e) {
  
              closeCamera();
  
              e.printStackTrace();
  
              Log.e(TAG, "startPreview failed.");
  
          }
  
  
  
      }
  
  
  
      private void stopPreview() {
  
          Log.v(TAG, "stopPreview");
  
          if (camera != null) {
  
              camera.stopPreview();
  
              mPreviewing = false;
  
          }
  
      }
  
  
  
      public void onPause() {
  
          paused = true;
  
  
  
          if (recording) {
  
              stopRecording();
  
          }
  
          closeCamera();
  
  
  
  //        if (useTexture()) {
  
  //            releaseSurfaceTexture();
  
  //        } else {
  
              releaseSurfaceView();
  
  //        }
  
      }
  
  
  
      private void setCameraParameters() {
  
          if (CamcorderProfile.hasProfile(CamcorderProfile.QUALITY_720P)) {
  
              camcorderProfile = CamcorderProfile.get(CamcorderProfile.QUALITY_720P);
  
          } else if (CamcorderProfile.hasProfile(CamcorderProfile.QUALITY_480P)) {
  
              camcorderProfile = CamcorderProfile.get(CamcorderProfile.QUALITY_480P);
  
          } else {
  
              camcorderProfile = CamcorderProfile.get(CamcorderProfile.QUALITY_HIGH);
  
          }
  
          mVideoWidth = camcorderProfile.videoFrameWidth;
  
          mVideoHeight = camcorderProfile.videoFrameHeight;
  
          camcorderProfile.fileFormat = MediaRecorder.OutputFormat.MPEG_4;
  
          camcorderProfile.videoFrameRate = 30;
  
  
  
          Log.v(TAG, "mVideoWidth=" + mVideoWidth + " mVideoHeight=" + mVideoHeight);
  
          cameraParameters.setPreviewSize(mVideoWidth, mVideoHeight);
  
  
  
          if (cameraParameters.getSupportedWhiteBalance().contains(Camera.Parameters.WHITE_BALANCE_AUTO)) {
  
              cameraParameters.setWhiteBalance(Camera.Parameters.WHITE_BALANCE_AUTO);
  
          }
  
  
  
          if (cameraParameters.getSupportedFocusModes().contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
  
              cameraParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
  
          }
  
  
  
          cameraParameters.setRecordingHint(true);
  
          cameraParameters.set("cam_mode", 1);
  
  
  
          camera.setParameters(cameraParameters);
  
          cameraParameters = camera.getParameters();
  
  
  
          camera.setDisplayOrientation(90);
  
          android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
  
          Log.d(TAG, info.orientation + " degree");
  
      }
  
  
  
      private void resizePreview() {
  
          Log.d(TAG, String.format("Video size:%d|%d", mVideoWidth, mVideoHeight));
  
  
  
          Point optimizedSize = getOptimizedPreviewSize(mVideoWidth, mVideoHeight);
  
          Log.d(TAG, String.format("Optimized size:%d|%d", optimizedSize.x, optimizedSize.y));
  
  
  
          ViewGroup.LayoutParams params = (ViewGroup.LayoutParams) previewFrame.getLayoutParams();
  
          params.width = optimizedSize.x;
  
          params.height = optimizedSize.y;
  
          previewFrame.setLayoutParams(params);
  
      }
  
  
  
      public void setOrientation(int ori) {
  
          this.mOrientation = ori;
  
      }
  
  
  
      public void setOrientationEventListener(OrientationEventListener listener) {
  
          this.mOrientationEventListener = listener;
  
      }
  
  
  
      public Camera getCamera() {
  
          return camera;
  
      }
  
  
  
      @SuppressWarnings("serial")
  
      public void setFocusArea(float x, float y) {
  
          if (camera != null) {
  
              int viewWidth = surfaceView.getWidth();
  
              int viewHeight = surfaceView.getHeight();
  
  
  
              int focusCenterX = FOCUS_MAX_VALUE - (int) (x / viewWidth * (FOCUS_MAX_VALUE - FOCUS_MIN_VALUE));
  
              int focusCenterY = FOCUS_MIN_VALUE + (int) (y / viewHeight * (FOCUS_MAX_VALUE - FOCUS_MIN_VALUE));
  
              final int left = focusCenterY - FOCUS_AREA_RADIUS < FOCUS_MIN_VALUE ? FOCUS_MIN_VALUE : focusCenterY - FOCUS_AREA_RADIUS;
  
              final int top = focusCenterX - FOCUS_AREA_RADIUS < FOCUS_MIN_VALUE ? FOCUS_MIN_VALUE : focusCenterX - FOCUS_AREA_RADIUS;
  
              final int right = focusCenterY + FOCUS_AREA_RADIUS > FOCUS_MAX_VALUE ? FOCUS_MAX_VALUE : focusCenterY + FOCUS_AREA_RADIUS;
  
              final int bottom = focusCenterX + FOCUS_AREA_RADIUS > FOCUS_MAX_VALUE ? FOCUS_MAX_VALUE : focusCenterX + FOCUS_AREA_RADIUS;
  
  
  
              Camera.Parameters params = camera.getParameters();
  
              params.setFocusAreas(new ArrayList() {
  
                  {
  
                      add(new Camera.Area(new Rect(left, top, right, bottom), 1000));
  
                  }
  
              });
  
              camera.setParameters(params);
  
              camera.autoFocus(new AutoFocusCallback() {
  
                  @Override
  
                  public void onAutoFocus(boolean success, Camera camera) {
  
                      Log.d(TAG, "onAutoFocus");
  
                  }
  
              });
  
          }
  
      }
  
  
  
      public void startRecording(String destinationFilepath) {
  
          if (!recording) {
  
              updateStorageSpace();
  
              setDestinationFilepath(destinationFilepath);
  
              if (mStorageSpace <= LOW_STORAGE_THRESHOLD) {
  
                  Log.v(TAG, "Storage issue, ignore the start request");
  
                  Toast.makeText(currentActivity, "Storage issue, ignore the recording request", Toast.LENGTH_LONG).show();
  
                  return;
  
              }
  
  
  
              if (!prepareMediaRecorder()) {
  
                  Toast.makeText(currentActivity, "prepareMediaRecorder failed.", Toast.LENGTH_LONG).show();
  
                  return;
  
              }
  
  
  
              Log.d(TAG, "Successfully prepare media recorder.");
  
              try {
  
                  mediaRecorder.start();
  
              } catch (RuntimeException e) {
  
                  Log.e(TAG, "MediaRecorder start failed.");
  
                  releaseMediaRecorder();
  
                  return;
  
              }
  
  
  
              mStartRecordingTime = System.currentTimeMillis();
  
  
  
              if (mOrientationEventListener != null) {
  
                  mOrientationEventListener.disable();
  
              }
  
  
  
              recording = true;
  
          }
  
      }
  
  
  
      public void stopRecording() {
  
          if (recording) {
  
              if (!paused) {
  
                  // Capture at least 1 second video
  
                  long currentTime = System.currentTimeMillis();
  
                  if (currentTime - mStartRecordingTime < MINIMUM_RECORDING_TIME) {
  
                      mHandler.postDelayed(mStopRecordingTask, MINIMUM_RECORDING_TIME - (currentTime - mStartRecordingTime));
  
                      return;
  
                  }
  
              }
  
  
  
              if (mOrientationEventListener != null) {
  
                  mOrientationEventListener.enable();
  
              }
  
  
  
  //            mHandler.removeCallbacks(mUpdateRecordingTimeTask);
  
  
  
              try {
  
                  mediaRecorder.setOnErrorListener(null);
  
                  mediaRecorder.setOnInfoListener(null);
  
                  mediaRecorder.stop(); // stop the recording
  
                  Toast.makeText(currentActivity, "Video file saved.", Toast.LENGTH_LONG).show();
  
  
  
                  long stopRecordingTime = System.currentTimeMillis();
  
                  Log.d(TAG, String.format("stopRecording. file:%s duration:%d", destinationFilepath, stopRecordingTime - mStartRecordingTime));
  
  
  
                  // Calculate the duration of video
  
                  MediaMetadataRetriever mmr = new MediaMetadataRetriever();
  
                  mmr.setDataSource(this.destinationFilepath);
  
                  String _length = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
  
                  if (_length != null) {
  
                      Log.d(TAG, String.format("clip duration:%d", Long.parseLong(_length)));
  
                  }
  
  
  
                  // Taking the snapshot of video
  
                  Bitmap snapshot = ThumbnailUtils.createVideoThumbnail(this.destinationFilepath, Thumbnails.MICRO_KIND);
  
                  try {
  
                      FileOutputStream out = new FileOutputStream(this.snapshotFilepath);
  
                      snapshot.compress(Bitmap.CompressFormat.JPEG, 70, out);
  
                      out.close();
  
                  } catch (Exception e) {
  
                      e.printStackTrace();
  
                  }
  
  
  
  //                mActivity.showPlayButton();
  
  
  
              } catch (RuntimeException e) {
  
                  e.printStackTrace();
  
                  Log.e(TAG, e.getMessage());
  
                  // if no valid audio/video data has been received when stop() is
  
                  // called
  
              } finally {
  
  //          
  
  
  
                  releaseMediaRecorder(); // release the MediaRecorder object
  
                  if (!paused) {
  
                      cameraParameters = camera.getParameters();
  
                  }
  
                  recording = false;
  
              }
  
  
  
          }
  
      }
  
  
  
      public void setRecorderOrientation(int orientation) {
  
          // For back camera only
  
          if (orientation != -1) {
  
              Log.d(TAG, "set orientationHint:" + (orientation + 135) % 360 / 90 * 90);
  
              mediaRecorder.setOrientationHint((orientation + 135) % 360 / 90 * 90);
  
          }else {
  
              Log.d(TAG, "not set orientationHint to mediaRecorder");
  
          }
  
      }
  
  
  
      private boolean prepareMediaRecorder() {
  
          mediaRecorder = new MediaRecorder();
  
  
  
          camera.unlock();
  
          mediaRecorder.setCamera(camera);
  
  
  
          mediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
  
          mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
  
  
  
          mediaRecorder.setProfile(camcorderProfile);
  
  
  
          mediaRecorder.setMaxDuration(MAXIMUM_RECORDING_TIME);
  
          mediaRecorder.setOutputFile(this.destinationFilepath);
  
  
  
          try {
  
              mediaRecorder.setMaxFileSize(Math.min(RECORDING_FILE_LIMIT, mStorageSpace - LOW_STORAGE_THRESHOLD));
  
          } catch (RuntimeException exception) {
  
          }
  
  
  
          setRecorderOrientation(mOrientation);
  
  
  
          if (!useTexture()) {
  
              mediaRecorder.setPreviewDisplay(surfaceHolder.getSurface());
  
          }
  
  
  
          try {
  
              mediaRecorder.prepare();
  
          } catch (IllegalStateException e) {
  
              releaseMediaRecorder();
  
              return false;
  
          } catch (IOException e) {
  
              releaseMediaRecorder();
  
              return false;
  
          }
  
  
  
          mediaRecorder.setOnErrorListener(this);
  
          mediaRecorder.setOnInfoListener(this);
  
  
  
          return true;
  
  
  
      }
  
  
  
      private void releaseMediaRecorder() {
  
          if (mediaRecorder != null) {
  
              mediaRecorder.reset(); // clear recorder configuration
  
              mediaRecorder.release(); // release the recorder object
  
              mediaRecorder = null;
  
              camera.lock(); // lock camera for later use
  
          }
  
      }
  
  
  
      private Point getOptimizedPreviewSize(int videoWidth, int videoHeight) {
  
          Display display = currentActivity.getWindowManager().getDefaultDisplay();
  
          Point size = new Point();
  
          display.getSize(size);
  
  
  
          Point optimizedSize = new Point();
  
          optimizedSize.x = size.x;
  
          optimizedSize.y = (int) ((float) videoWidth / (float) videoHeight * size.x);
  
  
  
          return optimizedSize;
  
      }
  
  
  
      private void showCameraErrorAndFinish() {
  
          DialogInterface.OnClickListener buttonListener = new DialogInterface.OnClickListener() {
  
              @Override
  
              public void onClick(DialogInterface dialog, int which) {
  
                  currentActivity.finish();
  
              }
  
          };
  
          new AlertDialog.Builder(currentActivity).setCancelable(false)
  
                  .setTitle("Camera error")
  
                  .setMessage("Cannot connect to the camera.")
  
                  .setNeutralButton("OK", buttonListener)
  
                  .show();
  
      }
  
  
  
      private void showStorageErrorAndFinish() {
  
          DialogInterface.OnClickListener buttonListener = new DialogInterface.OnClickListener() {
  
              @Override
  
              public void onClick(DialogInterface dialog, int which) {
  
                  currentActivity.finish();
  
              }
  
          };
  
          new AlertDialog.Builder(currentActivity).setCancelable(false)
  
                  .setTitle("Storage error")
  
                  .setMessage("Cannot read external storage.")
  
                  .setNeutralButton("OK", buttonListener)
  
                  .show();
  
      }
  
  
  
      private void updateStorageSpace() {
  
          mStorageSpace = getAvailableSpace();
  
          Log.v(TAG, "updateStorageSpace mStorageSpace=" + mStorageSpace);
  
      }
  
  
  
      private long getAvailableSpace() { 
  
          String state = Environment.getExternalStorageState();
  
          Log.d(TAG, "External storage state=" + state);
  
          if (Environment.MEDIA_CHECKING.equals(state)) {
  
              return -1;
  
          }
  
          if (!Environment.MEDIA_MOUNTED.equals(state)) {
  
              return -1;
  
          }
  
  
  
          File directory = currentActivity.getExternalFilesDir("vine");
  
          directory.mkdirs();
  
          if (!directory.isDirectory() || !directory.canWrite()) {
  
              return -1;
  
          }
  
  
  
          try {
  
              StatFs stat = new StatFs(directory.getAbsolutePath());
  
              return stat.getAvailableBlocks() * (long) stat.getBlockSize();
  
          } catch (Exception e) {
  
              Log.i(TAG, "Fail to access external storage", e);
  
          }
  
          return -1;
  
      }
  
  
  
      private boolean useTexture() {
  
          return false;
  
  //        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1;
  
      }
  
  
  
      private class SurfaceViewCallback implements SurfaceHolder.Callback {
  
  
  
          @Override
  
          public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
  
              Log.v(TAG, "surfaceChanged. width=" + width + ". height=" + height);
  
          }
  
  
  
          @Override
  
          public void surfaceCreated(SurfaceHolder holder) {
  
              Log.v(TAG, "surfaceCreated");
  
              surfaceViewReady = true;
  
              surfaceHolder = holder;
  
              startPreview();
  
          }
  
  
  
          @Override
  
          public void surfaceDestroyed(SurfaceHolder holder) {
  
              Log.d(TAG, "surfaceDestroyed");
  
              surfaceViewReady = false;
  
          }
  
  
  
      }
  
  
  
      @Override
  
      public void onError(int error, Camera camera) {
  
          Log.e(TAG, "Camera onError. what=" + error + ".");
  
          if (error == Camera.CAMERA_ERROR_SERVER_DIED) {
  
  
  
          } else if (error == Camera.CAMERA_ERROR_UNKNOWN) {
  
  
  
          }
  
      }
  
  
  
      @Override
  
      public void onInfo(MediaRecorder mr, int what, int extra) {
  
          if (what == MediaRecorder.MEDIA_RECORDER_INFO_MAX_DURATION_REACHED) {
  
              stopRecording();
  
          } else if (what == MediaRecorder.MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED) {
  
              stopRecording();
  
              Toast.makeText(currentActivity, "Size limit reached", Toast.LENGTH_LONG).show();
  
          }
  
      }
  
  
  
      @Override
  
      public void onError(MediaRecorder mr, int what, int extra) {
  
          Log.e(TAG, "MediaRecorder onError. what=" + what + ". extra=" + extra);
  
          if (what == MediaRecorder.MEDIA_RECORDER_ERROR_UNKNOWN) {
  
              stopRecording();
  
          }
  
      }
  
  
  
  }

  VideoUtils

  public class VideoUtils {
  
      private static final String TAG = VideoUtils.class.getSimpleName();
  
  
  
      static double[] matrix = new double[] { 0.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0,
  
              0.0, 1.0 };
  
  
  
      public static boolean MergeFiles(String speratedDirPath,
  
              String targetFileName) {
  
          File videoSourceDirFile = new File(speratedDirPath);
  
          String[] videoList = videoSourceDirFile.list();
  
          List<track> videoTracks = new LinkedList<track>();
  
          List<track> audioTracks = new LinkedList<track>();
  
          for (String file : videoList) {
  
              Log.d(TAG, "source files" + speratedDirPath
  
                      + File.separator + file);
  
              try {
  
                  FileChannel fc = new FileInputStream(speratedDirPath
  
                          + File.separator + file).getChannel();
  
                  Movie movie = MovieCreator.build(fc);
  
                  for (Track t : movie.getTracks()) {
  
                      if (t.getHandler().equals("soun")) {
  
                          audioTracks.add(t);
  
                      }
  
                      if (t.getHandler().equals("vide")) {
  
  
  
                          videoTracks.add(t);
  
                      }
  
                  }
  
              } catch (FileNotFoundException e) {
  
                  e.printStackTrace();
  
                  return false;
  
              } catch (IOException e) {
  
                  e.printStackTrace();
  
                  return false;
  
              }
  
          }
  
  
  
          Movie result = new Movie();
  
  
  
          try {
  
              if (audioTracks.size() > 0) {
  
                  result.addTrack(new AppendTrack(audioTracks
  
                          .toArray(new Track[audioTracks.size()])));
  
              }
  
              if (videoTracks.size() > 0) {
  
                  result.addTrack(new AppendTrack(videoTracks
  
                          .toArray(new Track[videoTracks.size()])));
  
              }
  
              IsoFile out = new DefaultMp4Builder().build(result);
  
  
  
  
  
  
  
              FileChannel fc = new RandomAccessFile(
  
                      String.format(targetFileName), "rw").getChannel();
  
  
  
              Log.d(TAG, "target file:" + targetFileName);
  
              TrackBox tb = out.getMovieBox().getBoxes(TrackBox.class).get(1);
  
  
  
              TrackHeaderBox tkhd = tb.getTrackHeaderBox();
  
              double[] b = tb.getTrackHeaderBox().getMatrix();
  
  
  
              tkhd.setMatrix(matrix);
  
  
  
              fc.position(0);
  
              out.getBox(fc);
  
              fc.close();
  
              for (String file : videoList) {
  
                  File TBRFile = new File(speratedDirPath + File.separator + file);
  
                  TBRFile.delete();
  
              }
  
              boolean a = videoSourceDirFile.delete();
  
              Log.d(TAG, "try to delete dir:" + a);
  
          } catch (IOException e) {
  
              // TODO Auto-generated catch block
  
              e.printStackTrace();
  
              return false;
  
          }
  
  
  
          return true;
  
      }
  
  
  
      public static boolean clearFiles(String speratedDirPath) {
  
          File videoSourceDirFile = new File(speratedDirPath);
  
          if (videoSourceDirFile != null
  
                  &amp;&amp; videoSourceDirFile.listFiles() != null) {
  
              File[] videoList = videoSourceDirFile.listFiles();
  
              for (File video : videoList) {
  
                  video.delete();
  
              }
  
              videoSourceDirFile.delete();
  
          }
  
          return true;
  
      }
  
  
  
      public static int createSnapshot(String videoFile, int kind, String snapshotFilepath) {
  
          return 0;
  
      };
  
  
  
      public static int createSnapshot(String videoFile, int width, int height, String snapshotFilepath) {
  
          return 0;
  
      }
  
  }
  
  </track></track></track></track>

  my reference code project link is

  https://github.com/jwfing/AndroidVideoKit