• MediaCodec视频编码H264流程及参考demo

            关于MediaCodec的简介和生命周期的讲解，在上一篇文章 MediaCodec视频解码流程详解及参考demo中已经阐述。

            本文则讲解使用MediaCodec进行视频编码的流程，主要通过一个例子，从摄像头采集数据，并将数据编码为h264文件。

    一、MediaCodec简介及生命周期

            在上面提到的文章中已阐述。

    二、MediaCodec编码流程

            下面将讲解使用mediacodec编码h264文件的API使用流程。本文主要是采用同步的编码方式。

            编码流程工作模型，与解码是一样：

    1、创建mediacodec并初始化

            可通过createDecoderByType来创建mediacodec：

    1. // 创建 MediaCodec，此时是 Uninitialized 状态
    2. mediaCodec = MediaCodec.createEncoderByType("video/avc");

            上面表示创建了一个编码器，但是还需要对这个编码器进行一些配置，包括格式，码率帧率等等，如下：

    1. MediaFormat mediaFormat = MediaFormat.createVideoFormat("video/avc", width, height);
    2. mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar);        //颜色格式
    3. mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, width*height*5);                                                     //码率
    4. mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 30);                                                               //帧率
    5. mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);                                                          //I 帧间隔

            设置好相关配置格式后，调用configure进行配置。

    1. // 调用 configure 进入 Configured 状态
    2. mediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);

            配置好后，可以调用start启动编码工作，进入Executing状态。不过一开始调用start后是先进入Executing的子状态Flushed状态，等后面编码线程启动后有数据了，才真正进入Running状态：

    1. // 调用 start 进入 Executing 状态，开始准备编解码工作
    2. mediaCodec.start();

    2、编码线程

            编码线程是真正的编码过程，本例子是将数据编码为h264。

            在启动线程之前，先创建个文件，用来保存编码后的h264数据，如下：

    1. private BufferedOutputStream outputStream;
    2. FileOutputStream outStream;
    3. private void createfile(String path){
    4.     File file = new File(path);
    5.     Log.d(TAG,"createfile path = "+path);
    6.     if(file.exists()){
    7.         file.delete();
    8.     }
    9.     try {
    10.         outputStream = new BufferedOutputStream(new FileOutputStream(file));
    11.     } catch (Exception e){
    12.         e.printStackTrace();
    13.     }
    14. }

            获取可用的输入缓冲区的索引：

    int inputBufferIndex = mediaCodec.dequeueInputBuffer(-1);

            获取输入缓冲区：

    1. // 输入缓冲区
    2. ByteBuffer[] inputBuffers = mediaCodec.getInputBuffers();

            从输入缓冲区队列中取出可用缓冲区，并填充数据：

    1. // 从输入缓冲区队列中取出可用缓冲区，并填充数据
    2. if (inputBufferIndex >= 0) {
    3.     // 计算时间戳
    4.     pts = computePresentationTime(generateIndex);
    5.     ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
    6.     inputBuffer.clear();
    7.     inputBuffer.put(input);
    8.     mediaCodec.queueInputBuffer(inputBufferIndex, 0, input.length, pts, 0);
    9.     generateIndex += 1;
    10. }

            创建输出缓冲区：

    1. //输出缓冲区
    2. ByteBuffer[] outputBuffers = mediaCodec.getOutputBuffers();

            获取已成功编解码的输出缓冲区的索引：

    1. MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
    2. int outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);

            从输出缓冲区队列中拿到编解码后的内容，配置相关内容，包括SPS，PPS等，然后进行相应操作（这里是写入output h264文件）后释放，供下一次使用：

    1. // 从输出缓冲区队列中拿到编解码后的内容，进行相应操作（这里是写入output h264文件）后释放，供下一次使用
    2. while (outputBufferIndex >= 0) {
    3.     ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
    4.     byte[] outData = new byte[bufferInfo.size];
    5.     outputBuffer.get(outData);
    6.     // flags 判断
    7.     if(bufferInfo.flags == 2){   // 配置相关的内容，也就是 SPS，PPS
    8.         configbyte = new byte[bufferInfo.size];
    9.         configbyte = outData;
    10.     }else if(bufferInfo.flags == 1){   //关键帧
    11.         byte[] keyframe = new byte[bufferInfo.size + configbyte.length];
    12.         System.arraycopy(configbyte, 0, keyframe, 0, configbyte.length);
    13.         System.arraycopy(outData, 0, keyframe, configbyte.length, outData.length);
    14.  
    15.         outputStream.write(keyframe, 0, keyframe.length);
    16.     }else{      // 非关键帧和SPS、PPS,直接写入文件，可能是B帧或者P帧
    17.         outputStream.write(outData, 0, outData.length);
    18.     }
    19.     mediaCodec.releaseOutputBuffer(outputBufferIndex, false);
    20.     outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);
    21. }

            完整编码线程代码如下：

    1. //编码子线程
    2. public void StartEncoderThread(){
    3.     Thread EncoderThread = new Thread(new Runnable() {
    4.  
    5.         @SuppressLint("NewApi")
    6.         @Override
    7.         public void run() {
    8.             isRuning = true;
    9.             byte[] input = null;
    10.             long pts =  0;
    11.             long generateIndex = 0;
    12.  
    13.             while (isRuning) {
    14.                 if (MainActivity.YUVQueue.size() >0){
    15.                     input = MainActivity.YUVQueue.poll();
    16.                     byte[] yuv420sp = new byte[m_width*m_height*3/2];
    17.                     NV21ToNV12(input,yuv420sp,m_width,m_height);
    18.                     input = yuv420sp;
    19.                 }
    20.                 if (input != null) {
    21.                     try {
    22.                         long startMs = System.currentTimeMillis();
    23.                         // 输入缓冲区
    24.                         ByteBuffer[] inputBuffers = mediaCodec.getInputBuffers();
    25.                         // 输出缓冲区
    26.                         ByteBuffer[] outputBuffers = mediaCodec.getOutputBuffers();
    27.                         // 从输入缓冲区队列中取出可用缓冲区，并填充数据
    28.                         int inputBufferIndex = mediaCodec.dequeueInputBuffer(-1);
    29.                         if (inputBufferIndex >= 0) {
    30.                             // 计算时间戳
    31.                             pts = computePresentationTime(generateIndex);
    32.                             ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
    33.                             inputBuffer.clear();
    34.                             inputBuffer.put(input);
    35.                             mediaCodec.queueInputBuffer(inputBufferIndex, 0, input.length, pts, 0);
    36.                             generateIndex += 1;
    37.                         }
    38.  
    39.                         MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
    40.                         // 从输出缓冲区队列中拿到编解码后的内容，进行相应操作（这里是写入output h264文件）后释放，供下一次使用
    41.                         int outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);
    42.                         while (outputBufferIndex >= 0) {
    43.                             //Log.d(TAG, "Get H264 Buffer Success! flag = "+bufferInfo.flags+",pts = "+bufferInfo.presentationTimeUs+"");
    44.                             ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
    45.                             byte[] outData = new byte[bufferInfo.size];
    46.                             outputBuffer.get(outData);
    47.                             // flags 判断
    48.                             if(bufferInfo.flags == 2){   // 配置相关的内容，也就是 SPS，PPS
    49.                                 configbyte = new byte[bufferInfo.size];
    50.                                 configbyte = outData;
    51.                             }else if(bufferInfo.flags == 1){   //关键帧
    52.                                 byte[] keyframe = new byte[bufferInfo.size + configbyte.length];
    53.                                 System.arraycopy(configbyte, 0, keyframe, 0, configbyte.length);
    54.                                 System.arraycopy(outData, 0, keyframe, configbyte.length, outData.length);
    55.  
    56.                                 outputStream.write(keyframe, 0, keyframe.length);
    57.                             }else{      // 非关键帧和SPS、PPS,直接写入文件，可能是B帧或者P帧
    58.                                 outputStream.write(outData, 0, outData.length);
    59.                             }
    60.                             mediaCodec.releaseOutputBuffer(outputBufferIndex, false);
    61.                             outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);
    62.                         }
    63.  
    64.                     } catch (Throwable t) {
    65.                         t.printStackTrace();
    66.                     }
    67.                 } else {
    68.                     try {
    69.                         Thread.sleep(500);
    70.                     } catch (InterruptedException e) {
    71.                         e.printStackTrace();
    72.                     }
    73.                 }
    74.             }
    75.         }
    76.     });
    77.     EncoderThread.start();
    78. }

    3、编码结束关闭回收

            完成编码后，对相关内存回收和线程资源等关闭处理：

    1. private void StopEncoder() {
    2.     try {
    3.         // 调用 stop 方法进入 Uninitialized 状态
    4.         mediaCodec.stop();
    5.         // 调用 release 方法释放，结束操作
    6.         mediaCodec.release();
    7.     } catch (Exception e){
    8.         e.printStackTrace();
    9.     }
    10. }
    11.  
    12. public void StopThread(){
    13.     isRuning = false;
    14.     try {
    15.         StopEncoder();
    16.         outputStream.flush();
    17.         outputStream.close();
    18.     } catch (IOException e) {
    19.         // TODO Auto-generated catch block
    20.         e.printStackTrace();
    21.     }
    22. }

            至此，整个编码为h264文件的过程就结束了。

    三、demo运行

            本人写了一个最简单的demo，使用mediacodec将摄像头采集到的数据编码为h264文件，采用同步编码的方式。

            关于编码后的h264文件路径，在代码中可以自己修改，如下位置：

            MainActivity.java下的：

            运行demo：

             点击START打开摄像头，进行录像采集摄像头数据：

             录制得差不多了，就点击STOP，完成编码，并提示编码后的h264文件的存放位置。

             完整例子已经放到github上，如下：

    https://github.com/weekend-y/mediacodec_demo/tree/master/MediaCodec_EncodeH264

  • 相关阅读:
    Golang之火爆原因
    Java 网络编程
    条件判断的优化
    Halcon机器视觉实战--分水岭分割+距离变换实现粘连物体图像分割
    百度飞桨AI4S亮相全国动力学设计与反问题研讨会，助力汽车底盘智能设计
    【Houdini】流体渲染流程(进阶版)-- learn from ysy
    小程序InnerAudioContext设置问题记录
    QT 自定义插件问题 error: LNK2001: 无法解析的外部符号
    基于LangChain的LLM应用开发3——记忆
    hexo发生错误 Error: Spawn failed
  • 原文地址：https://blog.csdn.net/weekend_y45/article/details/127764621