if(isRecording) {
  mMediaRecorder.stop();
  releaseMediaRecorder();
  mCamera.lock();
  isRecording = false;
}
if(startRecordVideo()) {
  startTimeVideoRecord();
  isRecording = true;
}

private boolean startRecordVideo() {
  configureMediaRecorder();
  if(!prepareConfiguredMediaRecorder()) {
    return false;
  }
  mMediaRecorder.start();
  return true;
}

private void stopRecordVideo() {

    releaseMediaRecorder();
    // 录制视频文件处理
    if(currentRecordProgress < MIN_RECORD_TIME) {
      Toast.makeText(VideoInputActivity.this, "录制时间太短", Toast.LENGTH_SHORT).show();
    } else {
      startVideoPlay();
      isPlaying = true;
      setUiDisplayAfterVideoRecordFinish();
    }
    currentRecordProgress = 0;
    updateProgressBar(currentRecordProgress);
    releaseTimer();
    // 状态设置
    isRecording = false;
  }

public CameraPreview(Context context, Camera camera) {
    super(context);

    mCamera = camera;
    mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();
    mHolder = getHolder();
    mHolder.addCallback(this);
    mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
  }

public Camera.Size getOptimalPreviewSize(List<Camera.Size> sizes, int w, int h) {
    final double ASPECT_TOLERANCE = 0.1;
    double targetRatio = (double) w / h;
    if (sizes == null) {
      return null;
    }
    Camera.Size optimalSize = null;
    double minDiff = Double.MAX_VALUE;
    int targetHeight = h;
    for (Camera.Size size : sizes) {
      double ratio = (double) size.width / size.height;
      if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE)
        continue;
      if (Math.abs(size.height - targetHeight) < minDiff) {
        optimalSize = size;
        minDiff = Math.abs(size.height - targetHeight);
      }
    }
    if (optimalSize == null) {
      minDiff = Double.MAX_VALUE;
      for (Camera.Size size : sizes) {
        if (Math.abs(size.height - targetHeight) < minDiff) {
          optimalSize = size;
          minDiff = Math.abs(size.height - targetHeight);
        }
      }
    }
    return optimalSize;
  }

if (mSupportedPreviewSizes != null) {
  mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, 
            Math.max(width, height), Math.min(width, height));
}

Camera.Parameters mParams = mCamera.getParameters();
mParams.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
mCamera.setDisplayOrientation(90);

List<String> focusModes = mParams.getSupportedFocusModes();
if(focusModes.contains("continuous-video")){
  mParams.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
}
mCamera.setParameters(mParams);

private void configureMediaRecorder() {
    // BEGIN_INCLUDE (configure_media_recorder)
    mMediaRecorder = new MediaRecorder();

    // Step 1: Unlock and set camera to MediaRecorder
    mCamera.unlock();
    mMediaRecorder.setCamera(mCamera);
    mMediaRecorder.setOrientationHint(90);

    // Step 2: Set sources
    mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.VOICE_RECOGNITION);
    mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);

    // Step 3: Set a Camera Parameters
    mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
    /* Fixed video Size: 640 * 480*/
    mMediaRecorder.setVideoSize(640, 480);
    /* Encoding bit rate: 1 * 1024 * 1024*/
    mMediaRecorder.setVideoEncodingBitRate(1 * 1024 * 1024);
    mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
    mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);

    // Step 4: Set output file
    mMediaRecorder.setMaxFileSize(maxFileSizeInBytes);
    mMediaRecorder.setOutputFile(videoFilePath);
    // END_INCLUDE (configure_media_recorder)

    // Set MediaRecorder ErrorListener
    mMediaRecorder.setOnErrorListener(this);
  }

private boolean prepareConfiguredMediaRecorder() {
    // Step 5: Prepare configured MediaRecorder
    try {
      mMediaRecorder.prepare();
    } catch (Exception e) {
      releaseMediaRecorder();
      return false;
    }
    return true;
  }

public void onPreviewFrame( byte[] data, Camera c ) {
     // Increment FPS counter for camera.
     util.cameraFrameTick();

     // Perform processing on the camera preview data.
     update( data, mDesiredWidth, mDesiredHeight );

     // Simple IIR filter on time.
     mProcessTime = util.getFastCVProcessTime();

     if( c != null )
     {
      // with buffer requires addbuffer each callback frame.
      c.addCallbackBuffer( mPreviewBuffer );
      c.setPreviewCallbackWithBuffer( this );
     }

     // Mark dirty for render.
     requestRender();
   }
  };

private boolean rotateVideoFileWithClockwiseDegree(String sourceFilePath, int degree) {
    if(!isFileAndDegreeValid(sourceFilePath, degree)) {
      return false;
    }
    rotateVideoFile(sourceFilePath, degree);
    return true;
  }

private boolean isFileAndDegreeValid(String sourceFilePath, int degree) {
    if(sourceFilePath == null || (!sourceFilePath.endsWith(".mp4")) 
                 || (!new File(sourceFilePath).exists())) {
      return false;
    }
    if (degree == 0 || (degree % 90 != 0)) {
      return false;
    }
    return true;
  }

private void rotateVideoFile(String sourceFilePath, int degree) {
    List<TrackBox> trackBoxes = getTrackBoxesOfVideoFileByPath(sourceFilePath);
    Movie rotatedMovie = getRotatedMovieOfTrackBox(trackBoxes);
    writeMovieToModifiedFile(rotatedMovie);
  }

private List<TrackBox> getTrackBoxesOfVideoFileByPath(String sourceFilePath) {
    IsoFile isoFile = null;
    List<TrackBox> trackBoxes = null;
    try {
      isoFile = new IsoFile(sourceFilePath);
      trackBoxes = isoFile.getMovieBox().getBoxes(TrackBox.class);
      isoFile.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
    return trackBoxes;
  }

private Movie getRotatedMovieOfTrackBox(List<TrackBox> trackBoxes) {
    Movie rotatedMovie = new Movie();
    // 旋转
    for (TrackBox trackBox : trackBoxes) {
      trackBox.getTrackHeaderBox().setMatrix(Matrix.ROTATE_90);
      rotatedMovie.addTrack(new Mp4TrackImpl(trackBox));
    }
    return rotatedMovie;
  }

private void writeMovieToModifiedFile(Movie movie) {
    Container container = new DefaultMp4Builder().build(movie);
    File modifiedVideoFile = new File(videoFilePath.replace(".mp4", "_MOD.mp4"));
    FileOutputStream fos;
    try {
      fos = new FileOutputStream(modifiedVideoFile);
      WritableByteChannel bb = Channels.newChannel(fos);
      container.writeContainer(bb);
      // 关闭文件流
      fos.close();
    } catch (Exception e) {
      e.printStackTrace();
    } 
  }