• Android MediaCodec将h264实时视频流数据解码为yuv，并转换yuv的颜色格式为nv21

    初始化mediacodec

    1.     //宽高根据摄像头分辨率设置
    2.     private int Width = 1280;
    3.     private int Height = 720;
    4.     private MediaCodec mediaCodec;
    5.     private ByteBuffer[] inputBuffers;
    6.  
    7.     private void initMediaCodec(Surface surface) {
    8.  
    9.         try {
    10.             Log.d(TAG, "onGetNetVideoData: ");
    11.             //创建解码器 H264的Type为  AAC
    12.             mediaCodec = MediaCodec.createDecoderByType("video/avc");
    13.             //创建配置
    14.             MediaFormat mediaFormat = MediaFormat.createVideoFormat("video/avc", Width, Height);
    15.             //设置解码预期的帧速率【以帧/秒为单位的视频格式的帧速率的键】
    16.             mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 20);
    17.  
    18.             mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, COLOR_FormatYUV420SemiPlanar);//
    19. //            byte[] headerSps = {0, 0, 0, 1, 103, 66, 0, 41, -115, -115, 64, 80, 30, -48, 15, 8, -124, 83, -128};
    20. //            byte[] headerPps = {0, 0, 0, 1, 104, -54, 67, -56};
    21. //
    22. //            mediaFormat.setByteBuffer("csd-0", ByteBuffer.wrap(headerSps));
    23. //            mediaFormat.setByteBuffer("csd-1", ByteBuffer.wrap(headerPps));
    24.             //配置绑定mediaFormat和surface
    25.             mediaCodec.configure(mediaFormat, null, null, 0);
    26.             mediaCodec.start();
    27.         } catch (IOException e) {
    28.             e.printStackTrace();
    29.             //创建解码失败
    30.             Log.e(TAG, "创建解码失败");
    31.         }
    32.  
    33.         inputBuffers = mediaCodec.getInputBuffers();
    34.  
    35.     }

    处理数据，解码h264数据为yuv格式

    这里传入的是h264格式的实时视频流数据。

    1.     private void onFrame(byte[] buf, int offset, int length) {
    2.  
    3.         MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
    4.         //查询10000毫秒后，如果dSP芯片的buffer全部被占用，返回-1；存在则大于0
    5.         int inIndex = mediaCodec.dequeueInputBuffer(10000);
    6.         if (inIndex >= 0) {
    7.             //根据返回的index拿到可以用的buffer
    8.             ByteBuffer byteBuffer = inputBuffers[inIndex];
    9.             //清空缓存
    10.             byteBuffer.clear();
    11.             //开始为buffer填充数据
    12.             byteBuffer.put(buf);
    13.             //填充数据后通知mediacodec查询inIndex索引的这个buffer,
    14.             mediaCodec.queueInputBuffer(inIndex, 0, length, mCount * 20, 0);
    15.             mCount++;
    16.         } else {
    17.             Log.i(TAG, "inIndex < 0");
    18.             //等待查询空的buffer
    19.             return;
    20.         }
    21.         //mediaCodec 查询 "mediaCodec的输出方队列"得到索引
    22.         int outIndex = mediaCodec.dequeueOutputBuffer(info, 10000);
    23.         Log.e(TAG, "解码输出outIndex " + outIndex);
    24.         if (outIndex >= 0) {
    25.  
    26.             //dsp的byteBuffer无法直接使用
    27.             ByteBuffer byteBuffer = mediaCodec.getOutputBuffer(outIndex);
    28.             //设置偏移量
    29.             byteBuffer.position(info.offset);
    30.             byteBuffer.limit(info.size + info.offset);
    31.  
    32.             byte[] ba = new byte[byteBuffer.remaining()];
    33.             byteBuffer.get(ba);
    34.             //需要预先分配与NV12相同大小的字节数组
    35.             byte[] yuv = new byte[ba.length];
    36.             //不确定是什么颜色格式，挨个试的
    37.             //convertI420ToNV21(ba, yuv, Width, Height);
    38.             //convertYV12toNV21(ba, yuv, Width, Height);
    39.             convertNV12toNV21(ba, yuv, Width, Height);
    40.             NV21Data(yuv);
    41.             //检查所支持的颜色格式
    42. //            MediaCodecInfo.CodecCapabilities capabilities = codecInfo.getCapabilitiesForType("video/avc");
    43. //             for (int i = 0; i < capabilities.colorFormats.length; i++) {
    44. //                int format = capabilities.colorFormats[i];
    45. //
    46. //                //华为平板：COLOR_FormatYUV420SemiPlanar、COLOR_FormatYUV420Planar
    47. //                //魅族手机：COLOR_FormatYUV420SemiPlanar
    48. //                //rk3588s: COLOR_FormatYUV420Planar、COLOR_FormatYUV420Flexible、COLOR_FormatYUV420PackedSemiPlanar、COLOR_FormatYUV420SemiPlanar
    49. //                switch (format) {
    50. //                    case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar://(对应 I420 or YV12)
    51. //                        Log.i("COLOR_Format_TAG", "=========COLOR_FormatYUV420Planar");
    52. //                        byte[] convertNv21YUV420Planar = new byte[ba.length];
    53. //                        //不确定是什么颜色格式，挨个试的
    54.                             convertI420ToNV21(ba, convertNv21YUV420Planar, Width, Height);
    55.                             convertYV12toNV21(ba, convertNv21YUV420Planar, Width, Height);
    56. //                        long l1 = System.currentTimeMillis();
    57. //                        convertNV12toNV21(ba, convertNv21YUV420Planar, Width, Height);
    58. //                        Log.i("耗时测试", "转为nv21的耗时: " + (System.currentTimeMillis() - l1));
    59. //                        long l2 = System.currentTimeMillis();
    60. //                        NV21Data(convertNv21YUV420Planar);
    61. //                        Log.i("耗时测试", "识别耗时: " + (System.currentTimeMillis() - l2));
    62. //                        continue;
    63. //
    64. //                    case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar://NV12
    65. //                        Log.i("COLOR_Format_TAG", "=======COLOR_FormatYUV420SemiPlanar");
    66. //                        byte[] nv21YUV420SemiPlanar = new byte[ba.length];
    67. //                        convertNV12toNV21(ba, nv21YUV420SemiPlanar, Width, Height);
    68. //                        NV21Data(nv21YUV420SemiPlanar);
    69. //
    70. //                        continue;
    71. //                    case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
    72. //                        Log.i("COLOR_Format_TAG", "=======COLOR_FormatYUV420PackedSemiPlanar");
    73. //                        byte[] nv21YUV420PackedSemiPlanar = new byte[ba.length];
    74. //                        convertNV12toNV21(ba, nv21YUV420PackedSemiPlanar, Width, Height);
    75. //                        NV21Data(nv21YUV420PackedSemiPlanar);
    76. //                        continue;
    77. //                    case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible:
    78. //                        byte[] nv21YUV420YUV420Flexible = new byte[ba.length];
    79. //                        convertNV12toNV21(ba, nv21YUV420YUV420Flexible, Width, Height);
    80. //                        NV21Data(nv21YUV420YUV420Flexible);
    81. //                        Log.i("COLOR_Format_TAG", "=======COLOR_FormatYUV420Flexible");
    82. //                        continue;
    83. //                    default:
    84. //                        continue;
    85. //
    86. //                }
    87. //
    88. //            }
    89.  
    90.             //如果surface绑定了，则直接输入到surface渲染并释放
    91.             mediaCodec.releaseOutputBuffer(outIndex, false);
    92.         } else {
    93.             Log.e(TAG, "没有解码成功");
    94.         }
    95.     }

    处理获取到的nv21颜色格式的yuv数据

    1.     private int printImageStatus = 0;
    2.     private void NV21Data(byte[] nv21) {
    3.           //将nv21视频流数据传入YuvImage中，转换成bitmap之后，显示在imageview上、
    4.           //或者保存为png图片到本地，如果不出现灰色、不出现蓝色图像和红色图像颜色颠倒，
    5.           //图像显示正常，则说明是标准的nv21格式视频流数据
    6.           YuvImage yuvImage = new YuvImage(nv21, ImageFormat.NV21, Width, Height, null);
    7.           ByteArrayOutputStream baos = new ByteArrayOutputStream();
    8.           yuvImage.compressToJpeg(new Rect(0, 0, Width, Height), 100, baos);
    9.           byte[] data = baos.toByteArray();
    10.           Log.i(TAG, "NV21Data-data: " + data.length);
    11.       
    12.           Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
    13.   
    14.          if (bitmap != null) {
    15.               runOnUiThread(new Runnable() {
    16.                   @Override
    17.                   public void run() {
    18.                       mIvShowImage.setImageBitmap(bitmap);
    19.                   }
    20.               });
    21.               //保存bitmap为png图片
    22.               if (printImageStatus == 0) {
    23.                   printImageStatus = 1;
    24.                   try {
    25.                       File myCaptureFile = new File(Environment.getExternalStorageDirectory(), "img.png");
    26.                       BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(myCaptureFile));
    27.                       bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos);
    28.                       bos.flush();
    29.                       bos.close();
    30.                   } catch (Exception e) {
    31.                       e.printStackTrace();
    32.                   }
    33.               }
    34.           }
    35.     }

     yuv视频数据颜色格式转换

    1.     public static void convertI420ToNV21(byte[] i420, byte[] nv21, int width, int height) {
    2.         System.arraycopy(i420, 0, nv21, 0, width * height);
    3.         int offset = width * height;
    4.         for (int i = 0; i < width * height / 4; i++) {
    5.             nv21[offset + 2 * i] = i420[offset + i + width * height / 4];
    6.             nv21[offset + 2 * i + 1] = i420[offset + i];
    7.         }
    8.     }
    9.  
    10.     public static void convertYV12toNV21(byte[] yv12, byte[] nv21, int width, int height) {
    11.         int size = width * height;
    12.         int vOffset = size;
    13.         int uOffset = size + (size / 4);
    14.  
    15.         // Copy Y channel as it is
    16.         System.arraycopy(yv12, 0, nv21, 0, size);
    17.  
    18.         for (int i = 0; i < size / 4; i++) {
    19.             nv21[vOffset + (i * 2)] = yv12[vOffset + i];      // V
    20.             nv21[vOffset + (i * 2) + 1] = yv12[uOffset + i];  // U
    21.         }
    22.     }
    23.  
    24.  
    25.     public static void convertNV12toNV21(byte[] nv12, byte[] nv21, int width, int height) {
    26.         int size = width * height;
    27.         int offset = size;
    28.  
    29.         // copy Y channel as it is
    30.         System.arraycopy(nv12, 0, nv21, 0, offset);
    31.  
    32.         for (int i = 0; i < size / 4; i++) {
    33.             nv21[offset + (i * 2) + 1] = nv12[offset + (i * 2)];       // U
    34.             nv21[offset + (i * 2)] = nv12[offset + (i * 2) + 1];       // V
    35.         }
    36.     }

    h264实时视频流的数据来源

    1.     @Override
    2.     public void onPacketEvent(byte[] data) {
    3.  
    4.  
    5.         onFrame(data, 0, data.length);
    6.         //写入h264视频流到sdcard中
    7.         //wirte2file(data, data.length);
    8.  
    9.     }

    写入h264视频流到sdcard中

    1.     private BufferedOutputStream BufOs = null;
    2.     private File destfile = null;
    3.     private FileOutputStream destfs = null;
    4.     private String dsetfilePath = Environment.getExternalStorageDirectory() + "/" + "test.h264";
    5.  
    6.     private void wirte2file(byte[] buf, int length) {
    7.         if (isStart) {
    8.             if (BufOs == null) {
    9.                 destfile = new File(dsetfilePath);
    10.                 try {
    11.                     destfs = new FileOutputStream(destfile);
    12.                     BufOs = new BufferedOutputStream(destfs);
    13.                     Log.d(TAG, "wirte2file-new ");
    14.                 } catch (FileNotFoundException e) {
    15.                     // TODO: handle exception
    16.                     Log.i("TRACK", "initerro" + e.getMessage());
    17.                     Log.d(TAG, "wirte2file-FileNotFoundException:" + e.getMessage());
    18.                     e.printStackTrace();
    19.                 }
    20.             }
    21.  
    22.             try {
    23.                 BufOs.write(buf, 0, length);
    24.                 BufOs.flush();
    25.                 Log.d(TAG, "wirte2file-write");
    26.             } catch (Exception e) {
    27.                 Log.d(TAG, "wirte2file-e: " + e.getMessage());
    28.                 // TODO: handle exception
    29.             }
    30.  
    31.         }
    32.     }
    33.  
    34.     private boolean isStart;
    35.  
    36.     public void onStop(View view) {
    37.         isStart = false;
    38.         Toast.makeText(this, "停止保存", Toast.LENGTH_SHORT).show();
    39.     }
    40.  
    41.     public void onStart(View view) {
    42.         isStart = true;
    43.         Toast.makeText(this, "开始保存", Toast.LENGTH_SHORT).show();
    44.     }

    rtsp获取h264实时视频流数据

    1. public class FFDemuxJava {
    2.  
    3.     static {
    4.         System.loadLibrary("demux");
    5.     }
    6.  
    7.     private long m_handle = 0;
    8.     private EventCallback mEventCallback = null;
    9.  
    10.     public void init(String url) {
    11.         m_handle = native_Init(url);
    12.     }
    13.  
    14.     public void Start() {
    15.         native_Start(m_handle);
    16.     }
    17.  
    18.     public void stop() {
    19.         native_Stop(m_handle);
    20.     }
    21.  
    22.     public void unInit() {
    23.         native_UnInit(m_handle);
    24.     }
    25.  
    26.     public void addEventCallback(EventCallback callback) {
    27.         mEventCallback = callback;
    28.     }
    29.  
    30.  
    31.     private void playerEventCallback(int msgType, float msgValue) {
    32.         if(mEventCallback != null)
    33.             mEventCallback.onMessageEvent(msgType, msgValue);
    34.  
    35.     }
    36.  
    37.  
    38.     private void packetEventCallback(byte[]data) {
    39.         if(mEventCallback != null)
    40.             mEventCallback.onPacketEvent(data);
    41.  
    42.     }
    43.  
    44.  
    45.  
    46.     private native long native_Init(String url);
    47.  
    48.     private native void native_Start(long playerHandle);
    49.  
    50.     private native void native_Stop(long playerHandle);
    51.  
    52.     private native void native_UnInit(long playerHandle);
    53.  
    54.  
    55.     public interface EventCallback {
    56.         void onMessageEvent(int msgType, float msgValue);
    57.         void onPacketEvent(byte []data);
    58.     }
    59.  
    60. }
     编写C代码加载ffmpeg库
    1. #include 
    2. #include 
    3.  
    4. #include "FFBridge.h"
    5.  
    6. extern "C"
    7. {
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. };
    17.  
    18. extern "C" JNIEXPORT jstring JNICALL
    19. Java_com_qmcy_demux_MainActivity_stringFromJNI(
    20.         JNIEnv* env,
    21.         jobject /* this */) {
    22.     std::string hello = "Hello from C++";
    23.     return env->NewStringUTF(hello.c_str());
    24. }
    25.  
    26.  
    27. extern "C" JNIEXPORT jstring JNICALL
    28. Java_com_qmcy_demux_MainActivity_GetVersion(
    29.         JNIEnv* env,
    30.         jobject /* this */) {
    31.     char strBuffer[1024 * 4] = {0};
    32.     strcat(strBuffer, "libavcodec : ");
    33.     strcat(strBuffer, AV_STRINGIFY(LIBAVCODEC_VERSION));
    34.     strcat(strBuffer, "\nlibavformat : ");
    35.     strcat(strBuffer, AV_STRINGIFY(LIBAVFORMAT_VERSION));
    36.     strcat(strBuffer, "\nlibavutil : ");
    37.     strcat(strBuffer, AV_STRINGIFY(LIBAVUTIL_VERSION));
    38.     strcat(strBuffer, "\nlibavfilter : ");
    39.     strcat(strBuffer, AV_STRINGIFY(LIBAVFILTER_VERSION));
    40.     strcat(strBuffer, "\nlibswresample : ");
    41.     strcat(strBuffer, AV_STRINGIFY(LIBSWRESAMPLE_VERSION));
    42.     strcat(strBuffer, "\nlibswscale : ");
    43.     strcat(strBuffer, AV_STRINGIFY(LIBSWSCALE_VERSION));
    44.     strcat(strBuffer, "\navcodec_configure : \n");
    45.     strcat(strBuffer, avcodec_configuration());
    46.     strcat(strBuffer, "\navcodec_license : ");
    47.     strcat(strBuffer, avcodec_license());
    48.     //LOGCATE("GetFFmpegVersion\n%s", strBuffer);
    49.     return env->NewStringUTF(strBuffer);
    50. }
    51.  
    52.  
    53. extern "C" JNIEXPORT jlong JNICALL Java_com_qmcy_demux_FFDemuxJava_native_1Init
    54.         (JNIEnv *env, jobject obj, jstring jurl)
    55. {
    56.     const char* url = env->GetStringUTFChars(jurl, nullptr);
    57.     FFBridge *bridge = new FFBridge();
    58.     bridge->Init(env, obj, const_cast<char *>(url));
    59.     env->ReleaseStringUTFChars(jurl, url);
    60.     return reinterpret_cast(bridge);
    61. }
    62.  
    63. extern "C"
    64. JNIEXPORT void JNICALL Java_com_qmcy_demux_FFDemuxJava_native_1Start
    65.         (JNIEnv *env, jobject obj, jlong handle)
    66. {
    67.     if(handle != 0)
    68.     {
    69.         FFBridge *bridge = reinterpret_cast(handle);
    70.         bridge->Start();
    71.     }
    72.  
    73. }
    74.  
    75. extern "C"
    76. JNIEXPORT void JNICALL Java_com_qmcy_demux_FFDemuxJava_native_1Stop
    77.         (JNIEnv *env, jobject obj, jlong handle)
    78. {
    79.     if(handle != 0)
    80.     {
    81.         FFBridge *bridge = reinterpret_cast(handle);
    82.         bridge->Stop();
    83.     }
    84. }
    85.  
    86.  
    87. extern "C"
    88. JNIEXPORT void JNICALL Java_com_qmcy_demux_FFDemuxJava_native_1UnInit
    89.         (JNIEnv *env, jobject obj, jlong handle)
    90. {
    91.     if(handle != 0)
    92.     {
    93.         FFBridge *bridge = reinterpret_cast(handle);
    94.         bridge->UnInit();
    95.         delete bridge;
    96.     }
    97. }

    源码地址icon-default.png?t=N7T8https://gitee.com/baipenggui/demux_demo.git

  • 相关阅读:
    PHP留言反馈管理系统源码
    【微服务】Nacos2.x服务发现？RPC调用？重试机制？
    力扣：17-电话号码的字母组合
    JS逆向实战9——cookies DES加密混淆
    三面拼多多都没过，惨败在（java中间件、数据库与spring框架）后悔没有早点知道这些
    Go方法特性详解：简单性和高效性的充分体现
    学习java第一百零七天
    2023中国传媒产业发展报告
    SSM - Springboot - MyBatis-Plus 全栈体系（十四）
    轻量级接口自动化测试框架
  • 原文地址：https://blog.csdn.net/qq_40116418/article/details/133351850