devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Camera2+MediaCodec+AudioRecord+MediaMuxer实现录制功能（带源码）_camera2 录制视频

作者：你好赵伟 | 2024-06-07 09:29:56

赞

踩

camera2 录制视频

源码在最下面 最下面 最下面！

前言

最近在学习音视频开发，涉及到MediaCodec的相关知识点，了解到MediaCodec+MediaMuxer可以编码视频流以及音频流最后合成MP4。

现在网络上流动的帖子大部分都是通过CameraAPI去进行视频流的采集，很少使用Camera2API或者CameraXAPI去进行视频流的采集。这不正巧我的工作就是相机影像方面，咱最熟的就是Camera2。

那废话不多说！献丑了！

预览实现

按照惯例，我们先使用Camera2将相机的一个基本预览拉起来，这样也方便后续的调试。这边我就不会太过详细去讲解，如果有不是很了解的同学，可以去看我之前的帖子，毕竟输入了Camera2这个关键词看到我这篇帖子多多少少都是学习过相关API知识的。(50条消息) 使用Camera2实现预览功能_camera2 预览_JS-s的博客-CSDN博客

这边只会快速的过一下核心代码。

首先看一下布局文件

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     tools:context=".MainActivity"
  8.     android:orientation="vertical"
  9.     android:keepScreenOn="true">
  10.  
  11.     <TextureView
  12.         android:id="@+id/previewtexture"
  13.         android:layout_weight="1"
  14.         android:layout_width="720dp"
  15.         android:layout_height="720dp"/>
  16.     <Button
  17.         android:id="@+id/shutterclick"
  18.         android:layout_margin="20dp"
  19.         android:layout_width="match_parent"
  20.         android:layout_height="50dp"
  21.         android:text="点击录像"/>
  22.  
  23. </LinearLayout>

非常简单，就是一个TextureView与一个开始录制的按钮 ，TextureView主要负责预览流的显示，按钮进行录制按钮的开始与结束。

在textureview可用之后，设置相机属性，打开相机，创建预览流，一气呵成。部分核心代码如下所示。（看不看懂无所谓噢，后面会直接把所有代码附上，让你慢慢看）

  1. previewTextureView.setSurfaceTextureListener(new TextureView.SurfaceTextureListener() {
  2.             @Override
  3.             public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surfaceTexture, int width, int height) {
  4.                 Log.d(TAG, "onSurfaceTextureAvailable");
  5.                 setupCamera(width, height);
  6.  
  7.             }
  8.  
  9.             @Override
  10.             public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surfaceTexture, int i, int i1) {
  11.  
  12.             }
  13.  
  14.             @Override
  15.             public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surfaceTexture) {
  16.                 return false;
  17.             }
  18.  
  19.             @Override
  20.             public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surfaceTexture) {
  21.  
  22.             }
  23.         });
  24.  
  25.  
  26. private void setupCamera(int width, int height) {
  27.         CameraManager cameraManage = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  28.         try {
  29.             String[] cameraIdList = cameraManage.getCameraIdList();
  30.             for (String cameraId : cameraIdList) {
  31.                 CameraCharacteristics cameraCharacteristics = cameraManage.getCameraCharacteristics(cameraId);
  32.                 //demo就就简单写写后摄录像
  33.                 if (cameraCharacteristics.get(CameraCharacteristics.LENS_FACING) != CameraCharacteristics.LENS_FACING_BACK) {
  34.                     //表示匹配到前摄，直接跳过这次循环
  35.                     continue;
  36.                 }
  37.                 StreamConfigurationMap map = cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  38.                 Size[] outputSizes = map.getOutputSizes(SurfaceTexture.class);
  39.                 //因为重点不在相机预览，我们这边给定一个预览尺寸，不进行最优选择。
  40.                 Size size = new Size(1440, 1440);
  41.                 previewSize = size;
  42.                 mWidth = previewSize.getWidth();
  43.                 mHeight = previewSize.getHeight();
  44.                 mCameraId = cameraId;
  45.             }
  46.         } catch (CameraAccessException e) {
  47.             throw new RuntimeException(e);
  48.         }
  49.         openCamera();
  50.     }
  51.  
  52. private void openCamera() {
  53.         Log.d(TAG, "openCamera: success");
  54.         CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  55.         try {
  56.             if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
  57.                 // TODO: Consider calling
  58.                 //    ActivityCompat#requestPermissions
  59.                 // here to request the missing permissions, and then overriding
  60.                 //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  61.                 //                                          int[] grantResults)
  62.                 // to handle the case where the user grants the permission. See the documentation
  63.                 // for ActivityCompat#requestPermissions for more details.
  64.                 return;
  65.             }
  66.             cameraManager.openCamera(mCameraId, stateCallback, cameraHandler);
  67.         } catch (CameraAccessException e) {
  68.             e.printStackTrace();
  69.         }
  70.     }
  71.  
  72.  
  73. private CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
  74.  
  75.         @Override
  76.         public void onOpened(@NonNull CameraDevice cameraDevice) {
  77.             Log.d(TAG, "onOpen");
  78.             mCameraDevice = cameraDevice;
  79.             startPreview(mCameraDevice);
  80.         }
  81.  
  82.         @Override
  83.         public void onDisconnected(@NonNull CameraDevice cameraDevice) {
  84.             Log.d(TAG, "onDisconnected");
  85.         }
  86.  
  87.         @Override
  88.         public void onError(@NonNull CameraDevice cameraDevice, int i) {
  89.             Log.d(TAG, "onError");
  90.         }
  91.     };
  92.  
  93.  
  94.  
  95. private void startPreview(CameraDevice mCameraDevice) {
  96.         try {
  97.             Log.d(TAG, "startPreview");
  98.             setPreviewImageReader();
  99.             previewCaptureRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  100.             SurfaceTexture previewSurfaceTexture = previewTextureView.getSurfaceTexture();
  101.             previewSurfaceTexture.setDefaultBufferSize(mWidth, mHeight);
  102.             Surface previewSurface = new Surface(previewSurfaceTexture);
  103.             Surface previewImageReaderSurface = previewImageReader.getSurface();
  104.             previewCaptureRequestBuilder.addTarget(previewSurface);
  105.             mCameraDevice.createCaptureSession(Arrays.asList(previewSurface, previewImageReaderSurface), new CameraCaptureSession.StateCallback() {
  106.                 @Override
  107.                 public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
  108.                     Log.d(TAG, "onConfigured");
  109.                     previewCaptureSession = cameraCaptureSession;
  110.                     try {
  111.                         cameraCaptureSession.setRepeatingRequest(previewCaptureRequestBuilder.build(), cameraPreviewCallback, cameraHandler);
  112.                     } catch (CameraAccessException e) {
  113.                         throw new RuntimeException(e);
  114.                     }
  115.                 }
  116.  
  117.                 @Override
  118.                 public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
  119.  
  120.                 }
  121.             }, cameraHandler);
  122.  
  123.         } catch (CameraAccessException e) {
  124.             throw new RuntimeException(e);
  125.         }
  126.     }

一个预览的基本流程就是这么一点东西，里面具体啥意思，我这边真不讲啊，要真不会的话，可以去看看我上面分享的博文链接。

这边我只需要额外注意一个方法，setPreviewImageReader()，这个跟后面录制视频的流程关系非常大。这个咱们来开第二个章节详细说道说道。

录像前的知识捡漏

AudioRecord

AudioRecord是Android系统提供的用于实现录音的功能类。 这个录音使用流程非常简单，但是该类录制出来的是PCM文件是无法直接用常见的播放器进行播放的。但是使用MediaCodec实现录像功能，使用AudioRecord类来捕获音频流就非常合适，MediaCodec可以将PCM格式的数据转换成AAC格式，这个格式就非常适合合成MP4的音频。

实现 Android 录音的流程为：
1. 构造一个 AudioRecord 对象，其中需要的最小录音缓存buffffer大小可以通过 getMinBufffferSize方法得到。如果 buffffer容量过小，将导致对象构造的失败。
2. 初始化一个 buffffer ，该 buffffer 大于等于 AudioRecord 对象用于写声音数据的 buffffer 大小。
3. 开始录音
4. 创建一个数据流，一边从 AudioRecord 中读取声音数据到初始化的 buffffer ，一边将 buffffer 中数据导入数据流。
5. 关闭数据流
6. 停止录音

我们现在使用AudioRecord录制的音频是PCM格式，我们需要将录制到的buffer数据放入到MediaCodec中转换成AAC编码格式。 

MediaCodec 

Android 在 API 16 后引入的音视频编解码 API，Android 应用层统一由 MediaCodec API 提供音视频编解码的功能，由参数配置来决定采用何种编解码算法、是否采用硬件编解码加速等。由于使用硬件编解码，兼容性有不少问题，据说 MediaCodec 坑比较多。本人在使用的过程中那是非常多问题，煎熬的很。

MediaCodec 可以处理具体的流，主要有这几个方法：
getInputBuffffers ：获取需要编码数据的输入流队列，返回的是一个 ByteBuffffer 数组
queueInputBuffffer ：输入流入队列
dequeueInputBuffffer ：从输入流队列中取数据进行编码操作
getOutputBuffffers ：获取编解码之后的数据输出流队列，返回的是一个 ByteBuffffer 数组
dequeueOutputBuffffer ：从输出队列中取出编码操作之后的数据
releaseOutputBuffffer ：处理完成，释放 ByteBuffffer 数据 
  1. //基本上的代码流程就是这样
  2. //创建MediaCodec
  3. - createEncoderByType/createDecoderByType
  4. //配置，这个必不可少，是MediaCodec的生命周期
  5. - configure
  6. //启动MediaCodec
  7. - start
  8. //不断获取待处理的数据流
  9. - while(true) {
  10.     //在MediaCodec中拿到一个输入缓存区的索引index，可以将MeidaCodec缓存区理解成一个数组，
  11.     //每个数组元素可进行buffer的存储，我们现在这个方法是拿到每个数组元素的下标。
  12.     //好在下一步往每个数组元素里面存inputbuffer
  13.     - dequeueInputBuffer
  14.     //通过该方法将之前获取的流数据放入到缓存区中等到MediaCodec进行处理
  15.     - queueInputBuffer
  16.     //在MediaCodec中拿到一个输出缓存区的索引index，
  17.     //这个输出缓存区是之前输入的数据处理之后就会存放在这
  18.     - dequeueOutputBuffer
  19.     //通过拿到的索引获取处理之后的buffer值
  20.     - getOutputBuffer
  21.     //释放处理之后的buffer值
  22.     - releaseOutputBuffer
  23. }
  24. - stop
  25. - release

MediaMuxer 

MediaMuxer的作用是生成音频或视频文件；还可以把音频与视频混合成一个音视频文件。

相关 API 介绍：
MediaMuxer(String path, int format) ：
path: 输出文件的名称                           format:输出文件的格式；当前只支持 MP4 格式；
addTrack(MediaFormat format)：添加通道；
start() ：开始合成文件
writeSampleData(int trackIndex, ByteBuffffer byteBuf,MediaCodec.BufffferInfobufffferInfo) ：把 ByteBuffffer 中的数据写入到在构造器设置的文件中；
stop() ：停止合成文件
release() ：释放资源

实现录像流程 

流程图总结

我们先从流程图看看我们需要获取到什么数据，需要解决什么问题。

 根据流程我们可以总结一下：

  1. 我们需要想办法使用Camera2在录像的时候实时获取到预览的数据，并将其转换成NV21的格式方便后续处理。
  2. 使用AudioRecord实时录制音频，并且需要去到pcm音频数据。
  3. 因为视频流跟音频流需要分别编码成两个完全不相同的编码格式（h.264、AAC），我们需要分别创建两个MediaCodec进行分开处理。
  4. 两个MediaCodec处理的数据传入到MediaMuxer中，MediaMuxer进行合并成MP4。

接下来我们按照步骤一个一个将其走通。

Camera2获取YUV数据并转换NV21

首先咱们来说一下思路，Camera2跟Camera区别还是比较大的，Camera提供了一个回调可以直接拿到预览数据，但是Camera2就莫得，但是hold on hold on，先别骂。办法总比困难多，我们回想一下我们是怎么用Camera2实现拍照的。我们是通过imagereader当session.capture完之后，imagereader可用之后提取image变量从而进行保存图片，发现没有，这要稍做设置，image就可以提取出来YUV数据。按照这个思路，我们是否可以当执行录像的时候，例如session.setRepeatRequest的时候设置一个videoImageReader,每次捕获完之后videoImageReader就开始可以开始回调Image，从而获取到录像的YUV数据。

话不多说，思路有了之后，我们便可以进行代码实现。

 上面的代码是设置好相机各种属性之后，准备开启预览的时候的session设置，一切都跟Camera2的预览差不多，但是需要注意一下的是我红色框标注的部分，我新建了一个previewImageReader，这个ImageReader就是我上面说的录像的时候捕获YUV数据用的。因为我录像与预览使用的session是准备使用同一个的，所以我在新建session的时候就将previewImageReader的surface放入到了创建session中。但是需要注意的是，仔细看一下上面代码previewCaptureRequestBuilder.addTarget，会发现只add了textureview的surface，咱可千万不要一激动就把previewImageReaderSurface也给add进去了，要这样的话，到时候预览的时候previewImageReader可都会回调。我们在session进行录像的时候，重建一个capturerequestbuilder将previewImageReaderSurface给add进去，这个后面应该也会有相关的代码展示。

  1. private void startVideoSession() {
  2.         Log.d(TAG, "startVideoSession");
  3.         if (previewCaptureSession!=null){
  4.             try {
  5.                 previewCaptureSession.stopRepeating();
  6.             } catch (CameraAccessException e) {
  7.                 throw new RuntimeException(e);
  8.             }
  9.         }
  10.         SurfaceTexture previewSurfaceTexture = previewTextureView.getSurfaceTexture();
  11.         Surface previewSurface = new Surface(previewSurfaceTexture);
  12.         Surface previewImageReaderSurface = previewImageReader.getSurface();
  13.         try {
  14.             videoRequest = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
  15.             videoRequest.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  16.             videoRequest.addTarget(previewSurface);
  17.             videoRequest.addTarget(previewImageReaderSurface);
  18.             previewCaptureSession.setRepeatingRequest(videoRequest.build(), videosessioncallback, cameraHandler);
  19.         } catch (CameraAccessException e) {
  20.             throw new RuntimeException(e);
  21.         }
  22.     }

看见没有在这里才去addTarget，然后重新开一个重复捕获模式去进行录像。 

接下来我们来看看previewImageReader的创建代码：

  1. private void setPreviewImageReader() {
  2.         previewImageReader = ImageReader.newInstance(previewSize.getWidth(), previewSize.getHeight(), ImageFormat.YUV_420_888, 1);
  3.         previewImageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
  4.             @Override
  5.             public void onImageAvailable(ImageReader imageReader) {
  6.                 Log.d(TAG,"onImageAvailable");
  7.                 Image image = imageReader.acquireNextImage();
  8.                 int width = image.getWidth();
  9.                 int height = image.getHeight();
  10.                 int I420size = width * height*3/2;
  11.                 Log.d(TAG,"I420size:"+I420size);
  12.                 byte[] nv21 = new byte[I420size];
  13.                 YUVToNV21_NV12(image,nv21,image.getWidth(),image.getHeight(),"NV21");
  14.  
  15.                 encodeVideo(nv21);
  16.                 image.close();
  17.             }
  18.         }, previewCaptureHandler);
  19.     }

可以看到这个ImageReader是设置成了YUV_420_888的格式，我之前有想过直接设置成NV21的格式，毕竟有这个选项，但是最后证明这是不行的，只能老老实实将YUV_420_888通过逻辑装换成NV21的格式。

  1. private static void YUVToNV21_NV12(Image image, byte[] nv21, int w, int h, String type) {
  2.         Image.Plane[] planes = image.getPlanes();
  3.         int remaining0 = planes[0].getBuffer().remaining();
  4.         int remaining1 = planes[1].getBuffer().remaining();
  5.         int remaining2 = planes[2].getBuffer().remaining();
  6.         //分别准备三个数组接收YUV分量。
  7.         byte[] yRawSrcBytes = new byte[remaining0];
  8.         byte[] uRawSrcBytes = new byte[remaining1];
  9.         byte[] vRawSrcBytes = new byte[remaining2];
  10.         planes[0].getBuffer().get(yRawSrcBytes);
  11.         planes[1].getBuffer().get(uRawSrcBytes);
  12.         planes[2].getBuffer().get(vRawSrcBytes);
  13.         int j = 0, k = 0;
  14.         boolean flag = type.equals("NV21");
  15.         for (int i = 0; i < nv21.length; i++) {
  16.             if (i < w * h) {
  17.                 //首先填充w*h个Y分量
  18.                 nv21[i] = yRawSrcBytes[i];
  19.             } else {
  20.                 if (flag) {
  21.                     //若NV21类型 则Y分量分配完后第一个将是V分量
  22.                     nv21[i] = vRawSrcBytes[j];
  23.                     //PixelStride有用数据步长 = 1紧凑按顺序填充，=2每间隔一个填充数据
  24.                     j += planes[1].getPixelStride();
  25.                 } else {
  26.                     //若NV12类型 则Y分量分配完后第一个将是U分量
  27.                     nv21[i] = uRawSrcBytes[k];
  28.                     //PixelStride有用数据步长 = 1紧凑按顺序填充，=2每间隔一个填充数据
  29.                     k += planes[2].getPixelStride();
  30.                 }
  31.                 //紧接着可以交错UV或者VU排列不停的改变flag标志即可交错排列
  32.                 flag = !flag;
  33.             }
  34.         }
  35.     }

具体的原理可以看看这篇博客

(51条消息) 【Android Camera2】彻底弄清图像数据YUV420_888转NV21问题/良心教学/避坑必读!_yuv_420_888_奔跑的鲁班七号的博客-CSDN博客

 转换成NV21之后我们需要做的就是将这些数据传进MediaCodec中，也就是那个encodeVideo方法。我们先不进行讲解，等到后面的MediaCodec再一起讲讲。

AudioRecord录制音频

这个在网上的资料还是比较多的，就那一套流程，创建初始化，把那些参数啥啥的设置后，之后就开始就行。

  1. private void initAudioRecord() {
  2.         //这minBufferSize是代表设备能接受的最小buffersize
  3.         //sample_rate是44100,最常见就是这个值
  4.         AudioiMinBufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, AudioFormat.CHANNEL_IN_STEREO, AudioFormat.ENCODING_PCM_16BIT);
  5.         if (ActivityCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
  6.             // TODO: Consider calling
  7.             //    ActivityCompat#requestPermissions
  8.             // here to request the missing permissions, and then overriding
  9.             //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  10.             //                                          int[] grantResults)
  11.             // to handle the case where the user grants the permission. See the documentation
  12.             // for ActivityCompat#requestPermissions for more details.
  13.             return;
  14.         }
  15.         //这下面的一些参数例如什么16BIT可以自行去了解一下，现阶段基本知道一下就行吧
  16.         audioRecord = new AudioRecord.Builder()
  17.                 .setAudioFormat(new AudioFormat.Builder()
  18.                         .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
  19.                         .setSampleRate(SAMPLE_RATE)
  20.                         .setChannelMask(AudioFormat.CHANNEL_IN_MONO).build())
  21.                 .setBufferSizeInBytes(AudioiMinBufferSize)
  22.                 .setAudioSource(MediaRecorder.AudioSource.MIC)
  23.                 .build();
  24.     }

初始化之后，我们在开始录像的时候，便可以将起启动

  1. private void startAudioRecord() {
  2.         audioRecordThread = new Thread(new Runnable() {
  3.             @Override
  4.             public void run() {
  5.                 mIsAudioRecording = true;
  6.                 audioRecord.startRecording();
  7.                 while (mIsAudioRecording) {
  8.                     byte[] inputAudioData = new byte[AudioiMinBufferSize];
  9.                     int res = audioRecord.read(inputAudioData, 0, inputAudioData.length);
  10.                     if (res > 0) {
  11.                         //Log.d(TAG,res+"");
  12.                         if (AudioCodec!=null){
  13.                             if (captureListener!=null){
  14.                                 captureListener.onCaptureListener(inputAudioData,res);
  15.                             }
  16.                             //callbackData(inputAudioData,inputAudioData.length);
  17.                         }
  18.                     }
  19.                 }
  20.             }
  21.         });
  22.         audioRecordThread.start();
  23.     }

inputAudioData就是每次录制出来的byte数据，这些数据是PCM编码格式的，我们要做的也是将其放入到专门的MediaCodec中 。而captureListener.onCaptureListener(inputAudioData,res)就是将pcm传入MediaCodec中。

MediaCodec接收数据，处理数据

视频流设置MediaCodec

1.初始化视频流的MediaCodec，并进行Configure

  1. private void initMediaCodec(int width, int height) {
  2.         Log.d(TAG, "width:" + width);
  3.         Log.d(TAG, "Height:" + height);
  4.         try {
  5.             //先拿到格式容器
  6.             /*
  7.               MediaFormat.createVideoFormat中的宽高参数，不能为奇数
  8.               过小或超过屏幕尺寸，也会出现这个错误
  9.             */
  10.             //这里面的长宽设置应该跟imagereader里面获得的image的长宽进行对齐
  11.             MediaFormat videoFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, 1440, 1440);
  12.             //设置色彩控件
  13.             videoFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible);
  14.             //设置码率，码率就是数据传输单位时间传递的数据位数
  15.             videoFormat.setInteger(MediaFormat.KEY_BIT_RATE, 500_000);
  16.             //设置帧率
  17.             videoFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 20);
  18.             //设置关键帧间隔
  19.             videoFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
  20.             videoFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE,4000000);
  21.             //创建MediaCodc，注意这个格式，视频编码一般都是使用这个type
  22.             videoMediaCodec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
  23.             videoMediaCodec.configure(videoFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
  24.         } catch (IOException e) {
  25.             throw new RuntimeException(e);
  26.         }
  27.     }

 2.将NV21数据传递进输入缓存区

  1. private void encodeVideo(byte[] nv21) {
  2.         //输入
  3.         int index = videoMediaCodec.dequeueInputBuffer(WAIT_TIME);
  4.         //Log.d(TAG,"video encord video index:"+index);
  5.         if (index >= 0) {
  6.             ByteBuffer inputBuffer = videoMediaCodec.getInputBuffer(index);
  7.             inputBuffer.clear();
  8.             int remaining = inputBuffer.remaining();
  9.             inputBuffer.put(nv21, 0, nv21.length);
  10.             videoMediaCodec.queueInputBuffer(index, 0, nv21.length, (System.nanoTime()-nanoTime) / 1000, 0);
  11.         }
  12.     }

图解如下图 

3.从输出缓存区中取出已经处理好的数据

  1. private void encodeVideoH264() {
  2.         MediaCodec.BufferInfo videoBufferInfo = new MediaCodec.BufferInfo();
  3.         //获取输出缓存区index索引
  4.         int videobufferindex = videoMediaCodec.dequeueOutputBuffer(videoBufferInfo, 0);
  5.         Log.d(TAG,"videobufferindex:"+videobufferindex);
  6.         //这个状态无论有没有outputbuffer，只要第一次都会执行，可以在这里进行一些MediaMuxer的逻辑操作，例如加轨道
  7.         if (videobufferindex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
  8.             //添加轨道
  9.             mVideoTrackIndex = mediaMuxer.addTrack(videoMediaCodec.getOutputFormat());
  10.             Log.d(TAG,"mVideoTrackIndex:"+mVideoTrackIndex);
  11.             if (mAudioTrackIndex != -1) {
  12.                 Log.d(TAG,"encodeVideoH264:mediaMuxer is Start");
  13.                 mediaMuxer.start();
  14.                 isMediaMuxerStarted+=1;
  15.                 setPCMListener();
  16.             }
  17.         } else {
  18.             if (isMediaMuxerStarted>=0) {
  19.                 while (videobufferindex >= 0) {
  20.                     //获取输出数据成功
  21.                     ByteBuffer videoOutputBuffer = videoMediaCodec.getOutputBuffer(videobufferindex);
  22.                     Log.d(TAG,"Video mediaMuxer writeSampleData");
  23.                     mediaMuxer.writeSampleData(mVideoTrackIndex, videoOutputBuffer, videoBufferInfo);
  24.                     videoMediaCodec.releaseOutputBuffer(videobufferindex, false);
  25.                     videobufferindex=videoMediaCodec.dequeueOutputBuffer(videoBufferInfo,0);
  26.                 }
  27.             }
  28.         }
  29.  
  30.     }

音频流设置MediaCodec 

其实跟视频流的MediaCodec也是差不多的，我这边就不那么详细了

1.初始化音频流的MediaCodec，并进行Configure

  1. private void initAudioCodec() {
  2.         MediaFormat format = MediaFormat.createAudioFormat(MIMETYPE_AUDIO_AAC, SAMPLE_RATE, CHANNEL_COUNT);
  3.         format.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
  4.         format.setInteger(MediaFormat.KEY_BIT_RATE, BIT_RATE);
  5.         format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 8192);
  6.         try {
  7.             //编码类型AAC格式
  8.             AudioCodec = MediaCodec.createEncoderByType(MIMETYPE_AUDIO_AAC);
  9.             AudioCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
  10.         } catch (IOException e) {
  11.             throw new RuntimeException(e);
  12.         }
  13.  
  14.     }

2. 将PCM数据传递进输入缓存区

  1. private void callbackData(byte[] inputAudioData, int length) {
  2.         //已经拿到AudioRecord的byte数据
  3.         //准备将其放入到MediaCodc中
  4.         int index = AudioCodec.dequeueInputBuffer(-1);
  5.         if (index<0){
  6.             return;
  7.         }
  8.         Log.d(TAG,"AudioCodec.dequeueInputBuffer:"+index);
  9.         ByteBuffer[] inputBuffers = AudioCodec.getInputBuffers();
  10.         ByteBuffer audioInputBuffer = inputBuffers[index];
  11.         audioInputBuffer.clear();
  12.         Log.d(TAG, "call back Data length:" + length);
  13.         Log.d(TAG, "call back Data audioInputBuffer remain:" + audioInputBuffer.remaining());
  14.         audioInputBuffer.put(inputAudioData);
  15.         audioInputBuffer.limit(inputAudioData.length);
  16.         presentationTimeUs += (long) (1.0 * length / (44100 * 2 * (16 / 8)) * 1000000.0);
  17.         AudioCodec.queueInputBuffer(index, 0, inputAudioData.length, (System.nanoTime()-nanoTime)/1000, 0);
  18.     }

 3.从输出缓存区中取出已经处理好的数据

  1. private void encodePCMToAC() {
  2.         MediaCodec.BufferInfo audioBufferInfo = new MediaCodec.BufferInfo();
  3.         //获得输出
  4.         int audioBufferFlag = AudioCodec.dequeueOutputBuffer(audioBufferInfo, 0);
  5.         Log.d(TAG, "CALL BACK DATA FLAG:" + audioBufferFlag);
  6.         if (audioBufferFlag==MediaCodec.INFO_OUTPUT_FORMAT_CHANGED){
  7.             //這時候進行添加軌道
  8.             mAudioTrackIndex=mediaMuxer.addTrack(AudioCodec.getOutputFormat());
  9.             Log.d(TAG,"mAudioTrackIndex:"+mAudioTrackIndex);
  10.             if (mVideoTrackIndex!=-1){
  11.                 Log.d(TAG,"encodecPCMToACC:mediaMuxer is Start");
  12.                 mediaMuxer.start();
  13.                 isMediaMuxerStarted+=1;
  14.                 //开始了再创建录音回调
  15.                 setPCMListener();
  16.             }
  17.         }else {
  18.             Log.d(TAG,"isMediaMuxerStarted:"+isMediaMuxerStarted);
  19.             if (isMediaMuxerStarted>=0){
  20.                 while (audioBufferFlag>=0){
  21.                     //获取输出数据成功
  22.                     ByteBuffer outputBuffer = AudioCodec.getOutputBuffer(audioBufferFlag);
  23.                     mediaMuxer.writeSampleData(mAudioTrackIndex,outputBuffer,audioBufferInfo);
  24.                     AudioCodec.releaseOutputBuffer(audioBufferFlag,false);
  25.                     audioBufferFlag = AudioCodec.dequeueOutputBuffer(audioBufferInfo, 0);
  26.                 }
  27.             }
  28.         }
  29.  
  30.     }

自此MediaCodec的输入输出数据便大体完成了。

我们现在拿到了H.264的视频数据以及AAC的音频数据 ，我们可以准备使用MediaMuxer进行合并最后导出MP4。

MediaMuxer合成MP4

我们先理一下整体的合成流程

  1. 首先我们需要初始化一下，设置一下参数啥的
  2. 一个MP4包括两个轨道，一个是视频轨道，一个是音频轨道，需要在合适的时候进行添加
  3. 添加好轨道之后，我们就可以启动
  4. 往里面写入编码后的数据
  5. 结束，生成MP4

因为MediaMuxer一般都是嵌套在MediaCodec取输出数据的逻辑中使用，所有我这边只会放一些核心的代码出来。

截至到目前为止所有代码都是节选的，咱们最主要是了解他的过程，已经重要的方法，整个流程的梳理，可以通过看最后的完整代码进行走通。

  1. private void initMediaMuxer() {
  2.         String filename = Environment.getExternalStorageDirectory().getAbsolutePath() + "/DCIM/Camera/" + getCurrentTime() + ".mp4";
  3.         try {
  4.             mediaMuxer = new MediaMuxer(filename, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
  5.             mediaMuxer.setOrientationHint(90);
  6.         } catch (IOException e) {
  7.             throw new RuntimeException(e);
  8.         }
  9.     }

 添加轨道，启动

  1. mAudioTrackIndex=mediaMuxer.addTrack(AudioCodec.getOutputFormat());
  2. mVideoTrackIndex = mediaMuxer.addTrack(videoMediaCodec.getOutputFormat());
  3. mediaMuxer.start();

添加数据

  1. mediaMuxer.writeSampleData(mVideoTrackIndex, videoOutputBuffer, videoBufferInfo);
  2. mediaMuxer.writeSampleData(mAudioTrackIndex,outputBuffer,audioBufferInfo);

停止MedaiMuxer并释放

  1. private void stopMediaMuxer() {
  2.         isMediaMuxerStarted=-1;
  3.         mediaMuxer.stop();
  4.         mediaMuxer.release();
  5.     }

停止释放之后，MP4就基本上合成成功。

自此，大体的录像流程就这么多。

笔者也是过来人，知道这么讲其实会比较晕，还不如直接丢所有的源码出来，自己慢慢开。所以咱这次直接就全给丢出来。

在此之前，我先总结一下遇到的一些问题 

常见问题

dequeueInputBuffer或dequeueOutputBuffer为-1

首先这个问题得先知道这两个方法返回-1，意味着什么

dequeueInputBuffer返回-1是代表输入缓存区没有空闲的位子，给我们输入数据了。这里经过探究，一般缓存区最大就相当于长度为4的数组，如果一直没有释放掉，可能就会输入几帧数据之后一直放回-1。这个问题的排查解决方式就是。如果一开始就返回-1，那这种情况就比较棘手了，我也不知道怎么搞，没遇到过，看看是不是MediaCodec什么参数没有设置好导致的。

但是如果是走了几帧，后就一直返回-1。拿这时候就有一个比较明确的思路了，赶紧去看看，输出缓存区的数据有没有被处理释放掉，因为输出缓存区的数据一直不去拿去处理释放，输入这边的也就不会释放，所以都是相连的，我之前一直卡着我的就是这个原因导致的 。

而如果dequeueOutputBuffer一直返回-1的话，这时候就代表一直无法可用的输出数据，这时候可以优先去排查一下输入数据有没有输入成功。

录制出来视频绿屏

这个主要就是和长宽之类的参数有关了，从Imagereader到MediaCodec的长宽设置一定要一致，否则极易绿屏，还有可能是YUV转NV21的时候有问题，可以着重排查一下这两个地方。

源码展示

布局文件

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     tools:context=".MainActivity"
  8.     android:orientation="vertical"
  9.     android:keepScreenOn="true">
  10.  
  11.     <TextureView
  12.         android:id="@+id/previewtexture"
  13.         android:layout_weight="1"
  14.         android:layout_width="720dp"
  15.         android:layout_height="720dp"/>
  16.     <Button
  17.         android:id="@+id/shutterclick"
  18.         android:layout_margin="20dp"
  19.         android:layout_width="match_parent"
  20.         android:layout_height="50dp"
  21.         android:text="点击录像"/>
  22.  
  23. </LinearLayout>

逻辑文件 

  1. package com.example.newwaytorecordcameraapplication;
  2.  
  3. import static android.media.MediaFormat.MIMETYPE_AUDIO_AAC;
  4.  
  5. import androidx.annotation.NonNull;
  6. import androidx.appcompat.app.AppCompatActivity;
  7. import androidx.core.app.ActivityCompat;
  8.  
  9. import android.Manifest;
  10. import android.content.Context;
  11. import android.content.pm.PackageManager;
  12. import android.graphics.ImageFormat;
  13. import android.graphics.SurfaceTexture;
  14. import android.hardware.camera2.CameraAccessException;
  15. import android.hardware.camera2.CameraCaptureSession;
  16. import android.hardware.camera2.CameraCharacteristics;
  17. import android.hardware.camera2.CameraDevice;
  18. import android.hardware.camera2.CameraManager;
  19. import android.hardware.camera2.CaptureRequest;
  20. import android.hardware.camera2.TotalCaptureResult;
  21. import android.hardware.camera2.params.StreamConfigurationMap;
  22. import android.media.AudioFormat;
  23. import android.media.AudioRecord;
  24. import android.media.Image;
  25. import android.media.ImageReader;
  26. import android.media.MediaCodec;
  27. import android.media.MediaCodecInfo;
  28. import android.media.MediaFormat;
  29. import android.media.MediaMuxer;
  30. import android.media.MediaRecorder;
  31. import android.os.Bundle;
  32. import android.os.Environment;
  33. import android.os.Handler;
  34. import android.os.HandlerThread;
  35. import android.os.Message;
  36. import android.os.SystemClock;
  37. import android.provider.MediaStore;
  38. import android.util.Log;
  39. import android.util.Size;
  40. import android.view.Surface;
  41. import android.view.TextureView;
  42. import android.view.View;
  43. import android.widget.Button;
  44. import android.widget.Toast;
  45.  
  46. import java.io.IOException;
  47. import java.nio.ByteBuffer;
  48. import java.text.DateFormat;
  49. import java.text.SimpleDateFormat;
  50. import java.util.ArrayList;
  51. import java.util.Arrays;
  52. import java.util.Collections;
  53. import java.util.Date;
  54. import java.util.List;
  55. import java.util.concurrent.atomic.AtomicBoolean;
  56.  
  57. public class MainActivity extends AppCompatActivity implements View.OnClickListener {
  58.     private TextureView previewTextureView;
  59.     private Button shutterClick;
  60.     private Size previewSize;
  61.     private static final String TAG = "VideoRecord";
  62.     private String mCameraId;
  63.     private Handler cameraHandler;
  64.     private CameraCaptureSession previewCaptureSession;
  65.     private MediaCodec videoMediaCodec;
  66.     private AudioRecord audioRecord;
  67.     private boolean isRecordingVideo = false;
  68.     private int mWidth;
  69.     private int mHeight;
  70.     private ImageReader previewImageReader;
  71.     private Handler previewCaptureHandler;
  72.     private CaptureRequest.Builder videoRequest;
  73.     private static final int WAIT_TIME = 0;
  74.     private static final int SAMPLE_RATE = 44100;
  75.     private long nanoTime;
  76.     private int AudioiMinBufferSize;
  77.     private boolean mIsAudioRecording = false;
  78.     private static final int CHANNEL_COUNT = 2;
  79.     private MediaCodec AudioCodec;
  80.     private static final int BIT_RATE = 96000;
  81.     private MediaMuxer mediaMuxer;
  82.     private volatile int mAudioTrackIndex = -1;
  83.     private volatile int mVideoTrackIndex = -1;
  84.     private volatile int isMediaMuxerStarted = -1;
  85.     private Thread audioRecordThread;
  86.     private Thread VideoCodecThread;
  87.     private Thread AudioCodecThread;
  88.     private long presentationTimeUs;
  89.     private AudioCaptureListener captureListener;
  90.     private volatile int isStop=0;
  91.     CaptureRequest.Builder previewCaptureRequestBuilder;
  92.     private volatile int videoMediaCodecIsStoped=0;
  93.     private volatile int AudioCodecIsStoped=0;
  94.  
  95.     @Override
  96.     protected void onCreate(Bundle savedInstanceState) {
  97.         super.onCreate(savedInstanceState);
  98.         setContentView(R.layout.activity_main);
  99.         initView();
  100.     }
  101.  
  102.     //1.初始化MediaCodec视频编码
  103.     //设置mediaformat，到时候放到MediaRecodc里面
  104.     private void initMediaCodec(int width, int height) {
  105.         Log.d(TAG, "width:" + width);
  106.         Log.d(TAG, "Height:" + height);
  107.         try {
  108.             //先拿到格式容器
  109.             /*
  110.               MediaFormat.createVideoFormat中的宽高参数，不能为奇数
  111.               过小或超过屏幕尺寸，也会出现这个错误
  112.             */
  113.             MediaFormat videoFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, 1440, 1440);
  114.             //设置色彩控件
  115.             videoFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible);
  116.             //设置码率，码率就是数据传输单位时间传递的数据位数
  117.             videoFormat.setInteger(MediaFormat.KEY_BIT_RATE, 500_000);
  118.             //设置帧率
  119.             videoFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 20);
  120.             //设置关键帧间隔
  121.             videoFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
  122.             videoFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE,4000000);
  123.             //创建MediaCodc
  124.             videoMediaCodec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
  125.             videoMediaCodec.configure(videoFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
  126.         } catch (IOException e) {
  127.             throw new RuntimeException(e);
  128.         }
  129.     }
  130.  
  131.     private void initView() {
  132.         previewTextureView = findViewById(R.id.previewtexture);
  133.         shutterClick = findViewById(R.id.shutterclick);
  134.         shutterClick.setOnClickListener(this);
  135.     }
  136.  
  137.     @Override
  138.     protected void onResume() {
  139.         super.onResume();
  140.         previewTextureView.setSurfaceTextureListener(new TextureView.SurfaceTextureListener() {
  141.             @Override
  142.             public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surfaceTexture, int width, int height) {
  143.                 Log.d(TAG, "onSurfaceTextureAvailable");
  144.                 setupCamera(width, height);
  145.  
  146.             }
  147.  
  148.             @Override
  149.             public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surfaceTexture, int i, int i1) {
  150.  
  151.             }
  152.  
  153.             @Override
  154.             public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surfaceTexture) {
  155.                 return false;
  156.             }
  157.  
  158.             @Override
  159.             public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surfaceTexture) {
  160.  
  161.             }
  162.         });
  163.         HandlerThread videoRecordThread = new HandlerThread("VideoRecordThread");
  164.         videoRecordThread.start();
  165.         cameraHandler = new Handler(videoRecordThread.getLooper()) {
  166.             @Override
  167.             public void handleMessage(@NonNull Message msg) {
  168.                 super.handleMessage(msg);
  169.             }
  170.         };
  171.         HandlerThread preivewImageReaderThread = new HandlerThread("preivewImageReaderThread");
  172.         preivewImageReaderThread.start();
  173.         previewCaptureHandler = new Handler(preivewImageReaderThread.getLooper()) {
  174.             @Override
  175.             public void handleMessage(@NonNull Message msg) {
  176.                 super.handleMessage(msg);
  177.             }
  178.         };
  179.     }
  180.  
  181.     //设置预览的ImageReader
  182.     private void setPreviewImageReader() {
  183.         previewImageReader = ImageReader.newInstance(previewSize.getWidth(), previewSize.getHeight(), ImageFormat.YUV_420_888, 1);
  184.         previewImageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
  185.             @Override
  186.             public void onImageAvailable(ImageReader imageReader) {
  187.                 Log.d(TAG,"onImageAvailable");
  188.                 Image image = imageReader.acquireNextImage();
  189.                 int width = image.getWidth();
  190.                 int height = image.getHeight();
  191.                 int I420size = width * height*3/2;
  192.                 Log.d(TAG,"I420size:"+I420size);
  193.                 byte[] nv21 = new byte[I420size];
  194.                 YUVToNV21_NV12(image,nv21,image.getWidth(),image.getHeight(),"NV21");
  195.  
  196.                 encodeVideo(nv21);
  197.                 image.close();
  198.             }
  199.         }, previewCaptureHandler);
  200.     }
  201.  
  202.     private static byte[] YUV_420_888toNV21(Image image) {
  203.         int width =  image.getWidth();
  204.         int height = image.getHeight();
  205.         Log.d(TAG,"image.getWidth():"+image.getWidth());
  206.         Log.d(TAG,"image.getHeight()"+image.getHeight());
  207.         ByteBuffer yBuffer = getBufferWithoutPadding(image.getPlanes()[0].getBuffer(), image.getWidth(), image.getPlanes()[0].getRowStride(),image.getHeight(),false);
  208.         ByteBuffer vBuffer;
  209.         //part1 获得真正的消除padding的ybuffer和ubuffer。需要对P格式和SP格式做不同的处理。如果是P格式的话只能逐像素去做，性能会降低。
  210.         if(image.getPlanes()[2].getPixelStride()==1){ //如果为true，说明是P格式。
  211.             vBuffer = getuvBufferWithoutPaddingP(image.getPlanes()[1].getBuffer(), image.getPlanes()[2].getBuffer(),
  212.                     width,height,image.getPlanes()[1].getRowStride(),image.getPlanes()[1].getPixelStride());
  213.         }else{
  214.             vBuffer = getBufferWithoutPadding(image.getPlanes()[2].getBuffer(), image.getWidth(), image.getPlanes()[2].getRowStride(),image.getHeight()/2,true);
  215.         }
  216.  
  217.         //part2 将y数据和uv的交替数据（除去最后一个v值）赋值给nv21
  218.         int ySize = yBuffer.remaining();
  219.         int vSize = vBuffer.remaining();
  220.         byte[] nv21;
  221.         int byteSize = width*height*3/2;
  222.         nv21 = new byte[byteSize];
  223.         yBuffer.get(nv21, 0, ySize);
  224.         vBuffer.get(nv21, ySize, vSize);
  225.  
  226.         //part3 最后一个像素值的u值是缺失的，因此需要从u平面取一下。
  227.         ByteBuffer uPlane = image.getPlanes()[1].getBuffer();
  228.         byte lastValue = uPlane.get(uPlane.capacity() - 1);
  229.         nv21[byteSize - 1] = lastValue;
  230.         return nv21;
  231.     }
  232.  
  233.     //Semi-Planar格式（SP）的处理和y通道的数据
  234.     private static ByteBuffer getBufferWithoutPadding(ByteBuffer buffer, int width, int rowStride, int times,boolean isVbuffer){
  235.         if(width == rowStride) return buffer;  //没有buffer,不用处理。
  236.         int bufferPos = buffer.position();
  237.         int cap = buffer.capacity();
  238.         byte []byteArray = new byte[times*width];
  239.         int pos = 0;
  240.         //对于y平面，要逐行赋值的次数就是height次。对于uv交替的平面，赋值的次数是height/2次
  241.         for (int i=0;i<times;i++) {
  242.             buffer.position(bufferPos);
  243.             //part 1.1 对于u,v通道,会缺失最后一个像u值或者v值，因此需要特殊处理，否则会crash
  244.             if(isVbuffer && i==times-1){
  245.                 width = width -1;
  246.             }
  247.             buffer.get(byteArray, pos, width);
  248.             bufferPos+= rowStride;
  249.             pos = pos+width;
  250.         }
  251.  
  252.         //nv21数组转成buffer并返回
  253.         ByteBuffer bufferWithoutPaddings=ByteBuffer.allocate(byteArray.length);
  254.         // 数组放到buffer中
  255.         bufferWithoutPaddings.put(byteArray);
  256.         //重置 limit 和postion 值否则 buffer 读取数据不对
  257.         bufferWithoutPaddings.flip();
  258.         return bufferWithoutPaddings;
  259.     }
  260.  
  261.     //Planar格式（P）的处理
  262.     private static ByteBuffer getuvBufferWithoutPaddingP(ByteBuffer uBuffer,ByteBuffer vBuffer, int width, int height, int rowStride, int pixelStride){
  263.         int pos = 0;
  264.         byte []byteArray = new byte[height*width/2];
  265.         for (int row=0; row<height/2; row++) {
  266.             for (int col=0; col<width/2; col++) {
  267.                 int vuPos = col*pixelStride + row*rowStride;
  268.                 byteArray[pos++] = vBuffer.get(vuPos);
  269.                 byteArray[pos++] = uBuffer.get(vuPos);
  270.             }
  271.         }
  272.         ByteBuffer bufferWithoutPaddings=ByteBuffer.allocate(byteArray.length);
  273.         // 数组放到buffer中
  274.         bufferWithoutPaddings.put(byteArray);
  275.         //重置 limit 和postion 值否则 buffer 读取数据不对
  276.         bufferWithoutPaddings.flip();
  277.         return bufferWithoutPaddings;
  278.     }
  279.  
  280.     private void encodeVideo(byte[] nv21) {
  281.         //输入
  282.         int index = videoMediaCodec.dequeueInputBuffer(WAIT_TIME);
  283.         //Log.d(TAG,"video encord video index:"+index);
  284.         if (index >= 0) {
  285.             ByteBuffer inputBuffer = videoMediaCodec.getInputBuffer(index);
  286.             inputBuffer.clear();
  287.             int remaining = inputBuffer.remaining();
  288.             inputBuffer.put(nv21, 0, nv21.length);
  289.             videoMediaCodec.queueInputBuffer(index, 0, nv21.length, (System.nanoTime()-nanoTime) / 1000, 0);
  290.         }
  291.     }
  292.  
  293.     private void encodeVideoH264() {
  294.         MediaCodec.BufferInfo videoBufferInfo = new MediaCodec.BufferInfo();
  295.         int videobufferindex = videoMediaCodec.dequeueOutputBuffer(videoBufferInfo, 0);
  296.         Log.d(TAG,"videobufferindex:"+videobufferindex);
  297.         if (videobufferindex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
  298.             //添加轨道
  299.             mVideoTrackIndex = mediaMuxer.addTrack(videoMediaCodec.getOutputFormat());
  300.             Log.d(TAG,"mVideoTrackIndex:"+mVideoTrackIndex);
  301.             if (mAudioTrackIndex != -1) {
  302.                 Log.d(TAG,"encodeVideoH264:mediaMuxer is Start");
  303.                 mediaMuxer.start();
  304.                 isMediaMuxerStarted+=1;
  305.                 setPCMListener();
  306.             }
  307.         } else {
  308.             if (isMediaMuxerStarted>=0) {
  309.                 while (videobufferindex >= 0) {
  310.                     //获取输出数据成功
  311.                     ByteBuffer videoOutputBuffer = videoMediaCodec.getOutputBuffer(videobufferindex);
  312.                     Log.d(TAG,"Video mediaMuxer writeSampleData");
  313.                     mediaMuxer.writeSampleData(mVideoTrackIndex, videoOutputBuffer, videoBufferInfo);
  314.                     videoMediaCodec.releaseOutputBuffer(videobufferindex, false);
  315.                     videobufferindex=videoMediaCodec.dequeueOutputBuffer(videoBufferInfo,0);
  316.                 }
  317.             }
  318.         }
  319.  
  320.     }
  321.  
  322.     private void encodePCMToAC() {
  323.         MediaCodec.BufferInfo audioBufferInfo = new MediaCodec.BufferInfo();
  324.         //获得输出
  325.         int audioBufferFlag = AudioCodec.dequeueOutputBuffer(audioBufferInfo, 0);
  326.         Log.d(TAG, "CALL BACK DATA FLAG:" + audioBufferFlag);
  327.         if (audioBufferFlag==MediaCodec.INFO_OUTPUT_FORMAT_CHANGED){
  328.             //這時候進行添加軌道
  329.             mAudioTrackIndex=mediaMuxer.addTrack(AudioCodec.getOutputFormat());
  330.             Log.d(TAG,"mAudioTrackIndex:"+mAudioTrackIndex);
  331.             if (mVideoTrackIndex!=-1){
  332.                 Log.d(TAG,"encodecPCMToACC:mediaMuxer is Start");
  333.                 mediaMuxer.start();
  334.                 isMediaMuxerStarted+=1;
  335.                 //开始了再创建录音回调
  336.                 setPCMListener();
  337.             }
  338.         }else {
  339.             Log.d(TAG,"isMediaMuxerStarted:"+isMediaMuxerStarted);
  340.             if (isMediaMuxerStarted>=0){
  341.                 while (audioBufferFlag>=0){
  342.                     ByteBuffer outputBuffer = AudioCodec.getOutputBuffer(audioBufferFlag);
  343.                     mediaMuxer.writeSampleData(mAudioTrackIndex,outputBuffer,audioBufferInfo);
  344.                     AudioCodec.releaseOutputBuffer(audioBufferFlag,false);
  345.                     audioBufferFlag = AudioCodec.dequeueOutputBuffer(audioBufferInfo, 0);
  346.                 }
  347.             }
  348.         }
  349.  
  350.     }
  351.  
  352.     private void setPCMListener() {
  353.         setCaptureListener(new AudioCaptureListener() {
  354.             @Override
  355.             public void onCaptureListener(byte[] audioSource, int audioReadSize) {
  356.                 callbackData(audioSource,audioReadSize);
  357.             }
  358.         });
  359.     }
  360.  
  361.     private static void YUVToNV21_NV12(Image image, byte[] nv21, int w, int h, String type) {
  362.         Image.Plane[] planes = image.getPlanes();
  363.         int remaining0 = planes[0].getBuffer().remaining();
  364.         int remaining1 = planes[1].getBuffer().remaining();
  365.         int remaining2 = planes[2].getBuffer().remaining();
  366.         //分别准备三个数组接收YUV分量。
  367.         byte[] yRawSrcBytes = new byte[remaining0];
  368.         byte[] uRawSrcBytes = new byte[remaining1];
  369.         byte[] vRawSrcBytes = new byte[remaining2];
  370.         planes[0].getBuffer().get(yRawSrcBytes);
  371.         planes[1].getBuffer().get(uRawSrcBytes);
  372.         planes[2].getBuffer().get(vRawSrcBytes);
  373.         int j = 0, k = 0;
  374.         boolean flag = type.equals("NV21");
  375.         for (int i = 0; i < nv21.length; i++) {
  376.             if (i < w * h) {
  377.                 //首先填充w*h个Y分量
  378.                 nv21[i] = yRawSrcBytes[i];
  379.             } else {
  380.                 if (flag) {
  381.                     //若NV21类型 则Y分量分配完后第一个将是V分量
  382.                     nv21[i] = vRawSrcBytes[j];
  383.                     //PixelStride有用数据步长 = 1紧凑按顺序填充，=2每间隔一个填充数据
  384.                     j += planes[1].getPixelStride();
  385.                 } else {
  386.                     //若NV12类型 则Y分量分配完后第一个将是U分量
  387.                     nv21[i] = uRawSrcBytes[k];
  388.                     //PixelStride有用数据步长 = 1紧凑按顺序填充，=2每间隔一个填充数据
  389.                     k += planes[2].getPixelStride();
  390.                 }
  391.                 //紧接着可以交错UV或者VU排列不停的改变flag标志即可交错排列
  392.                 flag = !flag;
  393.             }
  394.         }
  395.     }
  396.  
  397.     private void setupCamera(int width, int height) {
  398.         CameraManager cameraManage = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  399.         try {
  400.             String[] cameraIdList = cameraManage.getCameraIdList();
  401.             for (String cameraId : cameraIdList) {
  402.                 CameraCharacteristics cameraCharacteristics = cameraManage.getCameraCharacteristics(cameraId);
  403.                 //demo就就简单写写后摄录像
  404.                 if (cameraCharacteristics.get(CameraCharacteristics.LENS_FACING) != CameraCharacteristics.LENS_FACING_BACK) {
  405.                     //表示匹配到前摄，直接跳过这次循环
  406.                     continue;
  407.                 }
  408.                 StreamConfigurationMap map = cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  409.                 Size[] outputSizes = map.getOutputSizes(SurfaceTexture.class);
  410.                 Size size = new Size(1440, 1440);
  411.                 previewSize = size;
  412.                 mWidth = previewSize.getWidth();
  413.                 mHeight = previewSize.getHeight();
  414.                 mCameraId = cameraId;
  415.             }
  416.         } catch (CameraAccessException e) {
  417.             throw new RuntimeException(e);
  418.         }
  419.         openCamera();
  420.     }
  421.  
  422.     private void initAudioRecord() {
  423.         AudioiMinBufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, AudioFormat.CHANNEL_IN_STEREO, AudioFormat.ENCODING_PCM_16BIT);
  424.         if (ActivityCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
  425.             // TODO: Consider calling
  426.             //    ActivityCompat#requestPermissions
  427.             // here to request the missing permissions, and then overriding
  428.             //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  429.             //                                          int[] grantResults)
  430.             // to handle the case where the user grants the permission. See the documentation
  431.             // for ActivityCompat#requestPermissions for more details.
  432.             return;
  433.         }
  434.         audioRecord = new AudioRecord.Builder()
  435.                 .setAudioFormat(new AudioFormat.Builder()
  436.                         .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
  437.                         .setSampleRate(SAMPLE_RATE)
  438.                         .setChannelMask(AudioFormat.CHANNEL_IN_MONO).build())
  439.                 .setBufferSizeInBytes(AudioiMinBufferSize)
  440.                 .setAudioSource(MediaRecorder.AudioSource.MIC)
  441.                 .build();
  442.     }
  443.  
  444.     private void openCamera() {
  445.         Log.d(TAG, "openCamera: success");
  446.         CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  447.         try {
  448.             if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
  449.                 // TODO: Consider calling
  450.                 //    ActivityCompat#requestPermissions
  451.                 // here to request the missing permissions, and then overriding
  452.                 //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  453.                 //                                          int[] grantResults)
  454.                 // to handle the case where the user grants the permission. See the documentation
  455.                 // for ActivityCompat#requestPermissions for more details.
  456.                 return;
  457.             }
  458.             cameraManager.openCamera(mCameraId, stateCallback, cameraHandler);
  459.         } catch (CameraAccessException e) {
  460.             e.printStackTrace();
  461.         }
  462.     }
  463.  
  464.     private CameraDevice mCameraDevice;
  465.     private CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
  466.  
  467.         @Override
  468.         public void onOpened(@NonNull CameraDevice cameraDevice) {
  469.             Log.d(TAG, "onOpen");
  470.             mCameraDevice = cameraDevice;
  471.             startPreview(mCameraDevice);
  472.         }
  473.  
  474.         @Override
  475.         public void onDisconnected(@NonNull CameraDevice cameraDevice) {
  476.             Log.d(TAG, "onDisconnected");
  477.         }
  478.  
  479.         @Override
  480.         public void onError(@NonNull CameraDevice cameraDevice, int i) {
  481.             Log.d(TAG, "onError");
  482.         }
  483.     };
  484.  
  485.     private void startPreview(CameraDevice mCameraDevice) {
  486.         try {
  487.             Log.d(TAG, "startPreview");
  488.             setPreviewImageReader();
  489.             previewCaptureRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  490.             SurfaceTexture previewSurfaceTexture = previewTextureView.getSurfaceTexture();
  491.             previewSurfaceTexture.setDefaultBufferSize(mWidth, mHeight);
  492.             Surface previewSurface = new Surface(previewSurfaceTexture);
  493.             Surface previewImageReaderSurface = previewImageReader.getSurface();
  494.             previewCaptureRequestBuilder.addTarget(previewSurface);
  495.             mCameraDevice.createCaptureSession(Arrays.asList(previewSurface, previewImageReaderSurface), new CameraCaptureSession.StateCallback() {
  496.                 @Override
  497.                 public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
  498.                     Log.d(TAG, "onConfigured");
  499.                     previewCaptureSession = cameraCaptureSession;
  500.                     try {
  501.                         cameraCaptureSession.setRepeatingRequest(previewCaptureRequestBuilder.build(), cameraPreviewCallback, cameraHandler);
  502.                     } catch (CameraAccessException e) {
  503.                         throw new RuntimeException(e);
  504.                     }
  505.                 }
  506.  
  507.                 @Override
  508.                 public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
  509.  
  510.                 }
  511.             }, cameraHandler);
  512.  
  513.         } catch (CameraAccessException e) {
  514.             throw new RuntimeException(e);
  515.         }
  516.     }
  517.  
  518.     private volatile boolean videoIsReadyToStop=false;
  519.     private CameraCaptureSession.CaptureCallback cameraPreviewCallback=new CameraCaptureSession.CaptureCallback() {
  520.         @Override
  521.         public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
  522.             super.onCaptureCompleted(session, request, result);
  523.             if(videoIsReadyToStop){
  524.                 try {
  525.                     Thread.sleep(1000);
  526.                 } catch (InterruptedException e) {
  527.                     throw new RuntimeException(e);
  528.                 }
  529.                 videoIsReadyToStop=false;
  530.                 stopMediaCodecThread();
  531.             }
  532.  
  533.         }
  534.     };
  535.     private Size getOptimalSize(Size[] sizes, int width, int height) {
  536.         Size tempSize = new Size(width, height);
  537.         List<Size> adaptSize = new ArrayList<>();
  538.         for (Size size : sizes) {
  539.             if (width > height) {
  540.                 //横屏的时候看，或是平板形式
  541.                 if (size.getHeight() > height && size.getWidth() > width) {
  542.                     adaptSize.add(size);
  543.                 }
  544.             } else {
  545.                 //竖屏的时候
  546.                 if (size.getWidth() > height && size.getHeight() > width) {
  547.                     adaptSize.add(size);
  548.                 }
  549.             }
  550.         }
  551.         if (adaptSize.size() > 0) {
  552.             tempSize = adaptSize.get(0);
  553.             int minnum = 999999;
  554.             for (Size size : adaptSize) {
  555.                 int num = size.getHeight() * size.getHeight() - width * height;
  556.                 if (num < minnum) {
  557.                     minnum = num;
  558.                     tempSize = size;
  559.                 }
  560.             }
  561.         }
  562.         return tempSize;
  563.     }
  564.  
  565.     @Override
  566.     public void onClick(View view) {
  567.         switch (view.getId()) {
  568.             case R.id.shutterclick:
  569.                 if (isRecordingVideo) {
  570.                     //stop recording video
  571.                     isRecordingVideo = false;
  572.                     //开始停止录像
  573.                     Log.d(TAG,"Stop recording video");
  574.                     stopRecordingVideo();
  575.                 } else {
  576.                     isRecordingVideo = true;
  577.                     //开始录像
  578.                     startRecording();
  579.                 }
  580.                 break;
  581.         }
  582.     }
  583.  
  584.     private void stopRecordingVideo() {
  585.         stopVideoSession();
  586.         stopAudioRecord();
  587.  
  588.  
  589.     }
  590.  
  591.     private void stopMediaMuxer() {
  592.         isMediaMuxerStarted=-1;
  593.         mediaMuxer.stop();
  594.         mediaMuxer.release();
  595.     }
  596.  
  597.     private void stopMediaCodecThread() {
  598.         isStop=2;
  599.         AudioCodecThread=null;
  600.         VideoCodecThread=null;
  601.     }
  602.  
  603.     private void stopMediaCodec() {
  604.         AudioCodec.stop();
  605.         AudioCodec.release();
  606.         videoMediaCodec.stop();
  607.         videoMediaCodec.release();
  608.     }
  609.  
  610.     private void stopVideoSession() {
  611.         if (previewCaptureSession!=null){
  612.             try {
  613.                 previewCaptureSession.stopRepeating();
  614.                 videoIsReadyToStop=true;
  615.             } catch (CameraAccessException e) {
  616.                 throw new RuntimeException(e);
  617.             }
  618.         }
  619.         try {
  620.             previewCaptureSession.setRepeatingRequest(previewCaptureRequestBuilder.build(), cameraPreviewCallback, cameraHandler);
  621.         } catch (CameraAccessException e) {
  622.             throw new RuntimeException(e);
  623.         }
  624.     }
  625.  
  626.     private void stopAudioRecord() {
  627.         mIsAudioRecording=false;
  628.         audioRecord.stop();
  629.         audioRecord.release();
  630.         audioRecord=null;
  631.         audioRecordThread=null;
  632.     }
  633.  
  634.     private void startRecording() {
  635.         isStop=1;
  636.         nanoTime = System.nanoTime();
  637.         initMediaMuxer();
  638.         initAudioRecord();
  639.         initMediaCodec(mWidth, mHeight);
  640.         initAudioCodec();
  641.         //將MediaCodec分成獨立的線程
  642.         initMediaCodecThread();
  643.         //啟動MediaCodec以及线程
  644.         startMediaCodec();
  645.         //开启录像session
  646.         startVideoSession();
  647.         //音頻開始錄製
  648.         startAudioRecord();
  649.     }
  650.  
  651.     private void startMediaCodec() {
  652.         if (AudioCodec!=null){
  653.             AudioCodecIsStoped=0;
  654.             AudioCodec.start();
  655.         }
  656.         if (videoMediaCodec!=null){
  657.             videoMediaCodecIsStoped=0;
  658.             videoMediaCodec.start();
  659.         }
  660.         if (VideoCodecThread!=null){
  661.             VideoCodecThread.start();
  662.         }
  663.         if (AudioCodecThread!=null){
  664.             AudioCodecThread.start();
  665.         }
  666.     }
  667.  
  668.     private void initMediaCodecThread() {
  669.         VideoCodecThread=new Thread(new Runnable() {
  670.             @Override
  671.             public void run() {
  672.                     //输出为H264
  673.                 while (true){
  674.                     if (isStop==2){
  675.                         Log.d(TAG,"videoMediaCodec is stopping");
  676.                         break;
  677.                     }
  678.                     encodeVideoH264();
  679.                 }
  680.                 videoMediaCodec.stop();
  681.                 videoMediaCodec.release();
  682.                 videoMediaCodecIsStoped=1;
  683.                 if (AudioCodecIsStoped==1){
  684.                     stopMediaMuxer();
  685.                 }
  686.             }
  687.         });
  688.         AudioCodecThread=new Thread(new Runnable() {
  689.             @Override
  690.             public void run() {
  691.                 while (true){
  692.                     if (isStop==2){
  693.                         Log.d(TAG,"AudioCodec is stopping");
  694.                         break;
  695.                     }
  696.                     encodePCMToAC();
  697.                 }
  698.                 AudioCodec.stop();
  699.                 AudioCodec.release();
  700.                 AudioCodecIsStoped=1;
  701.                 if (videoMediaCodecIsStoped==1){
  702.                     stopMediaMuxer();
  703.                 }
  704.             }
  705.         });
  706.     }
  707.  
  708.  
  709.  
  710.     private void startAudioRecord() {
  711.         audioRecordThread = new Thread(new Runnable() {
  712.             @Override
  713.             public void run() {
  714.                 mIsAudioRecording = true;
  715.                 audioRecord.startRecording();
  716.                 while (mIsAudioRecording) {
  717.                     byte[] inputAudioData = new byte[AudioiMinBufferSize];
  718.                     int res = audioRecord.read(inputAudioData, 0, inputAudioData.length);
  719.                     if (res > 0) {
  720.                         //Log.d(TAG,res+"");
  721.                         if (AudioCodec!=null){
  722.                             if (captureListener!=null){
  723.                                 captureListener.onCaptureListener(inputAudioData,res);
  724.                             }
  725.                             //callbackData(inputAudioData,inputAudioData.length);
  726.                         }
  727.                     }
  728.                 }
  729.             }
  730.         });
  731.         audioRecordThread.start();
  732.     }
  733.  
  734.     private void initMediaMuxer() {
  735.         String filename = Environment.getExternalStorageDirectory().getAbsolutePath() + "/DCIM/Camera/" + getCurrentTime() + ".mp4";
  736.         try {
  737.             mediaMuxer = new MediaMuxer(filename, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
  738.             mediaMuxer.setOrientationHint(90);
  739.         } catch (IOException e) {
  740.             throw new RuntimeException(e);
  741.         }
  742.     }
  743.  
  744.     public String getCurrentTime() {
  745.         Date date = new Date(System.currentTimeMillis());
  746.  
  747.         DateFormat dateFormat = new SimpleDateFormat("yyyyMMddhhmmss");
  748.         return dateFormat.format(date);
  749.     }
  750.  
  751.     //初始化Audio MediaCodec
  752.     private void initAudioCodec() {
  753.         MediaFormat format = MediaFormat.createAudioFormat(MIMETYPE_AUDIO_AAC, SAMPLE_RATE, CHANNEL_COUNT);
  754.         format.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
  755.         format.setInteger(MediaFormat.KEY_BIT_RATE, BIT_RATE);
  756.         format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 8192);
  757.         try {
  758.             AudioCodec = MediaCodec.createEncoderByType(MIMETYPE_AUDIO_AAC);
  759.             AudioCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
  760.         } catch (IOException e) {
  761.             throw new RuntimeException(e);
  762.         }
  763.  
  764.     }
  765.  
  766.     private void callbackData(byte[] inputAudioData, int length) {
  767.         //已经拿到AudioRecord的byte数据
  768.         //准备将其放入到MediaCodc中
  769.         int index = AudioCodec.dequeueInputBuffer(-1);
  770.         if (index<0){
  771.             return;
  772.         }
  773.         Log.d(TAG,"AudioCodec.dequeueInputBuffer:"+index);
  774.         ByteBuffer[] inputBuffers = AudioCodec.getInputBuffers();
  775.         ByteBuffer audioInputBuffer = inputBuffers[index];
  776.         audioInputBuffer.clear();
  777.         Log.d(TAG, "call back Data length:" + length);
  778.         Log.d(TAG, "call back Data audioInputBuffer remain:" + audioInputBuffer.remaining());
  779.         audioInputBuffer.put(inputAudioData);
  780.         audioInputBuffer.limit(inputAudioData.length);
  781.         presentationTimeUs += (long) (1.0 * length / (44100 * 2 * (16 / 8)) * 1000000.0);
  782.         AudioCodec.queueInputBuffer(index, 0, inputAudioData.length, (System.nanoTime()-nanoTime)/1000, 0);
  783.     }
  784.  
  785.     /*private void getEncordData() {
  786.         MediaCodec.BufferInfo outputBufferInfo = new MediaCodec.BufferInfo();
  787.         //获得输出
  788.         int flag = AudioCodec.dequeueOutputBuffer(outputBufferInfo, 0);
  789.         Log.d(TAG, "CALL BACK DATA FLAG:" + flag);
  790.         if (flag == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
  791.             //第一次都会执行这个
  792.             //这时候可以加轨道到MediaMuxer中，但是先不要启动，等到两个轨道都加好再start
  793.             mAudioTrackIndex = mediaMuxer.addTrack(AudioCodec.getOutputFormat());
  794.             if (mAudioTrackIndex != -1 && mVideoTrackIndex != -1) {
  795.                 mediaMuxer.start();
  796.                 Log.d(TAG, "AudioMediaCodec start mediaMuxer");
  797.                 isMediaMuxerStarted = true;
  798.             }
  799.         } else {
  800.             if (isMediaMuxerStarted) {
  801.                 if (flag >= 0) {
  802.                     if (mAudioTrackIndex != -1) {
  803.                         Log.d(TAG, "AudioCodec.getOutputBuffer:");
  804.                         ByteBuffer outputBuffer = AudioCodec.getOutputBuffer(flag);
  805.                         mediaMuxer.writeSampleData(mAudioTrackIndex, outputBuffer, outputBufferInfo);
  806.                         AudioCodec.releaseOutputBuffer(flag, false);
  807.                     }
  808.                 }
  809.             }
  810.         }
  811.     }*/
  812.  
  813.     private void startVideoSession() {
  814.         Log.d(TAG, "startVideoSession");
  815.         if (previewCaptureSession!=null){
  816.             try {
  817.                 previewCaptureSession.stopRepeating();
  818.             } catch (CameraAccessException e) {
  819.                 throw new RuntimeException(e);
  820.             }
  821.         }
  822.         SurfaceTexture previewSurfaceTexture = previewTextureView.getSurfaceTexture();
  823.         Surface previewSurface = new Surface(previewSurfaceTexture);
  824.         Surface previewImageReaderSurface = previewImageReader.getSurface();
  825.         try {
  826.             videoRequest = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
  827.             videoRequest.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  828.             videoRequest.addTarget(previewSurface);
  829.             videoRequest.addTarget(previewImageReaderSurface);
  830.             previewCaptureSession.setRepeatingRequest(videoRequest.build(), videosessioncallback, cameraHandler);
  831.         } catch (CameraAccessException e) {
  832.             throw new RuntimeException(e);
  833.         }
  834.     }
  835.  
  836.     private CameraCaptureSession.CaptureCallback videosessioncallback = new CameraCaptureSession.CaptureCallback() {
  837.         @Override
  838.         public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
  839.             super.onCaptureCompleted(session, request, result);
  840.         }
  841.     };
  842.  
  843.     public interface AudioCaptureListener {
  844.  
  845.         /**
  846.          * 音频采集回调数据源
  847.          *
  848.          * @param audioSource ：音频采集回调数据源
  849.          * @param audioReadSize :每次读取数据的大小
  850.          */
  851.         void onCaptureListener(byte[] audioSource,int audioReadSize);
  852.     }
  853.  
  854.     public AudioCaptureListener getCaptureListener() {
  855.         return captureListener;
  856.     }
  857.  
  858.     public void setCaptureListener(AudioCaptureListener captureListener) {
  859.         this.captureListener = captureListener;
  860.     }
  861.  
  862. }

 自此一个基本功能就完成了。

但是我这边留了一些问题，没有解决，因为不是这个demo的重点。首先就是录像结束后第二次点击录像会闪退。

其次音频时间戳有点对不上，导致有点变声。

各位观众可以后续研究一下。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号