Android 录制视频，同时实时获取帧

我发现了这样的问题。有人说这是可能的，但解决方案对我不起作用，还有人说这是不可能的

我有记录mp4的代码：

    import java.io.IOException;

    import android.app.Activity;
    import android.content.pm.ActivityInfo;
    import android.media.CamcorderProfile;
    import android.media.MediaRecorder;
    import android.os.Bundle;
    import android.os.Environment;
    import android.view.SurfaceHolder;
    import android.view.SurfaceView;
    import android.view.View;
    import android.view.View.OnClickListener;


    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);


            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

            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(5 * 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();
        }
    }

另一个用于实时获取帧：

        import java.io.IOException;
    import java.util.Iterator;
    import java.util.List;

    import android.app.Activity;
    import android.content.pm.ActivityInfo;
    import android.graphics.ImageFormat;
    import android.hardware.Camera;
    import android.hardware.Camera.ErrorCallback;
    import android.hardware.Camera.Size;
    import android.os.Bundle;
    import android.util.Log;
    import android.view.SurfaceHolder;
    import android.view.SurfaceView;
    import android.view.SurfaceHolder.Callback;

    public class MainActivity extends Activity {
        SurfaceView mVideoCaptureView;
        Camera mCamera;




        @Override
        public void onCreate(Bundle savedInstanceState) {

            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);

            mVideoCaptureView = (SurfaceView) findViewById(R.id.surfaceView1);
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            SurfaceHolder videoCaptureViewHolder = mVideoCaptureView.getHolder();
            videoCaptureViewHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
            videoCaptureViewHolder.addCallback(new Callback() {
                public void surfaceDestroyed(SurfaceHolder holder) {
                    stopVideo();
                }
                public void surfaceCreated(SurfaceHolder holder) {
                    startVideo();
                }

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





        private void startVideo() {

            //Open camera
            SurfaceHolder videoCaptureViewHolder = null;
            try {
                mCamera = Camera.open();
            } catch (RuntimeException e) {
                Log.e("CameraTest", "Camera Open failed");
                return;
            }
            mCamera.setErrorCallback(new ErrorCallback() {
                public void onError(int error, Camera camera) {
                }
            }); 

            //Get params
            Camera.Parameters parameters = mCamera.getParameters();


            //Get Frame rate
            int[] minFrameRate = {90000,90000};
            List<int[]> supportedPreviewFps=parameters.getSupportedPreviewFpsRange();
            Iterator<int[]> supportedPreviewFpsIterator=supportedPreviewFps.iterator();
            while(supportedPreviewFpsIterator.hasNext()){
                int[] tmpRate=supportedPreviewFpsIterator.next();   

                if(tmpRate[0]<minFrameRate[0])
                {
                    minFrameRate[0] = tmpRate[0];
                    minFrameRate[1] = tmpRate[1];
                }


            }

            //Set frame rate
            parameters.setPreviewFpsRange(minFrameRate[0],minFrameRate[1]);
            Log.i("Info", "Frame rate set to: " + minFrameRate[0] + ','+ minFrameRate[1]);

            //Get image size
            List<Size> supportedPreviewSizes=parameters.getSupportedPreviewSizes();
            Iterator<Size> supportedPreviewSizesIterator=supportedPreviewSizes.iterator();
            while(supportedPreviewSizesIterator.hasNext()){
                Size tmpSize=supportedPreviewSizesIterator.next();
                Log.v("CameraTest","supportedPreviewSize.width = "+tmpSize.width+"supportedPreviewSize.height = "+tmpSize.height);
            }

            //Set params
            mCamera.setParameters(parameters);
            if ( mVideoCaptureView!=null)
                videoCaptureViewHolder = mVideoCaptureView.getHolder();
            try 
            {
                mCamera.setPreviewDisplay(videoCaptureViewHolder);
            } catch (Throwable t) 
            {
                Log.e("Error","mCamera.setPreviewDisplay(videoCaptureViewHolder) fail");
            }


            //Start camera
            Size previewSize=mCamera.getParameters().getPreviewSize();
            int dataBufferSize=(int)(previewSize.height*previewSize.width*
                                   (ImageFormat.getBitsPerPixel(mCamera.getParameters().getPreviewFormat())/8.0));
            mCamera.addCallbackBuffer(new byte[dataBufferSize]);
            mCamera.addCallbackBuffer(new byte[dataBufferSize]);
            mCamera.addCallbackBuffer(new byte[dataBufferSize]);




            mCamera.setPreviewCallbackWithBuffer(new Camera.PreviewCallback() {           

                public synchronized void onPreviewFrame(byte[] data, Camera camera) {


                    try
                    {                   
                        camera.addCallbackBuffer(data);

                    }catch (Exception e) {

                        Log.e("CameraTest", "addCallbackBuffer error");

                    }


                }
            });







            try {
                mCamera.startPreview();
            } catch (Throwable e) {
                mCamera.release();
                mCamera = null;
                return;
            }
        }






        private void stopVideo() {

            Log.i("StopVideo","OK");


            if(null==mCamera)
                return;
            try {
                mCamera.stopPreview();
                mCamera.setPreviewDisplay(null);
                mCamera.setPreviewCallbackWithBuffer(null);
                mCamera.release();
            } catch (IOException e) {
                e.printStackTrace();
                return;
            }
            mCamera = null;
        }
        public void finish(){
            stopVideo();
            super.finish();
        }





        @Override
        public void onBackPressed() {

            stopVideo();
            super.onBackPressed();
        };







    }

import java.io.IOException；
导入java.util.Iterator；
导入java.util.List；
导入android.app.Activity；
导入android.content.pm.ActivityInfo；
导入android.graphics.ImageFormat；
导入android.hardware.Camera；
导入android.hardware.Camera.ErrorCallback；
导入android.hardware.Camera.Size；
导入android.os.Bundle；
导入android.util.Log；
导入android.view.SurfaceHolder；
导入android.view.SurfaceView；
导入android.view.SurfaceHolder.Callback；
公共类MainActivity扩展了活动{
SurfaceView mVideoCaptureView；
麦克默拉照相机；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
mVideoCaptureView=（SurfaceView）findViewById（R.id.surfaceView1）；
setRequestedOrientation（ActivityInfo.SCREEN\u ORIENTATION\u横向）；
SurfaceHolder videoCaptureViewHolder=mvideCaptureView.getHolder（）；
videoCaptureViewHolder.setType（SurfaceHolder.SURFACE类型推送缓冲区）；
videoCaptureViewHolder.addCallback（新回调（）{
公共空间表面覆盖（表面覆盖物持有人）{
停止视频（）；
}
已创建的公共空白表面（表面持有人）{
startVideo（）；
}
公共无效表面更改（表面文件夹持有者，整数格式，
整数宽度，整数高度）{
}
});
}
私有void startVideo（）{
//开放式摄像机
SurfaceHolder videoCaptureViewHolder=null；
试一试{
mCamera=Camera.open（）；
}捕获（运行时异常e）{
Log.e（“摄影机测试”、“摄影机打开失败”）；
返回；
}
setErrorCallback（新的ErrorCallback（）{
公共无效onError（内部错误，摄像头）{
}
}); 
//获取参数
Camera.Parameters=mCamera.getParameters（）；
//获取帧速率
int[]最小帧率={9000090000}；
列出supportedPreviewFps=参数。getSupportedPreviewFpsRange（）；
迭代器supportedPreviewfpsierator=supportedPreviewFps.Iterator（）；
while（supportedPreviewfpsierator.hasNext（））{
int[]tmpRate=supportedPreviewFpsIterator.next（）；
如果（tmpRate[0]您对需要支持的最低android SDK版本有要求吗？您回答自己：“如果Camara打开并开始录制mp4失败，因为它不能同时完成这两个任务”。还详细说明了“有人说是可能的”.谁？在哪里？你有没有像我在上一个问题中建议的那样尝试过JavaCV？如果你得到了这样的帧，你仍然需要在使用一些编码器编辑后对它们进行编码。因此你的最终目的地将是JavaCV。不，我没有我的最低要求sdk。我不再想要编辑帧，只需要获得它们。我依赖于这些问题..和它对你有用？对我来说，在MediaRecorder.start之后重新连接并设置回调无效：