• Android RTMP推拉流，MediaCodec硬件编解码

    一 mediacodec简介

    MediaCodec 类可以用来访问底层媒体编解码器，即编码器/解码器的组件。 它是 Android 底层多媒体支持架构的一部分（通常与 MediaExtractor，MediaSync，MediaMuxer，MediaCrypto，MediaDrm，Image，Surface 和 AudioTrack 一起使用）。

    编解码器可以处理三类数据：压缩数据、原始音频数据、原始视频数据。

    a Compressed Buffers 压缩缓冲区

    输入和输出缓冲区包含了对应类型的压缩数据；对于视频类型通常是简单的压缩视频帧；音频数据通常是一个单入单元，(一种编码格式典型的包含了许多 ms 的音频类型)，但当一个缓冲区包含了多种编码音频进入单元，可以不需要。另一方面，缓冲区不能在任意字节边界开始或停止，但当标记了 BUFFERFLAGPARTIAL_FRAME 标记时，可以访问帧或进入单元边界。

    b Raw Audio Buffers 原始音频缓冲区

    原始音频缓冲区包含完整的 PCM 格式的帧数据，一种通道对应一个采样率。每一种采样率是一个 16 位有符号整型在规定参数里面；

    c Raw Video Buffers 原始视频缓冲区

    在 ByteBuffer 模式，视频缓冲区根据颜色格式；可以通过 getCodecInfo().getCapabilitiesForType(…).colorFormats 获取支持的颜色格式，视频编码支持三种类型的颜色格式：

    native raw video format： 标记 COLOR_FormatSurface，可以配合输入输出 surface 使用

    flexible YUV buffers：COLOR_FormatYUV420Flexible，可以配合输入输出 surface、在 ByteBuffer 模式，可以通过 getInput/OutputImage(int)访问

    other, specific formats：这些格式只在 ByteBuffer 模式支持。一些格式是厂商特有的，其他的定义在 MediaCodecInfo.CodecCapabilities；

    自从 5.1.1 之后，所有的编解码器支持 YUV 4:2:0 buffers。

    d Accessing Raw Video ByteBuffers on Older Devices 在老的设备上面访问原始视频缓冲区

    本文福利， 免费领取C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部点击免费领取↓↓

    状态

    编解码器理论上存在三种状态：停止、执行、释放；停止状态也包含三种子状态：未初始化的、已配置的、错误；执行状态也包含三种子状态：已刷新、正在运行、流结束；

    0) 工厂方法创建一个编解码器，处于未初始化状态。

    1) configure(…)方法进入已配置状态。

    2) start()方法进入执行状态。此时，才可以通过上面缓冲队列来处理数据。

    3) start()之后，编解码出于已刷新子状态，此时持有所有的缓冲区；当第一个输入缓冲块被出队时，编解码器会耗费许多时间进入运行状态。当一个输入缓冲块被入队时(被标记流结束标记)，编解码器进入流结束状态；此时，编解码器不在接收输入缓冲块，但是可以产生输出缓冲块，直到流结束块被出队。

    4) 可以在任意时刻，通过调用 flush()，进入已刷新状态。

    5) stop()让其进入未初始化状态，如果需要使用，需要再配置一次。

    6) 当你已经用完编解码器，你需要 release()；

    某些情况下，编解码器会遭遇错误进入错误状态；可以根据不合法返回值或者异常来判断；调用 reset()可以复位编码器，让其可以重新使用，并进入未初始化状态。调用 releases()进入最终释放状态。

    1 creating创建

    可以根据指定的 MediaFormat 通过 MediaCodecList 创建一个编解码器；

    可以根据 MediaExtractor.getTrackFormat 来创建一个可以用于解码文件和流的编解码器；

    在引入其他格式之前，当你想 MediaFormat.setFeatureEnabled，需要通过 MediaCodecList.findDecoderForFormat 获得与名字对应的特殊的媒体格式的编解码器；

    最后通过 createByCodecName(String)创建；

    也可以通过 MIME 类型使用 createDecoder/EncoderByType(String)来创建。

    2 Initialization初始化

    creating之后，可以设置回调 setCallback 来异步处理数据；然后 configure 配置指定的媒体格式。你可以为视频生成指定一个输出 surface；也可以设置安全编码，参考 MediaCrypto；最后编解码器运行在多个模式下，需要特殊指定在编码或解码状态；

    如果你想处理原始输入视频缓冲区，可以在配置后通过 createInputSurface()创建一个指定的 Surface。也可以通过 setInputSurface(Surface)设置编解码器使用指定的 Surface。

    AAC audio and MPEG4, H.264 and H.265 video 格式要求预置启动参数或者编解码特殊数据。当处理一些压缩格式时，这些数据必须在任意帧数据之前和 start()之后提交到编解码器。这些数据在调用 queueInputBuffer 时需要被标记 BUFFERFLAGCODEC_CONFIG。

    这些数据也可以通过 configure 来配置，可以从 MediaExtractor 获取并放在 MediaFromat 里面。这些数据会在 start()时提交到比爱你解码器里面。

    编码器会在任何可用数据之前创建和返回特定标记了 codec-config 标记的编码参数，缓冲区包含了没有时间戳的 codec-specific-data。

    3 Data processing执行编解码

    同步模式下，获取一个输入缓冲区之后，填充数据，并通过 queueInputBuffer 提交到 codec，不要提交多个同样时间戳一样的输入数据到 codec。codec 处理完后，会返回一个只读输出缓冲区数据。

    异步模式可以通过 onOutputBufferAvailable 读取，同步模式通过 dequeuOutputBuffer 读取；最后需要调用 releaseOutputBuffer 返回缓冲区到 codec。

    二 用法示例

    1. //播放mp4文件
    2. package com.cclin.jubaohe.activity.Media;
    3. import android.media.AudioFormat;
    4. import android.media.AudioManager;
    5. import android.media.AudioTrack;
    6. import android.media.MediaCodec;
    7. import android.media.MediaExtractor;
    8. import android.media.MediaFormat;
    9. import android.os.Bundle;
    10. import android.view.Surface;
    11. import android.view.SurfaceHolder;
    12. import android.view.SurfaceView;
    13. import android.view.View;
    14. import android.widget.Button;
    15. import com.cclin.jubaohe.R;
    16. import com.cclin.jubaohe.base.BaseActivity;
    17. import com.cclin.jubaohe.util.CameraUtil;
    18. import com.cclin.jubaohe.util.LogUtil;
    19. import com.cclin.jubaohe.util.SDPathConfig;
    20. import java.io.File;
    21. import java.io.IOException;
    22. import java.nio.ByteBuffer;
    23. /**
    24. * Created by LinChengChun on 2018/4/14.
    25. */
    26. public class MediaTestActivity extends BaseActivity implements SurfaceHolder.Callback, View.OnClickListener {
    27.     private final static String MEDIA_FILE_PATH = SDPathConfig.LIVE_MOVIE_PATH+"/18-04-12-10:47:06-0.mp4";
    28.     private Surface mSurface;
    29.     private SurfaceView mSvRenderFromCamera;
    30.     private SurfaceView mSvRenderFromFile;
    31.     Button mBtnCameraPreview;
    32.     Button mBtnPlayMediaFile;
    33.     private MediaStream mMediaStream;
    34.     private Thread mVideoDecoderThread;
    35.     private AudioTrack mAudioTrack;
    36.     private Thread mAudioDecoderThread;
    37.     @Override
    38.     protected void onCreate(Bundle savedInstanceState) {
    39.         super.onCreate(savedInstanceState);
    40.         mBtnCameraPreview = retrieveView(R.id.btn_camera_preview);
    41.         mBtnPlayMediaFile = retrieveView(R.id.btn_play_media_file);
    42.         mBtnCameraPreview.setOnClickListener(this);
    43.         mBtnPlayMediaFile.setOnClickListener(this);
    44.         mSvRenderFromCamera = retrieveView(R.id.sv_render);
    45.         mSvRenderFromCamera.setOnClickListener(this);
    46.         mSvRenderFromCamera.getHolder().addCallback(this);
    47.         mSvRenderFromFile = retrieveView(R.id.sv_display);
    48.         mSvRenderFromFile.setOnClickListener(this);
    49.         mSvRenderFromFile.getHolder().addCallback(this);
    50.         init();
    51.     }
    52.     @Override
    53.     protected int initLayout() {
    54.         return R.layout.activity_media_test;
    55.     }
    56.     private void init(){
    57.         File file = new File(MEDIA_FILE_PATH);
    58.         if (!file.exists()){
    59.             LogUtil.e("文件不存在！！");
    60.             return;
    61.         }
    62.         LogUtil.e("目标文件存在!!");
    63.     }
    64.     private void startVideoDecoder(){
    65.         // fill inputBuffer with valid data
    66.         mVideoDecoderThread = new Thread("mVideoDecoderThread"){
    67.             @Override
    68.             public void run() {
    69.                 super.run();
    70.                 MediaFormat mMfVideo = null, mMfAudio = null;
    71.                 String value = null;
    72.                 String strVideoMime = null;
    73.                 String strAudioMime = null;
    74.                 try {
    75.                     MediaExtractor mediaExtractor = new MediaExtractor(); // 提取器用来从文件中读取音视频
    76.                     mediaExtractor.setDataSource(MEDIA_FILE_PATH);
    77.                     int numTracks = mediaExtractor.getTrackCount(); // 轨道数，一般为2
    78.                     LogUtil.e("获取track数"+numTracks);
    79.                     for (int i=0; i< numTracks; i++) { // 检索每个轨道的格式
    80.                         MediaFormat mediaFormat = mediaExtractor.getTrackFormat(i);
    81.                         LogUtil.e("单独显示track MF："+mediaFormat);
    82.                         value = mediaFormat.getString(MediaFormat.KEY_MIME);
    83.                         if (value.contains("audio")){
    84.                             mMfAudio = mediaFormat;
    85.                             strAudioMime = value;
    86.                         }else {
    87.                             mMfVideo = mediaFormat;
    88.                             strVideoMime = value;
    89.                             mediaExtractor.selectTrack(i);
    90.                         }
    91.                     }
    92.                     mSurface = mSvRenderFromFile.getHolder().getSurface();
    93.                     MediaCodec codec = MediaCodec.createDecoderByType(strVideoMime); // 创建编解码器
    94.                     codec.configure(mMfVideo, mSurface, null, 0); // 配置解码后的视频帧数据直接渲染到Surface
    95.                     codec.setVideoScalingMode(MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT);
    96.                     codec.start(); // 启动编解码器，让codec进入running模式
    97.                     MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo(); //缓冲区信息
    98.                     int size = -1, outputBufferIndex = -1;
    99.                     LogUtil.e("开始解码。。。");
    100.                     long previewStampUs = 0l;
    101.                     do {
    102.                         int inputBufferId = codec.dequeueInputBuffer(10);// 从编码器中获取 输入缓冲区
    103.                         if (inputBufferId >= 0) {
    104.                             ByteBuffer inputBuffer = codec.getInputBuffer(inputBufferId); // 获取该输入缓冲区
    105.                             // fill inputBuffer with valid data
    106.                             inputBuffer.clear(); // 清空缓冲区
    107.                             size = mediaExtractor.readSampleData(inputBuffer, 0); // 从提取器中获取一帧数据填充到输入缓冲区
    108.                             LogUtil.e("readSampleData: size = "+size);
    109.                             if (size < 0)
    110.                                 break;
    111.                             int trackIndex = mediaExtractor.getSampleTrackIndex();
    112.                             long presentationTimeUs = mediaExtractor.getSampleTime(); // 获取采样时间
    113.                             LogUtil.e("queueInputBuffer: 把数据放入编码器。。。");
    114.                             codec.queueInputBuffer(inputBufferId, 0, size, presentationTimeUs, 0); // 将输入缓冲区压入编码器
    115.                             mediaExtractor.advance(); // 获取下一帧
    116.                             LogUtil.e("advance: 获取下一帧。。。");
    117.                             outputBufferIndex = codec.dequeueOutputBuffer(bufferInfo, 10000); // 从编码器中读取解码完的数据
    118.                             LogUtil.e("outputBufferIndex = "+outputBufferIndex);
    119.                             switch (outputBufferIndex) {
    120.                                 case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
    121. //                                    MediaFormat mf = codec.getOutputFormat(outputBufferIndex); // 导致播放视频失败
    122.                                     MediaFormat mf = codec.getOutputFormat();
    123.                                     LogUtil.e("INFO_OUTPUT_FORMAT_CHANGED："+mf);
    124.  
    125.                                     break;
    126.                                 case MediaCodec.INFO_TRY_AGAIN_LATER:
    127.                                     LogUtil.e("解码当前帧超时");
    128.                                     break;
    129.                                 case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
    130.                                     //outputBuffers = videoCodec.getOutputBuffers();
    131.                                     LogUtil.e("output buffers changed");
    132.                                     break;
    133.                                 default:
    134.                                     //直接渲染到Surface时使用不到outputBuffer
    135.                                     //ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
    136.                                     //延时操作
    137.                                     //如果缓冲区里的可展示时间>当前视频播放的进度，就休眠一下
    138.                                     boolean firstTime = previewStampUs == 0l;
    139.                                     long newSleepUs = -1;
    140.                                     long sleepUs = (bufferInfo.presentationTimeUs - previewStampUs);
    141.                                     if (!firstTime) {
    142.                                         long cache = 0;
    143.                                         newSleepUs = CameraUtil.fixSleepTime(sleepUs, cache, -100000);
    144.                                     }
    145.                                     previewStampUs = bufferInfo.presentationTimeUs;
    146.                                     //渲染
    147.                                     if (newSleepUs < 0)
    148.                                         newSleepUs = 0;
    149.                                     Thread.sleep(newSleepUs / 1000);
    150.                                     codec.releaseOutputBuffer(outputBufferIndex, true); // 释放输入缓冲区，并渲染到Surface
    151.                                     break;
    152.                             }
    153.                         }
    154.                     }while (!this.isInterrupted());
    155.                     LogUtil.e("解码结束。。。");
    156.                     codec.stop();
    157.                     codec.release();
    158.                     codec = null;
    159.                     mediaExtractor.release();
    160.                     mediaExtractor = null;
    161.                 } catch (IOException e) {
    162.                     e.printStackTrace();
    163.                 } catch (InterruptedException e) {
    164.                     e.printStackTrace();
    165.                 }
    166.  
    167.             }
    168.         };
    169.         mVideoDecoderThread.start();
    170.     }
    171.  
    172.     private void startAudioDecoder(){
    173.         mAudioDecoderThread = new Thread("AudioDecoderThread"){
    174.             @Override
    175.             public void run() {
    176.                 super.run();
    177.                 try {
    178.  
    179.                     MediaFormat mMfVideo = null, mMfAudio = null;
    180.                     String value = null;
    181.                     String strVideoMime = null;
    182.                     String strAudioMime = null;
    183.  
    184.                     MediaExtractor mediaExtractor = new MediaExtractor();
    185.                     mediaExtractor.setDataSource(MEDIA_FILE_PATH);
    186.                     int numTracks = mediaExtractor.getTrackCount();
    187.                     LogUtil.e("获取track数"+numTracks);
    188.                     for (int i=0; i< numTracks; i++) {
    189.                         MediaFormat mediaFormat = mediaExtractor.getTrackFormat(i);
    190.                         LogUtil.e("单独显示track MF："+mediaFormat);
    191.                         value = mediaFormat.getString(MediaFormat.KEY_MIME);
    192.                         if (value.contains("audio")){
    193.                             mMfAudio = mediaFormat;
    194.                             strAudioMime = value;
    195.                             mediaExtractor.selectTrack(i);
    196.                         }else {
    197.                             mMfVideo = mediaFormat;
    198.                             strVideoMime = value;
    199.                         }
    200.                     }
    201. //                    mMfAudio.setInteger(MediaFormat.KEY_IS_ADTS, 1);
    202.                     mMfAudio.setInteger(MediaFormat.KEY_BIT_RATE, 16000);
    203.                     MediaCodec codec = MediaCodec.createDecoderByType(strAudioMime);
    204.                     codec.configure(mMfAudio, null, null, 0);
    205.                     codec.start();
    206.                     ByteBuffer outputByteBuffer = null;
    207.                     ByteBuffer[] outputByteBuffers = null;
    208.                     MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
    209.                     int size = -1, outputBufferIndex = -1;
    210.                     long previewStampUs = 01;
    211.                     LogUtil.e("开始解码。。。");
    212.                     if (mAudioTrack == null){
    213.                         int sample_rate = mMfAudio.getInteger(MediaFormat.KEY_SAMPLE_RATE);
    214.                         int channels = mMfAudio.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
    215.                         int sampleRateInHz = (int) (sample_rate * 1.004);
    216.                         int channelConfig = channels == 1 ? AudioFormat.CHANNEL_OUT_MONO : AudioFormat.CHANNEL_OUT_STEREO;
    217.                         int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
    218.                         int bfSize = AudioTrack.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat) * 4;
    219.                         mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRateInHz, channelConfig, audioFormat, bfSize, AudioTrack.MODE_STREAM);
    220.                     }
    221.                     mAudioTrack.play();
    222.  
    223. //                    outputByteBuffers = codec.getOutputBuffers();
    224.                     do {
    225.  
    226.                         int inputBufferId = codec.dequeueInputBuffer(10);
    227.                         if (inputBufferId >= 0) {
    228.                             ByteBuffer inputBuffer = codec.getInputBuffer(inputBufferId);
    229.                             // fill inputBuffer with valid data
    230.                             inputBuffer.clear();
    231.                             size = mediaExtractor.readSampleData(inputBuffer, 0);
    232.                             if (size<0)
    233.                                 break;
    234.                             long presentationTimeUs = mediaExtractor.getSampleTime();
    235. //                            LogUtil.e("queueInputBuffer: 把数据放入编码器。。。");
    236.                             codec.queueInputBuffer(inputBufferId, 0, size, presentationTimeUs, 0);
    237.                             mediaExtractor.advance();
    238. //                            LogUtil.e("advance: 获取下一帧。。。");
    239.                             outputBufferIndex = codec.dequeueOutputBuffer(bufferInfo, 50000);
    240.                             switch (outputBufferIndex) {
    241.                                 case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
    242. //                                    MediaFormat mf = codec.getOutputFormat(outputBufferIndex);
    243.                                     MediaFormat mf = codec.getOutputFormat();
    244.                                     LogUtil.e("INFO_OUTPUT_FORMAT_CHANGED："+mf);
    245.                                     break;
    246.                                 case MediaCodec.INFO_TRY_AGAIN_LATER:
    247.                                     LogUtil.e( "解码当前帧超时");
    248.                                     break;
    249.                                 case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
    250. //                                    outputByteBuffer = codec.getOutputBuffers();
    251.                                     LogUtil.e( "output buffers changed");
    252.                                     break;
    253.                                 default:
    254.                                     //直接渲染到Surface时使用不到outputBuffer
    255.                                     //ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
    256.                                     //延时操作
    257.                                     //如果缓冲区里的可展示时间>当前视频播放的进度，就休眠一下
    258.                                     LogUtil.e("outputBufferIndex = "+outputBufferIndex);
    259. //                                    outputByteBuffer = outputByteBuffers[outputBufferIndex];
    260.                                     outputByteBuffer = codec.getOutputBuffer(outputBufferIndex); // 获取解码后的数据
    261.                                     outputByteBuffer.clear();
    262.                                     byte[] outData = new byte[bufferInfo.size];
    263.                                     outputByteBuffer.get(outData);
    264.                                     boolean firstTime = previewStampUs == 0l;
    265.                                     long newSleepUs = -1;
    266.                                     long sleepUs = (bufferInfo.presentationTimeUs - previewStampUs);
    267.                                     if (!firstTime){
    268.                                         long cache = 0;
    269.                                         newSleepUs = CameraUtil.fixSleepTime(sleepUs, cache, -100000);
    270.                                     }
    271.                                     previewStampUs = bufferInfo.presentationTimeUs;
    272.                                     //渲染
    273.                                     if (newSleepUs < 0)
    274.                                         newSleepUs = 0;
    275.                                     Thread.sleep(newSleepUs/1000);
    276.                                     mAudioTrack.write(outData, 0, outData.length); // 输出音频
    277.                                     codec.releaseOutputBuffer(outputBufferIndex, false); // 释放输出缓冲区
    278.                                     break;
    279.                             }
    280.                         }
    281.                     }while (!this.isInterrupted());
    282.                     LogUtil.e("解码结束。。。");
    283.                     codec.stop();
    284.                     codec.release();
    285.                     codec = null;
    286.                     mAudioTrack.stop();
    287.                     mAudioTrack.release();
    288.                     mAudioTrack = null;
    289.                     mediaExtractor.release();
    290.                     mediaExtractor = null;
    291.                 } catch (IOException e) {
    292.                     e.printStackTrace();
    293.                 } catch (InterruptedException e) {
    294.                     e.printStackTrace();
    295.                 }
    296.             }
    297.         };
    298.         mAudioDecoderThread.start();
    299.     }
    300.  
    301.     @Override
    302.     public void onClick(View view){
    303.         switch (view.getId()){
    304.             case R.id.sv_render:
    305.                 mMediaStream.getCamera().autoFocus(null);
    306.                 break;
    307.             case R.id.sv_display:
    308.                 break;
    309.  
    310.             case R.id.btn_camera_preview:
    311.                 break;
    312.  
    313.             case R.id.btn_play_media_file:
    314.                 break;
    315.  
    316.             default:break;
    317.         }
    318.     }
    319.  
    320.     private int getDgree() {
    321.         int rotation = getWindowManager().getDefaultDisplay().getRotation();
    322.         int degrees = 0;
    323.         switch (rotation) {
    324.             case Surface.ROTATION_0:
    325.                 degrees = 0;
    326.                 break; // Natural orientation
    327.             case Surface.ROTATION_90:
    328.                 degrees = 90;
    329.                 break; // Landscape left
    330.             case Surface.ROTATION_180:
    331.                 degrees = 180;
    332.                 break;// Upside down
    333.             case Surface.ROTATION_270:
    334.                 degrees = 270;
    335.                 break;// Landscape right
    336.         }
    337.         return degrees;
    338.     }
    339.  
    340.     private void onMediaStreamCreate(){
    341.         if (mMediaStream==null)
    342.             mMediaStream = new MediaStream(this, mSvRenderFromCamera.getHolder());
    343.         mMediaStream.setDgree(getDgree());
    344.         mMediaStream.createCamera();
    345.         mMediaStream.startPreview();
    346.     }
    347.  
    348.     private void onMediaStreamDestroy(){
    349.         mMediaStream.release();
    350.         mMediaStream = null;
    351.     }
    352.  
    353.     @Override
    354.     protected void onPause() {
    355.         super.onPause();
    356.         onMediaStreamDestroy();
    357.         if (mVideoDecoderThread!=null)
    358.             mVideoDecoderThread.interrupt();
    359.         if (mAudioDecoderThread!=null)
    360.             mAudioDecoderThread.interrupt();
    361.     }
    362.  
    363.     @Override
    364.     protected void onResume() {
    365.         super.onResume();
    366.         if (isSurfaceCreated && mMediaStream == null){
    367.             onMediaStreamCreate();
    368.         }
    369.     }
    370.  
    371.     private boolean isSurfaceCreated = false;
    372.     @Override
    373.     public void surfaceCreated(SurfaceHolder holder) {
    374.         LogUtil.e("surfaceCreated: "+holder);
    375.  
    376.         if (holder.getSurface() == mSvRenderFromCamera.getHolder().getSurface()){
    377.             isSurfaceCreated = true;
    378.             onMediaStreamCreate();
    379.         }else if (holder.getSurface() == mSvRenderFromFile.getHolder().getSurface()){
    380.             if (new File(MEDIA_FILE_PATH).exists()) {
    381.                 startVideoDecoder();
    382.                 startAudioDecoder();
    383.             }
    384.         }
    385.     }
    386.  
    387.     @Override
    388.     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    389.         LogUtil.e("surfaceChanged: "
    390.                 +"\nholder = "+holder
    391.                 +"\nformat = "+format
    392.                 +"\nwidth = "+width
    393.                 +"\nheight = "+height);
    394.     }
    395.  
    396.     @Override
    397.     public void surfaceDestroyed(SurfaceHolder holder) {
    398.         LogUtil.e("surfaceDestroyed: ");
    399.         if (holder.getSurface() == mSvRenderFromCamera.getHolder().getSurface()) {
    400.             isSurfaceCreated = false;
    401.         }
    402.     }
    403. }
    1. //摄像头数据编码h264
    2.  
    3. final int millisPerframe = 1000 / 20;
    4.     long lastPush = 0;
    5.     @Override
    6.     public void run() {
    7.         MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
    8.         int outputBufferIndex = 0;
    9.         byte[] mPpsSps = new byte[0];
    10.         byte[] h264 = new byte[mWidth * mHeight];
    11.         do {
    12.             outputBufferIndex = mMediaCodec.dequeueOutputBuffer(bufferInfo, 10000); // 从codec中获取编码完的数据
    13.             if (outputBufferIndex == MediaCodec.INFO_TRY_AGAIN_LATER) {
    14.                 // no output available yet
    15.             } else if (outputBufferIndex == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
    16.                 // not expected for an encoder
    17.                 outputBuffers = mMediaCodec.getOutputBuffers();
    18.             } else if (outputBufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
    19.                 synchronized (HWConsumer.this) {
    20.                     newFormat = mMediaCodec.getOutputFormat();
    21.                     EasyMuxer muxer = mMuxer;
    22.                     if (muxer != null) {
    23.                         // should happen before receiving buffers, and should only happen once
    24.  
    25.                         muxer.addTrack(newFormat, true);
    26.                     }
    27.                 }
    28.             } else if (outputBufferIndex < 0) {
    29.                 // let's ignore it
    30.             } else {
    31.                 ByteBuffer outputBuffer;
    32.                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    33.                     outputBuffer = mMediaCodec.getOutputBuffer(outputBufferIndex);
    34.                 } else {
    35.                     outputBuffer = outputBuffers[outputBufferIndex];
    36.                 }
    37.                 outputBuffer.position(bufferInfo.offset);
    38.                 outputBuffer.limit(bufferInfo.offset + bufferInfo.size);
    39.                 EasyMuxer muxer = mMuxer;
    40.                 if (muxer != null) {
    41.                     muxer.pumpStream(outputBuffer, bufferInfo, true);
    42.                 }
    43.  
    44.                 boolean sync = false;
    45.                 if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {// codec会产生sps和pps
    46.                     sync = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_SYNC_FRAME) != 0; // 标记是I帧还是同步帧
    47.                     if (!sync) { // 如果是同步帧，也就是填充着pps和sps参数
    48.                         byte[] temp = new byte[bufferInfo.size];
    49.                         outputBuffer.get(temp);
    50.                         mPpsSps = temp;
    51.                         mMediaCodec.releaseOutputBuffer(outputBufferIndex, false);
    52.                         continue; // 等待下一帧
    53.                     } else {
    54.                         mPpsSps = new byte[0];
    55.                     }
    56.                 }
    57.                 sync |= (bufferInfo.flags & MediaCodec.BUFFER_FLAG_SYNC_FRAME) != 0; // 标记是否是关键帧
    58.                 int len = mPpsSps.length + bufferInfo.size;
    59.                 if (len > h264.length) {
    60.                     h264 = new byte[len];
    61.                 }
    62.                 if (sync) {
    63.                     // 如果是关键帧
    64.                    if (BuildConfig.DEBUG)
    65.                         Log.i(TAG, String.format("push i video stamp:%d", bufferInfo.presentationTimeUs / 1000));
    66.                 } else { // 非I帧直接读取出来
    67.                     outputBuffer.get(h264, 0, bufferInfo.size);
    68.                     
    69.                     if (BuildConfig.DEBUG)
    70.                         Log.i(TAG, String.format("push video stamp:%d", bufferInfo.presentationTimeUs / 1000));
    71.                 }
    72.                 mMediaCodec.releaseOutputBuffer(outputBufferIndex, false);
    73.             }
    74.         }
    75.         while (mVideoStarted);
    76.     }
    77.     @Override
    78.     public int onVideo(byte[] data, int format) {
    79.         if (!mVideoStarted) return 0;
    80.         try {
    81.             if (lastPush == 0) {
    82.                 lastPush = System.currentTimeMillis();
    83.             }
    84.             long time = System.currentTimeMillis() - lastPush;
    85.             if (time >= 0) {
    86.                 time = millisPerframe - time;
    87.                 if (time > 0) Thread.sleep(time / 2);
    88.             }
    89.             if (format == ImageFormat.YV12) {
    90.                 JNIUtil.yV12ToYUV420P(data, mWidth, mHeight);
    91.             } else {
    92.                 JNIUtil.nV21To420SP(data, mWidth, mHeight);
    93.             }
    94.             int bufferIndex = mMediaCodec.dequeueInputBuffer(0);
    95.             if (bufferIndex >= 0) {
    96.                 ByteBuffer buffer = null;
    97.                 if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
    98.                     buffer = mMediaCodec.getInputBuffer(bufferIndex);
    99.                 } else {
    100.                     buffer = inputBuffers[bufferIndex];
    101.                 }
    102.                 buffer.clear();
    103.                 buffer.put(data);
    104.                 buffer.clear();
    105.                 mMediaCodec.queueInputBuffer(bufferIndex, 0, data.length, System.nanoTime() / 1000, MediaCodec.BUFFER_FLAG_KEY_FRAME); // 标记含有关键帧
    106.             }
    107.             if (time > 0) Thread.sleep(time / 2); // 添加延时，确保帧率
    108.             lastPush = System.currentTimeMillis();
    109.         } catch (InterruptedException ex) {
    110.             ex.printStackTrace();
    111.         }
    112.         return 0;
    113.     }
    114.  
    115.     /**
    116.     * 初始化编码器
    117.     */
    118.     private void startMediaCodec() throws IOException {
    119.             /*
    120.         SD (Low quality) SD (High quality) HD 720p
    121. 1 HD 1080p
    122. 1
    123. Video resolution 320 x 240 px 720 x 480 px 1280 x 720 px 1920 x 1080 px
    124. Video frame rate 20 fps 30 fps 30 fps 30 fps
    125. Video bitrate 384 Kbps 2 Mbps 4 Mbps 10 Mbps
    126.         */
    127.         int framerate = 20;
    128. //        if (width == 640 || height == 640) {
    129. //            bitrate = 2000000;
    130. //        } else if (width == 1280 || height == 1280) {
    131. //            bitrate = 4000000;
    132. //        } else {
    133. //            bitrate = 2 * width * height;
    134. //        }
    135.  
    136.         int bitrate = (int) (mWidth * mHeight * 20 * 2 * 0.05f);
    137.         if (mWidth >= 1920 || mHeight >= 1920) bitrate *= 0.3;
    138.         else if (mWidth >= 1280 || mHeight >= 1280) bitrate *= 0.4;
    139.         else if (mWidth >= 720 || mHeight >= 720) bitrate *= 0.6;
    140.         EncoderDebugger debugger = EncoderDebugger.debug(mContext, mWidth, mHeight);
    141.         mVideoConverter = debugger.getNV21Convertor();
    142.         mMediaCodec = MediaCodec.createByCodecName(debugger.getEncoderName());
    143.         MediaFormat mediaFormat = MediaFormat.createVideoFormat("video/avc", mWidth, mHeight);
    144.         mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitrate);
    145.         mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, framerate);
    146.         mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, debugger.getEncoderColorFormat());
    147.         mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
    148.         mMediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
    149.         mMediaCodec.start();
    150.  
    151.         Bundle params = new Bundle();
    152.         params.putInt(MediaCodec.PARAMETER_KEY_REQUEST_SYNC_FRAME, 0);
    153.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    154.             mMediaCodec.setParameters(params);
    155.         }
    156.     }
    1. //h264编码生成pps，sps
    2. inputBuffers = mMediaCodec.getInputBuffers();
    3. outputBuffers = mMediaCodec.getOutputBuffers();
    4. int bufferIndex = mMediaCodec.dequeueInputBuffer(0);
    5. if (bufferIndex >= 0) {
    6.     inputBuffers[bufferIndex].clear();
    7.     mConvertor.convert(data, inputBuffers[bufferIndex]);
    8.     mMediaCodec.queueInputBuffer(bufferIndex, 0, inputBuffers[bufferIndex].position(), System.nanoTime() / 1000, 0);
    9.  
    10.     MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
    11.     int outputBufferIndex = mMediaCodec.dequeueOutputBuffer(bufferInfo, 0);
    12.  
    13.     while (outputBufferIndex >= 0) {
    14.         ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
    15.  
    16. //                        String data0 = String.format("%x %x %x %x %x %x %x %x %x %x ", outData[0], outData[1], outData[2], outData[3], outData[4], outData[5], outData[6], outData[7], outData[8], outData[9]);
    17. //                        Log.e("out_data", data0);
    18.  
    19.         //记录pps和sps
    20.         int type = outputBuffer.get(4) & 0x07; // 判断是什么帧
    21.  
    22. //                                LogUtil.e(TAG, String.format("type is %d", type));
    23.         if (type == 7 || type == 8) {
    24.             byte[] outData = new byte[bufferInfo.size];
    25.             outputBuffer.get(outData);
    26.             mPpsSps = outData;
    27.  
    28.             ArrayList<Integer> posLists = new ArrayList<>(2);
    29.             for (int i=0; i<bufferInfo.size-3; i++){    // 找寻 pps sps
    30.                 if (outData[i]==0 && outData[i+1]==0&& outData[i+2]==0 && outData[i+3]==1){
    31.                     posLists.add(i);
    32.                 }
    33.             }
    34.             int sps_pos = posLists.get(0);
    35.             int pps_pos = posLists.get(1);
    36.             posLists.clear();
    37.             posLists = null;
    38.             ByteBuffer csd0 = ByteBuffer.allocate(pps_pos);
    39.             csd0.put(outData, sps_pos, pps_pos);
    40.             csd0.clear();
    41.             mCSD0 = csd0;
    42.             LogUtil.e(TAG, String.format("CSD-0 searched!!!"));
    43.  
    44.             ByteBuffer csd1 = ByteBuffer.allocate(outData.length-pps_pos);
    45.             csd1.put(outData, pps_pos, outData.length-pps_pos);
    46.             csd1.clear();
    47.             mCSD1 = csd1;
    48.             LogUtil.e(TAG, String.format("CSD-1 searched!!!"));
    49.  
    50.             LocalBroadcastManager.getInstance(mApplicationContext).sendBroadcast(new Intent(ACTION_H264_SPS_PPS_GOT));
    51.         } else if (type == 5) {
    52.         		// 这是一个关键帧
    53.             if (mEasyMuxer !=null && !isRecordPause) {
    54.                 bufferInfo.presentationTimeUs = TimeStamp.getInstance().getCurrentTimeUS();
    55.                 mEasyMuxer.pumpStream(outputBuffer, bufferInfo, true);// 用于保存本地视频到本地
    56.                 isWaitKeyFrame = false; // 拿到关键帧，则清除等待关键帧的条件
    57. //              LocalBroadcastManager.getInstance(mApplicationContext).sendBroadcast(new Intent(ACTION_I_KEY_FRAME_GOT));
    58.             }
    59.         } else {
    60.             outputBuffer.get(h264, 0, bufferInfo.size);
    61.             if (System.currentTimeMillis() - timeStamp >= 3000) {
    62.                 timeStamp = System.currentTimeMillis();
    63.                 if (Build.VERSION.SDK_INT >= 23) {
    64.                     Bundle params = new Bundle();
    65.                     params.putInt(MediaCodec.PARAMETER_KEY_REQUEST_SYNC_FRAME, 0);
    66.                     mMediaCodec.setParameters(params);
    67.                 }
    68.             }
    69.             
    70.             if (mEasyMuxer !=null && !isRecordPause && !isWaitKeyFrame) {
    71.                 bufferInfo.presentationTimeUs = TimeStamp.getInstance().getCurrentTimeUS();
    72.                 mEasyMuxer.pumpStream(outputBuffer, bufferInfo, true);// 用于保存本地视频到本地
    73.             }
    74.         }
    75.  
    76.         mMediaCodec.releaseOutputBuffer(outputBufferIndex, false);
    77.         outputBufferIndex = mMediaCodec.dequeueOutputBuffer(bufferInfo, 0);
    78.     }
    79.  
    80. } else {
    81.     Log.e(TAG, "No buffer available !");
    82. }

    如果你对音视频开发感兴趣，觉得文章对您有帮助，别忘了点赞、收藏哦！或者对本文的一些阐述有自己的看法，有任何问题，欢迎在下方评论区讨论！

     本文福利， 免费领取C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部点击免费领取↓↓

  • 相关阅读:
    外卖项目（SpringBoot）--- 前后端分离开发部署
    无线传感器网络：数据链路层，MAC
    php mysql摄影网_图片分享网站
    Vue3实现刷新页面局部内容
    Python简介-Python3及环境配置
    go语言的一些常见踩坑问题
    CROS错误 403 preflight 预检
    【20221201】【每日一题】划分字母区间
    要求用一句sql语句打印出A,B各剩了多少
    Seata 源码篇之AT模式启动流程 - 中 - 03
  • 原文地址：https://blog.csdn.net/m0_60259116/article/details/127109840