Android MediaCodec编码后解析出H264/H265中vps sps pps帧

最新推荐文章于 2024-07-23 00:12:22 发布
最新推荐文章于 2024-07-23 00:12:22 发布
阅读量6.6k 收藏 20
点赞数 9
分类专栏： 多媒体Multimedia Android 文章标签： sps pps android h.264 vps
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhichi202/article/details/105920432
版权

文章目录


H264格式编码是没有vps帧，是从sps帧开始，这里从H264和H265两种编码器中分别解析各自编码出的配置。

解析的两种方式

  1. 直接解析编码器编码的原始码的第一帧数据，第一帧一般为配置帧。H264编码中是按照sps，pps顺序拼接而成一帧；H265是按照vps，sps，pps顺序拼接成一帧。
  2. 回调函数onOutputFormatChanged中，根据MediaFormat的csd-0，csd-1中分析出配置帧的数据。H264中sps为csd-0，pps为csd-1；H265中vps、sps、pps都在csd-0中按顺序拼接。

MediaCodec异步编码具体过程如下：

1.配置Camera回调，获取preview的原始数据

//打开camera
mCamera = Camera.open(Camera.CameraInfo.CAMERA_FACING_BACK);
//设置preview回调
mCamera.setPreviewCallback(new CameraPreviewCallback());

class CameraPreviewCallback implements Camera.PreviewCallback {
        @Override
        public void onPreviewFrame(byte[] data, Camera camera) {
//            Log.d(TAG, "onPreviewFrame: ");
            if (frameRawDataListener != null)
                frameRawDataListener.previewDataCallBack(data);
        }
    }

//定义回调
public interface FrameRawDataListener{
        public void previewDataCallBack(byte[] frameData);
    }

2.配置encoder和MediaFormat

public void prepareEncoder(){
        Log.d(TAG, "prepareEncoder: ");
        MediaFormat videoFormat = MediaFormat.createVideoFormat(VIDEO_MIME_TYPE, mWidth, mHeight);
        videoFormat.setInteger(MediaFormat.KEY_FRAME_RATE, mFps);
        videoFormat.setInteger(MediaFormat.KEY_BIT_RATE, (int)(mWidth * mHeight));
        videoFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, selectColorFormat(VIDEO_MIME_TYPE));
        videoFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, I_FRAME_INTERVAL);
        if(VIDEO_MIME_TYPE.equals(MediaFormat.MIMETYPE_VIDEO_AVC)){
            videoFormat.setInteger(MediaFormat.KEY_BITRATE_MODE, MediaCodecInfo.EncoderCapabilities.BITRATE_MODE_VBR);
            videoFormat.setInteger(MediaFormat.KEY_PROFILE,MediaCodecInfo.CodecProfileLevel.AVCProfileHigh);
            videoFormat.setInteger(MediaFormat.KEY_LEVEL, MediaCodecInfo.CodecProfileLevel.AVCLevel31);
        }else{
            videoFormat.setInteger(MediaFormat.KEY_BITRATE_MODE, MediaCodecInfo.EncoderCapabilities.BITRATE_MODE_VBR);
            videoFormat.setInteger(MediaFormat.KEY_PROFILE,MediaCodecInfo.CodecProfileLevel.HEVCProfileMain);
            videoFormat.setInteger(MediaFormat.KEY_LEVEL, MediaCodecInfo.CodecProfileLevel.HEVCHighTierLevel4);
        }

        try {
            mEncoder = MediaCodec.createEncoderByType(VIDEO_MIME_TYPE);
        } catch (IOException e) {
            e.printStackTrace();
        }
        mEncoder.setCallback(mediaCodecCallback);
        mEncoder.configure(videoFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
    }

//选择ColorFormat
private int selectColorFormat(String type) {
        return selectColorFormat(selectCodec(type), type);
    }

    private int selectColorFormat(MediaCodecInfo codecInfo, String mimeType) {
        MediaCodecInfo.CodecCapabilities capabilities = codecInfo.getCapabilitiesForType(mimeType);
        for (int i = 0; i < capabilities.colorFormats.length; i++) {
            int colorFormat = capabilities.colorFormats[i];
            if (isRecognizedFormat(colorFormat)) {
                return colorFormat;
            }
        }

        Log.w(TAG, "Couldn't find color format for " + codecInfo.getName()
                + " / " + mimeType);
        return 0; // not reached
    }

    private boolean isRecognizedFormat(int colorFormat) {
        switch (colorFormat) {
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar:
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
            case MediaCodecInfo.CodecCapabilities.COLOR_TI_FormatYUV420PackedSemiPlanar:
                return true;
            default:
                return false;
        }
    }

    private MediaCodecInfo selectCodec(String mimeType) {
        int numCodecs = MediaCodecList.getCodecCount();
        for (int i = 0; i < numCodecs; i++) {
            MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
            if (!codecInfo.isEncoder()) {
                continue;
            }
            String[] types = codecInfo.getSupportedTypes();
            for (int j = 0; j < types.length; j++) {
                if (types[j].equalsIgnoreCase(mimeType)) {
                    return codecInfo;
                }
            }
        }
        return null;
    }

3.开启encoder

public void startEncodec(){
        mEncoder.start();
        mStartTime = System.currentTimeMillis() * 1000;
        WorkThread workThread = new WorkThread();
        videoEncoderLoop = true;
        workThread.start();
    }

4.获取到preview数据，并送如编码器

class WorkThread extends Thread{
        @Override
        public void run() {
            while (videoEncoderLoop && !Thread.interrupted()) {
                Log.d(TAG, "run: ");
                int inputBufferIndex = 0;
                try {
                    inputBufferIndex = mInputIndexQueue.take().arg1;
                    Log.d(TAG,"inputBufferIndex="+inputBufferIndex);
                    if (inputBufferIndex >= 0) {
                        byte[] nv21Data = (byte[]) frameDataLinkedBlockingQueue.take();
                        ByteBuffer inputBuffer = mEncoder.getInputBuffer(inputBufferIndex);
                        inputBuffer.put(nv21Data);

                        long pts = System.currentTimeMillis() * 1000 - mStartTime;
                        mEncoder.queueInputBuffer(inputBufferIndex, 0, nv21Data.length, pts, 0);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            mInputIndexQueue.clear();
            frameDataLinkedBlockingQueue.clear();
        }
    }

    @Override
    public void previewDataCallBack(byte[] frameData) {
        try {
            frameDataLinkedBlockingQueue.put(frameData);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

5.mediaCodecCallback解析出编码后的vps sps vps帧，两种方式

private MediaCodec.Callback mediaCodecCallback = new MediaCodec.Callback() {
        @Override
        public void onInputBufferAvailable(MediaCodec mediaCodec, int i) {
            Message msg = new Message();
            msg.obj = mediaCodec;
            msg.arg1 = i;
            mInputIndexQueue.offer(msg);
        }

        @Override
        public void onOutputBufferAvailable(MediaCodec mediaCodec, int i, MediaCodec.BufferInfo bufferInfo) {
            if (!videoEncoderLoop)
                return;

            ByteBuffer buffer = mediaCodec.getOutputBuffer(i);//获取到该缓冲区
            //第一种方法,start {
            if (VIDEO_MIME_TYPE.equals(MediaFormat.MIMETYPE_VIDEO_AVC)) {
                int typeH264 = buffer.get(4) & 0x1F;//获取该缓冲区的类型
                if (typeH264 == 7 || typeH264 == 8) { //7代表SPS帧，8代表PPS帧(只有第一帧会出现此类帧（目前发现只有7），其余都是1或者5)
                    byte[] configFps = new byte[bufferInfo.size];
                    buffer.get(configFps);
                    Log.d(TAG, "chris buffer.position="+buffer.position()+",H264type= " + typeH264 +",value = "+bytesToHex(configFps));
                    //H264type= 7,value = 000000016764001FACB402802DD2905020206D0A13500000000168EE06E2C0

                    searchSPSandPPSFromH264(ByteBuffer.wrap(configFps),bufferInfo);
                }

            } else if (VIDEO_MIME_TYPE.equals(MediaFormat.MIMETYPE_VIDEO_HEVC)) {
                int typeH265 = (buffer.get(4) & 0x7e) >> 1;
                Log.d(TAG, "chris H265type= " + typeH265);
                if (typeH265 == 32 || typeH265 == 33 || typeH265 == 34) { //32代表VPS帧   33代表SPS帧，34代表PPS帧(只有第一帧会出现此类帧（目前发现只有32），其余都是1或者19)
                    byte[] configFps = new byte[bufferInfo.size];
                    buffer.get(configFps);
                    Log.d(TAG, "chris H265type= " + typeH265 +",value = "+bytesToHex(configFps));
                    //H265type= 32, value = 0000000140010C01FFFF016000000300B0000003000003005DAC5900000001420101016000000300B0000003000003005DA00280802E1F1396BB9324BB948281010176850940000000014401C0F1800420

                    searchVpsSpsPpsFromH265(ByteBuffer.wrap(configFps));
                }
            }
            //第一种方法,end }

            mediaCodec.releaseOutputBuffer(i, false);
        }

        @Override
        public void onError(MediaCodec mediaCodec, MediaCodec.CodecException e) {

        }

        @Override
        public void onOutputFormatChanged(MediaCodec mediaCodec, MediaFormat mediaFormat) {
            //第二种方法,start {
            if (VIDEO_MIME_TYPE == MediaFormat.MIMETYPE_VIDEO_HEVC) {
                searchVpsSpsPpsFromH265(mediaFormat.getByteBuffer("csd-0"));
            } else if (VIDEO_MIME_TYPE == MediaFormat.MIMETYPE_VIDEO_AVC) {
                ByteBuffer sps = mediaFormat.getByteBuffer("csd-0"); //000000016764001FACB402802DD2905020206D0A1350
                ByteBuffer pps = mediaFormat.getByteBuffer("csd-1"); //0000000168EE06E2C0
                Log.d(TAG,"H264 onOutputFormatChanged sps="+bytesToHex(sps.array()) + ",pps=" + bytesToHex(pps.array()));
                //onOutputFormatChanged sps=000000016764001FACB402802DD2905020206D0A1350,pps=0000000168EE06E2C0
            }
            //第二种方法,end }
        }
    };

6.解析每个帧的值

 //查找sps pps vps
    public void searchSPSandPPSFromH264(ByteBuffer buffer, MediaCodec.BufferInfo bufferInfo){

        byte[] csd = new byte[128];
        int len = 0, p = 4, q = 4;

        len = bufferInfo.size;
        Log.d(TAG,"len="+len);
        if (len<128) {
            buffer.get(csd,0,len);
            if (len>0 && csd[0]==0 && csd[1]==0 && csd[2]==0 && csd[3]==1) {
                // Parses the SPS and PPS, they could be in two different packets and in a different order
                //depending on the phone so we don't make any assumption about that
                while (p<len) {
                    while (!(csd[p+0]==0 && csd[p+1]==0 && csd[p+2]==0 && csd[p+3]==1) && p+3<len) p++;
                    if (p+3>=len) p=len;
                    if ((csd[q]&0x1F)==7) {
                        byte[] sps = new byte[p-q];
                        System.arraycopy(csd, q, sps, 0, p-q);
                        Log.d(TAG,"chris, searchSPSandPPSFromH264 SPS="+bytesToHex(sps));
                        //chris, searchSPSandPPSFromH264 SPS=6764001FACB402802DD2905020206D0A1350
                    } else {
                        byte[] pps = new byte[p-q];
                        System.arraycopy(csd, q, pps, 0, p-q);
                        Log.d(TAG,"chris, searchSPSandPPSFromH264 PPS="+bytesToHex(pps));
                        //chris, searchSPSandPPSFromH264 PPS=68EE06E2C0
                    }
                    p += 4;
                    q = p;
                }
            }
        }
    }

public void searchVpsSpsPpsFromH265(ByteBuffer csd0byteBuffer) {
    int vpsPosition = -1;
    int spsPosition = -1;
    int ppsPosition = -1;
    int contBufferInitiation = 0;
    byte[] csdArray = csd0byteBuffer.array();
    for (int i = 0; i < csdArray.length; i++) {
        if (contBufferInitiation == 3 && csdArray[i] == 1) {
            if (vpsPosition == -1) {
                vpsPosition = i - 3;
            } else if (spsPosition == -1) {
                spsPosition = i - 3;
            } else {
                ppsPosition = i - 3;
            }
        }
        if (csdArray[i] == 0) {
            contBufferInitiation++;
        } else {
            contBufferInitiation = 0;
        }
    }
    byte[] vps = new byte[spsPosition];
    byte[] sps = new byte[ppsPosition - spsPosition];
    byte[] pps = new byte[csdArray.length - ppsPosition];
    for (int i = 0; i < csdArray.length; i++) {
        if (i < spsPosition) {
            vps[i] = csdArray[i];
        } else if (i < ppsPosition) {
            sps[i - spsPosition] = csdArray[i];
        } else {
            pps[i - ppsPosition] = csdArray[i];
        }
    }

    Log.d(TAG, "searchVpsSpsPpsFromH265: vps="+ bytesToHex(vps)+",sps="+bytesToHex(sps)+",pps="+bytesToHex(pps));
    //vps=0000000140010C01FFFF016000000300B0000003000003005DAC59,sps=00000001420101016000000300B0000003000003005DA00280802E1F1396BB9324BB948281010176850940,pps=000000014401C0F1800420
}

7.工具bytesToHex

final protected static char[] hexArray = "0123456789ABCDEF".toCharArray();
public static String bytesToHex(byte[] bytes) {
    char[] hexChars = new char[bytes.length * 2];
    for ( int j = 0; j < bytes.length; j++ ) {
        int v = bytes[j] & 0xFF;
        hexChars[j * 2] = hexArray[v >>> 4];
        hexChars[j * 2 + 1] = hexArray[v & 0x0F];
    }
    return new String(hexChars);
}
Mr*Chris
关注
专栏目录
Android开发之利用MediaCodec 获取视频的sps pps 和视频数据
hnjzfwy的博客
04-02 1112
Android开发之利用MediaCodec 获取视频的sps pps 和视频数据，一般情况 SPS 和 PPS 的 NAL Unit 通常位于整个码流的起始位置。封装文件一般进保存一次，位于文件头部，SPS/PPS 在整个解码过程中复用，不发生变化。然而对于实时流，通常是从流中间开始解码，因此需要在每个I帧前添加SPS和PPS； 如果编码器在编码过程中改变了码流参数（如分辨率），需要重新调整SPS和PPS数据。
（四）音视频 Ｈ265学习 SPS解析
weixin_43911199的博客
09-15 785
H２６４主要适合１０８０P以及以下的视频编解码，无法对４K和８K的视频进行编解码。H265可以对4k和8k视频进行编解码。H２６５和H２６４相比主要有哪些相同点和不同点呢？
H264/H265的两种格式Annex B、AVCC(H264)/HVCC(H265)
不定期更新关于音视频的文章
03-25 4223
H.264 (AVC) 和 H.265 (HEVC) 是两种常见的视频编码标准，它们都有不同的封装格式，即Annex B 和 AVCC(H264)/HVCC(H265) 封装格式。
Android APP 音视频（01）MediaCodec解码H264码流
最新发布
wangdsh的博客
07-23 1903
H.264，也被称为MPEG-4 AVC（Advanced Video Coding），是一种广泛使用的数字视频压缩标准，主要用于视频编码。H.264标准由ITU-T视频编码专家组（VCEG）和ISO/IEC动态图像专家组（MPEG）共同开发，旨在提供比之前的视频编码标准更高的数据压缩效率。H.264是一种基于块的编码技术，它将视频帧分为多个宏块（Macroblocks，MBs），每个宏块包含亮度信息和色度信息。帧类型，I帧（Intra-coded frames）
H265编码 SPS分析
sunlifeall的博客
07-13 3855
学习目标： H265编码分析 学习内容： H265出现的原因： 我们视频的分辨率 从 720p到1080p,而且电视的屏幕也越来越大 视频帧率从30帧 到60帧，再到120帧 这就会导致我们cpu在编解码的时候，会出现宏块个数爆发式增长，运动矢量复杂度增加的后果，直接导致我们编码后的视频文件依旧很大，所以H264编码方式已经不满足现在的需求了，H265也就应运而生。 下面是通过Elecard HEVCAnalyzer 软件分析宏块的效果，可以看到我们的宏块大小在颜色差异大的地方越小，这样我们的画
android 存储h264数据,android - Android MediaCodec将原始视频编码为h264 - 堆栈内存溢出...
weixin_36044301的博客
05-27 450
我正在尝试将手机摄像头输出转换为.h264 es格式，但MediaCodec编码器在第一帧后卡在TRY_AGAIN_LATER输出缓冲器状态。摄像头预览设置为NV21。这是相机到编码器：mCamera.setPreviewCallback(new Camera.PreviewCallback() {private long timestamp=0;@Overridepublic void onPr...
FFmpeg简单使用：解封装h264 ---- 提取SPS PPS
huabiaochen的博客
12-27 1231
2_bit: 数据长度-1：avcc格式是extradata | [length] [nalu] | [length][nalu]，这里length所占的字节数就是3（11）+ 1 = 4。0x28: avc level （首个SPS的第3个字节，可以发现后面0x0989位置的3个字，和这3个是一样的）0x67: [0110 0111] nalu_type为7，表示SPS，就是说从0988到099f这24个数据为sps。5_bit: 接下来的sps或pps的个数:：这里为1。3_bit: 默认 111。
h264码流中SPS PPS的作用及mp4文件中查找sps pps
05-24
本文档讲叙如何从mp4文件中查找 sps pps等和h264编码信息相关的内容，同时介绍了h264 raw 流中 naul单元的分类。
Android视频编解码
lkl22的专栏
02-22 6017
简介 　　从广义上讲，编解码器就是处理输入数据来产生输出数据。MediaCode采用异步方式处理数据，并且使用了一组输入输出缓存（input and output buffers）。简单来讲，你请求或接收到一个空的输入缓存（input buffer），向其中填充满数据并将它传递给编解码器处理。编解码器处理完这些数据并将处理结果输出至一个空的输出缓存（output buffer）中。最终，你请求或...
Android H.265硬解码&EasyPlayerPro
热门推荐
jyt0551的博客
07-05 1万+
H.265编码算法作为新一代视频编码标准，在编码效果上有了很大的进步，同样清晰度的视频，265要比264有着更低的码率。关于265对比264的优越性，网上有更专业的文章来作分析，我也仅对这两种算法略知皮毛，因此不多阐述。基于其更高的压缩比，H.265适用于安防行业再合适不过了！因为安防行业每天都有着海量的视频数据在产生，同时需要实时传输、分析、存储…在带宽和存储成本依然昂贵的今天，我们极度需要更低的
（五）音视频 Ｈ265投屏传输
weixin_43911199的博客
12-24 413
对手机A的屏幕内容进行H265编码，再通过socket传输发送给手机B。主要利用过的技术是H265编解码和socket通信。
H.265码流解析
青山渺渺
05-24 1665
H.265（hevc）码流解析
h265 Nalu类型判断及 sps 数据解析
H265技术专栏
03-20 4900
      一，Nalu解析                        首先来介绍下h265（HEVC）nal单元头，与h264的nal层相比，h265的nal unit header有两个字节构成，如下图所示 0                   10 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5+ -+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+| F | ...
H264码流中SPS PPS
weixin_40673765的博客
03-22 284
转载地址：https://www.cnblogs.com/wainiwann/p/7477794.html 1 SPS和PPS从何处而来？ 2 SPS和PPS中的每个参数起什么作用？ 3 如何解析SDP中包含的H.264的SPS和PPS串？
（一）音视频：解码H264文件流程 渲染和拿到解码后源数据YUV 完整Demo
weixin_43911199的博客
08-06 1774
本博文讲解H264文件通过MediaCodec硬解码流程，解码后的处理：渲染和获取原始数据YUV。获取到的原始数据用7YUV工具查看出现绿色和紫色条的原因以及处理方式。
如何从RTP包的AP类型包，获取h265的PPS、SPS、VPS信息
cf125313的专栏
12-28 1301
ffmpeg播放rtp流，为了降低首开延迟，需要在SDP文件中指定PPS、SPS、VPS信息。抓包后发现wireshark无法解析AP包。下图中红色部分是分隔符，橙色是VPS，黑色是SPS，黄色为PPS。根据如上信息，我们可以解析AP包，效果如下。
MediaCodec视频编码H264流程及参考demo
分享音视频技术
11-09 2401
本文则讲解使用MediaCodec进行视频编码的流程，主要通过一个例子，从摄像头采集数据，并将数据编码为h264文件。
VPS SPS PPS
LIEY
09-10 4571
视频参数集VPS H.265中增加，主要用于传输视频分级信息，有利于兼容标准在可分级视频编码或多视点视频的扩展。 注意：对于一个视频序列，无论它每一层的SPS是否相同，都参考相同的VPS。 序列参数集SPS SPS即Sequence Paramater Set，又称作序列参数集。SPS中保存了一组编码视频序列(Coded video sequence)的全局参数。所谓的编码视频序列即原...
Android Camera to H264 with MediaCodec: A Step-by-Step Guide
"本文主要介绍了如何在Android平台上利用MediaCodec API将摄像头采集的视频流进行H.264编码。首先，我们将从创建一个基本的Android Activity开始，它包含一个SurfaceView用于显示预览画面，并实现SurfaceHolder....
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值