android – 使用MediaRecorder录制mp4时获取/修改帧

public class MainActivity extends Activity implements OnClickListener,SurfaceHolder.CallBACk {
MediaRecorder recorder;
SurfaceHolder holder;
Boolean recording = false;
@Override
public void onCreate(Bundle savedInstanceStatE) {
    super.onCreate(savedInstanceStatE);
    requestWindowFeature(Window.FEATURE_NO_titlE);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
    setrequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

    recorder = new MediaRecorder();
    initRecorder();
    setContentView(R.layout.activity_main);

    SurfaceView cameraView = (SurfaceView) findViewById(R.id.surfaceView1);
    holder = cameraView.getHolder();
    holder.addCallBACk(this);
    holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

    cameraView.setClickable(true);
    cameraView.setOnClickListener(this);
}

private void initRecorder() {
    recorder.setAudiosource(MediaRecorder.Audiosource.DEFAULT);
    recorder.setVideosource(MediaRecorder.Videosource.DEFAULT);

    CamcorderProfile cpHigh = CamcorderProfile
            .get(CamcorderProfile.QUALITY_HIGH);
    recorder.setProfile(cpHigh);

    recorder.setOutputFile(Environment.getExternalStorageDirectory().getPath() + "/video.mp4");
    recorder.setMaxDuration(50 * 1000); // 50 seconds
    recorder.setMaxFileSize(5 * 1000000); // Approximately 5 megabytes
}

private void prepareRecorder() {
    recorder.setPreviewDisplay(holder.getSurface());

    try {
        recorder.prepare();
    } catch (IllegalStateException E) {
        e.printStackTrace();
        finish();
    } catch (IOException E) {
        e.printStackTrace();
        finish();
    }
}

public void onClick(View v) {
    if (recording) {
        recorder.stop();
        recording = false;


        // Let's initRecorder so we can record again
        initRecorder();
        prepareRecorder();
    } else {
        recording = true;
        recorder.start();
    }
}

public void surfaceCreated(SurfaceHolder holder) {
    prepareRecorder();
}

public void surfaceChanged(SurfaceHolder holder,int format,int width,int height) {
}

public void surfaceDestroyed(SurfaceHolder holder) {
    if (recording) {
        recorder.stop();
        recording = false;
    }
    recorder.release();
    finish();
}

我使用 JavaCV库(包装FFMPEG和OpenCV)来编辑帧.捕获onPreviewFrame上的帧并通过FFMPEG记录器记录它们.

以下是RecordActivity.java示例.

public class RecordActivity extends Activity implements OnClickListener {

    private final static String CLASS_LABEL = "RecordActivity";
    private final static String LOG_TAG = CLASS_LABEL;

    private PoweRMANager.WakeLock mWakeLock;

    private String ffmpeg_link = "/mnt/sdcard/stream.flv";

    long startTime = 0;
    Boolean recording = false;

    private volatile FFmpegFrameRecorder recorder;

    private Boolean isPreviewOn = false;

    privatE int sampleAudioRateInHz = 44100;
    privatE int imageWidth = 320;
    privatE int imageHeight = 240;
    privatE int frameRate = 30;

    /* audio data getTing thread */
    private AudioRecord audioRecord;
    private AudioRecordRunnable audioRecordRunnable;
    private Thread audioThread;
    volatile Boolean runAudioThread = true;

    /* video data getTing thread */
    private Camera cameraDevice;
    private CameraView cameraView;

    private iplImage yuvIplimage = null;

    /* layout setTing */
    private final int bg_screen_bx = 232;
    private final int bg_screen_by = 128;
    private final int bg_screen_width = 700;
    private final int bg_screen_height = 500;
    private final int bg_width = 1123;
    private final int bg_height = 715;
    private final int live_width = 640;
    private final int live_height = 480;
    privatE int screenWidth,screenHeight;
    private Button btnRecorderControl;

    @Override
    public void onCreate(Bundle savedInstanceStatE) {
        super.onCreate(savedInstanceStatE);
        setrequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

        setContentView(R.layout.main);

        PoweRMANager pm = (PoweRMANager) getSystemservice(Context.POWER_serviCE); 
        mWakeLock = pm.newWakeLock(PoweRMANager.SCREEN_BRIGHT_WAKE_LOCK,CLASS_LABEL); 
        mWakeLock.acquire(); 

        initLayout();
        initRecorder();
    }


    @Override
    protected void onResume() {
        super.onResume();

        if (mWakeLock == null) {
           PoweRMANager pm = (PoweRMANager) getSystemservice(Context.POWER_serviCE);
           mWakeLock = pm.newWakeLock(PoweRMANager.SCREEN_BRIGHT_WAKE_LOCK,CLASS_LABEL);
           mWakeLock.acquire();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();

        if (mWakeLock != null) {
            mWakeLock.release();
            mWakeLock = null;
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        recording = false;

        if (cameraView != null) {
            cameraView.stopPreview();
        }

        if(cameraDevice != null) {
           cameraDevice.stopPreview();
           cameraDevice.release();
           cameraDevice = null;
        }

        if (mWakeLock != null) {
            mWakeLock.release();
            mWakeLock = null;
        }
    }


    private void initLayout() {

        /* get size of screen */
        Display display = ((WindowManager) getSystemservice(Context.WINDOW_serviCE)).getDefaultDisplay();
        screenWidth = display.getWidth();
        screenHeight = display.getHeight();
        RelativeLayout.LayoutParams layoutParam = null; 
        LayoutInflater myInflate = null; 
        myInflate = (LayoutInflater) getSystemservice(Context.LAYOUT_INFLATER_serviCE);
        RelativeLayout topLayout = new RelativeLayout(this);
        setContentView(topLayout);
        LinearLayout preViewLayout = (LinearLayout) myInflate.inflate(R.layout.main,null);
        layoutParam = new RelativeLayout.LayoutParams(screenWidth,screenHeight);
        topLayout.addView(preViewLayout,layoutParam);

        /* add control button: start and stop */
        btnRecorderControl = (Button) findViewById(R.id.recorder_control);
        btnRecorderControl.setText("Start");
        btnRecorderControl.setOnClickListener(this);

        /* add camera view */
        int display_width_d = (int) (1.0 * bg_screen_width * screenWidth / bg_width);
        int display_height_d = (int) (1.0 * bg_screen_height * screenHeight / bg_height);
        int prev_rw,prev_rh;
        if (1.0 * display_width_d / display_height_d > 1.0 * live_width / live_height) {
            prev_rh = display_height_d;
            prev_rw = (int) (1.0 * display_height_d * live_width / live_height);
        } else {
            prev_rw = display_width_d;
            prev_rh = (int) (1.0 * display_width_d * live_height / live_width);
        }
        layoutParam = new RelativeLayout.LayoutParams(prev_rw,prev_rh);
        layoutParam.topMargin = (int) (1.0 * bg_screen_by * screenHeight / bg_height);
        layoutParam.leftMargin = (int) (1.0 * bg_screen_bx * screenWidth / bg_width);

        cameraDevice = Camera.open();
        Log.i(LOG_TAG,"cameara open");
        cameraView = new CameraView(this,cameraDevicE);
        topLayout.addView(cameraView,layoutParam);
        Log.i(LOG_TAG,"cameara preview start: OK");
    }

    //---------------------------------------
    // initialize ffmpeg_recorder
    //---------------------------------------
    private void initRecorder() {

        Log.w(LOG_TAG,"init recorder");

        if (yuvIplimage == null) {
            yuvIplimage = IplImage.create(imageWidth,imageHeight,IPL_DEPTH_8U,2);
            Log.i(LOG_TAG,"create yuvIplimage");
        }

        Log.i(LOG_TAG,"ffmpeg_url: " + ffmpeg_link);
        recorder = new FFmpegFrameRecorder(ffmpeg_link,imageWidth,1);
        recorder.setFormat("flv");
        recorder.setSampleRate(sampleAudioRateInHz);
        // Set in the surface changed method
        recorder.setFrameRate(frameRatE);

        Log.i(LOG_TAG,"recorder initialize success");

        audioRecordRunnable = new AudioRecordRunnable();
        audioThread = new Thread(audioRecordRunnablE);
        runAudioThread = true;
    }

    public void startRecording() {

        try {
            recorder.start();
            startTime = System.currentTimeMillis();
            recording = true;
            audioThread.start();

        } catch (FFmpegFrameRecorder.Exception E) {
            e.printStackTrace();
        }
    }

    public void stopRecording() {

        runAudioThread = false;
        try {
            audioThread.join();
        } catch (InterruptedException E) {
            e.printStackTrace();
        }
        audioRecordRunnable = null;
        audioThread = null;

        if (recorder != null && recording) {
            recording = false;
            Log.v(LOG_TAG,"Finishing recording,calling stop and release on recorder");
            try {
                recorder.stop();
                recorder.release();
            } catch (FFmpegFrameRecorder.Exception E) {
                e.printStackTrace();
            }
            recorder = null;

        }
    }

    @Override
    public Boolean onKeyDown(int keyCode,KeyEvent event) {

        if (keyCode == KeyEvent.KEYCODE_BACK) {
            if (recording) {
                stopRecording();
            }

            finish();

            return true;
        }

        return super.onKeyDown(keyCode,event);
    }


    //---------------------------------------------
    // audio thread,gets and encodes audio data
    //---------------------------------------------
    class AudioRecordRunnable implements Runnable {

        @Override
        public void run() {
            android.os.process.setThreadPriority(android.os.process.THREAD_PRIORITY_URGENT_AUdio);

            // Audio
            int bufferSize;
            short[] audioData;
            int bufferReadResult;

            bufferSize = AudioRecord.getMinBufferSize(sampleAudioRateInHz,AudioFormat.CHAnnEL_IN_MONO,AudioFormat.ENCODING_PCM_16BIT);
            audioRecord = new AudioRecord(MediaRecorder.Audiosource.MIC,sampleAudioRateInHz,AudioFormat.ENCODING_PCM_16BIT,bufferSizE);

            audioData = new short[bufferSize];

            Log.d(LOG_TAG,"audioRecord.startRecording()");
            audioRecord.startRecording();

            /* ffmpeg_audio encoding loop */
            while (runAudioThread) {
                //Log.v(LOG_TAG,"recording? " + recording);
                bufferReadResult = audioRecord.read(audioData,audioData.length);
                if (bufferReadResult > 0) {
                    Log.v(LOG_TAG,"bufferReadResult: " + bufferReadResult);
                    // If "recording" isn't true when start this thread,it never get's set according to this if statement...!!!
                    // Why?  Good question...
                    if (recording) {
                        try {
                            recorder.record(ShortBuffer.wrap(audioData,bufferReadResult));
                            //Log.v(LOG_TAG,"recording " + 1024*i + " to " + 1024*i+1024);
                        } catch (FFmpegFrameRecorder.Exception E) {
                            Log.v(LOG_TAG,e.getmessage());
                            e.printStackTrace();
                        }
                    }
                }
            }
            Log.v(LOG_TAG,"AudioThread Finished,release audioRecord");

            /* encoding finish,release recorder */
            if (audioRecord != null) {
                audioRecord.stop();
                audioRecord.release();
                audioRecord = null;
                Log.v(LOG_TAG,"audioRecord released");
            }
        }
    }

    //---------------------------------------------
    // camera thread,gets and encodes video data
    //---------------------------------------------
    class CameraView extends SurfaceView implements SurfaceHolder.CallBACk,PreviewCallBACk {

        private SurfaceHolder mHolder;
        private Camera mCamera;

        public CameraView(Context context,Camera camera) {
            super(context);
            Log.w("camera","camera view");
            mCamera = camera;
            mHolder = getHolder();
            mHolder.addCallBACk(CameraView.this);
            mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
            mCamera.setPreviewCallBACk(CameraView.this);
        }

        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            try {
                stopPreview();
                mCamera.setPreviewDisplay(holder);
            } catch (IOException exception) {
                mCamera.release();
                mCamera = null;
            }
        }

        public void surfaceChanged(SurfaceHolder holder,int height) {
            Log.v(LOG_TAG,"SetTing imageWidth: " + imageWidth + " imageHeight: " + imageHeight + " frameRate: " + frameRatE);
            Camera.Parameters camParams = mCamera.getParameters();
            camParams.setPreviewSize(imageWidth,imageHeight);

            Log.v(LOG_TAG,"Preview Framerate: " + camParams.getPreviewFrameRate());

            camParams.setPreviewFrameRate(frameRatE);
            mCamera.setParameters(camParams);
            startPreview();
        }

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            try {
                mHolder.addCallBACk(null);
                mCamera.setPreviewCallBACk(null);
            } catch (RuntimeException E) {
                // The camera has probably just been released,ignore.
            }
        }

        public void startPreview() {
            if (!isPreviewOn && mCamera != null) {
                isPreviewOn = true;
                mCamera.startPreview();
            }
        }

        public void stopPreview() {
            if (isPreviewOn && mCamera != null) {
                isPreviewOn = false;
                mCamera.stopPreview();
            }
        }

        @Override
        public void onPreviewFrame(byte[] data,Camera camera) {
            /* get video data */
            if (yuvIplimage != null && recording) {
                yuvIplimage.getByteBuffer().put(data);

                Log.v(LOG_TAG,"WriTing Frame");
                try {
                    long t = 1000 * (System.currentTimeMillis() - startTimE);
                    if (t > recorder.gettimestamp()) {
                        recorder.settimestamp(t);
                    }
                    recorder.record(yuvIplimagE);
                } catch (FFmpegFrameRecorder.Exception E) {
                    Log.v(LOG_TAG,e.getmessage());
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public void onClick(View v) {
        if (!recording) {
            startRecording();
            Log.w(LOG_TAG,"Start Button Pushed");
            btnRecorderControl.setText("Stop");
        } else {
            // This will trigger the audio recording loop to stop and then set isRecorderstart = false;
            stopRecording();
            Log.w(LOG_TAG,"Stop Button Pushed");
            btnRecorderControl.setText("Start");
        }
    }
}