H.264（H264）解码SPS获取分辨率和帧率

最新推荐文章于 2023-08-16 20:39:55 发布
最新推荐文章于 2023-08-16 20:39:55 发布
阅读量1.9k 收藏 7
点赞数
分类专栏： 音视频
原文链接：https://blog.csdn.net/lbc2100/article/details/79928689?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-1&spm=1001.2101.3001.4242
版权

H264 视频解析 SPS 帧率 NAL单元
关键词由CSDN通过智能技术生成

  1. #include <stdio.h>  
    #include <stdint.h>  
    #include <string.h>  
    #include <math.h>  
      
    typedef  unsigned int UINT;  
    typedef  unsigned char BYTE;  
    typedef  unsigned long DWORD;  
      
    UINT Ue(BYTE *pBuff, UINT nLen, UINT &nStartBit)  
    {  
        //计算0bit的个数  
        UINT nZeroNum = 0;  
        while (nStartBit < nLen * 8)  
        {  
            if (pBuff[nStartBit / 8] & (0x80 >> (nStartBit % 8))) //&:按位与，%取余  
            {  
                break;  
            }  
            nZeroNum++;  
            nStartBit++;  
        }  
        nStartBit ++;  
      
      
        //计算结果  
        DWORD dwRet = 0;  
        for (UINT i=0; i<nZeroNum; i++)  
        {  
            dwRet <<= 1;  
            if (pBuff[nStartBit / 8] & (0x80 >> (nStartBit % 8)))  
            {  
                dwRet += 1;  
            }  
            nStartBit++;  
        }  
        return (1 << nZeroNum) - 1 + dwRet;  
    }  
      
      
    int Se(BYTE *pBuff, UINT nLen, UINT &nStartBit)  
    {  
        int UeVal=Ue(pBuff,nLen,nStartBit);  
        double k=UeVal;  
        int nValue=ceil(k/2);//ceil函数：ceil函数的作用是求不小于给定实数的最小整数。ceil(2)=ceil(1.2)=cei(1.5)=2.00  
        if (UeVal % 2==0)  
            nValue=-nValue;  
        return nValue;  
    }  
      
      
    DWORD u(UINT BitCount,BYTE * buf,UINT &nStartBit)  
    {  
        DWORD dwRet = 0;  
        for (UINT i=0; i<BitCount; i++)  
        {  
            dwRet <<= 1;  
            if (buf[nStartBit / 8] & (0x80 >> (nStartBit % 8)))  
            {  
                dwRet += 1;  
            }  
            nStartBit++;  
        }  
        return dwRet;  
    }  
      
    /** 
     * H264的NAL起始码防竞争机制 
     * 
     * @param buf SPS数据内容 
     * 
     * @无返回值 
     */  
    void de_emulation_prevention(BYTE* buf,unsigned int* buf_size)  
    {  
        int i=0,j=0;  
        BYTE* tmp_ptr=NULL;  
        unsigned int tmp_buf_size=0;  
        int val=0;  
      
        tmp_ptr=buf;  
        tmp_buf_size=*buf_size;  
        for(i=0;i<(tmp_buf_size-2);i++)  
        {  
            //check for 0x000003  
            val=(tmp_ptr[i]^0x00) +(tmp_ptr[i+1]^0x00)+(tmp_ptr[i+2]^0x03);  
            if(val==0)  
            {  
                //kick out 0x03  
                for(j=i+2;j<tmp_buf_size-1;j++)  
                    tmp_ptr[j]=tmp_ptr[j+1];  
      
                //and so we should devrease bufsize  
                (*buf_size)--;  
            }  
        }  
    }  
      
    /** 
     * 解码SPS,获取视频图像宽、高和帧率信息 
     * 
     * @param buf SPS数据内容 
     * @param nLen SPS数据的长度 
     * @param width 图像宽度 
     * @param height 图像高度 
     
     * @成功则返回true , 失败则返回false 
     */  
    bool h264_decode_sps(BYTE * buf,unsigned int nLen,int &width,int &height,int &fps)  
    {  
        UINT StartBit=0;  
        fps=0;  
        de_emulation_prevention(buf,&nLen);  
      
        int forbidden_zero_bit=u(1,buf,StartBit);  
        int nal_ref_idc=u(2,buf,StartBit);  
        int nal_unit_type=u(5,buf,StartBit);  
        if(nal_unit_type==7)  
        {  
            int profile_idc=u(8,buf,StartBit);  
            int constraint_set0_flag=u(1,buf,StartBit);//(buf[1] & 0x80)>>7;  
            int constraint_set1_flag=u(1,buf,StartBit);//(buf[1] & 0x40)>>6;  
            int constraint_set2_flag=u(1,buf,StartBit);//(buf[1] & 0x20)>>5;  
            int constraint_set3_flag=u(1,buf,StartBit);//(buf[1] & 0x10)>>4;  
            int reserved_zero_4bits=u(4,buf,StartBit);  
            int level_idc=u(8,buf,StartBit);  
      
            int seq_parameter_set_id=Ue(buf,nLen,StartBit);  
      
            if( profile_idc == 100 || profile_idc == 110 ||  
                profile_idc == 122 || profile_idc == 144 )  
            {  
                int chroma_format_idc=Ue(buf,nLen,StartBit);  
                if( chroma_format_idc == 3 )  
                    int residual_colour_transform_flag=u(1,buf,StartBit);  
                int bit_depth_luma_minus8=Ue(buf,nLen,StartBit);  
                int bit_depth_chroma_minus8=Ue(buf,nLen,StartBit);  
                int qpprime_y_zero_transform_bypass_flag=u(1,buf,StartBit);  
                int seq_scaling_matrix_present_flag=u(1,buf,StartBit);  
      
                int seq_scaling_list_present_flag[8];  
                if( seq_scaling_matrix_present_flag )  
                {  
                    for( int i = 0; i < 8; i++ ) {  
                        seq_scaling_list_present_flag[i]=u(1,buf,StartBit);  
                    }  
                }  
            }  
            int log2_max_frame_num_minus4=Ue(buf,nLen,StartBit);  
            int pic_order_cnt_type=Ue(buf,nLen,StartBit);  
            if( pic_order_cnt_type == 0 )  
                int log2_max_pic_order_cnt_lsb_minus4=Ue(buf,nLen,StartBit);  
            else if( pic_order_cnt_type == 1 )  
            {  
                int delta_pic_order_always_zero_flag=u(1,buf,StartBit);  
                int offset_for_non_ref_pic=Se(buf,nLen,StartBit);  
                int offset_for_top_to_bottom_field=Se(buf,nLen,StartBit);  
                int num_ref_frames_in_pic_order_cnt_cycle=Ue(buf,nLen,StartBit);  
      
                int *offset_for_ref_frame=new int[num_ref_frames_in_pic_order_cnt_cycle];  
                for( int i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++ )  
                    offset_for_ref_frame[i]=Se(buf,nLen,StartBit);  
                delete [] offset_for_ref_frame;  
            }  
            int num_ref_frames=Ue(buf,nLen,StartBit);  
            int gaps_in_frame_num_value_allowed_flag=u(1,buf,StartBit);  
            int pic_width_in_mbs_minus1=Ue(buf,nLen,StartBit);  
            int pic_height_in_map_units_minus1=Ue(buf,nLen,StartBit);  

            printf("num_ref_frames:%d.\n", num_ref_frames);
            width=(pic_width_in_mbs_minus1+1)*16;  
            height=(pic_height_in_map_units_minus1+1)*16;  
      
            int frame_mbs_only_flag=u(1,buf,StartBit);  
            if(!frame_mbs_only_flag)  
                int mb_adaptive_frame_field_flag=u(1,buf,StartBit);  
      
            int direct_8x8_inference_flag=u(1,buf,StartBit);  
            int frame_cropping_flag=u(1,buf,StartBit);  
            if(frame_cropping_flag)  
            {  
                int frame_crop_left_offset=Ue(buf,nLen,StartBit);  
                int frame_crop_right_offset=Ue(buf,nLen,StartBit);  
                int frame_crop_top_offset=Ue(buf,nLen,StartBit);  
                int frame_crop_bottom_offset=Ue(buf,nLen,StartBit);  
            }  
            int vui_parameter_present_flag=u(1,buf,StartBit);  
            printf("vui_parameter_present_flag:%d.\n", vui_parameter_present_flag);
            if(vui_parameter_present_flag)  
            {  
                int aspect_ratio_info_present_flag=u(1,buf,StartBit);  
                if(aspect_ratio_info_present_flag)  
                {  
                    int aspect_ratio_idc=u(8,buf,StartBit);  
                    if(aspect_ratio_idc==255)  
                    {  
                        int sar_width=u(16,buf,StartBit);  
                        int sar_height=u(16,buf,StartBit);  
                    }  
                }  
                int overscan_info_present_flag=u(1,buf,StartBit);  
                if(overscan_info_present_flag)  
                    int overscan_appropriate_flagu=u(1,buf,StartBit);  
                int video_signal_type_present_flag=u(1,buf,StartBit);  
                if(video_signal_type_present_flag)  
                {  
                    int video_format=u(3,buf,StartBit);  
                    int video_full_range_flag=u(1,buf,StartBit);  
                    int colour_description_present_flag=u(1,buf,StartBit);  
                    if(colour_description_present_flag)  
                    {  
                        int colour_primaries=u(8,buf,StartBit);  
                        int transfer_characteristics=u(8,buf,StartBit);  
                        int matrix_coefficients=u(8,buf,StartBit);  
                    }  
                }  
                int chroma_loc_info_present_flag=u(1,buf,StartBit);  
                if(chroma_loc_info_present_flag)  
                {  
                    int chroma_sample_loc_type_top_field=Ue(buf,nLen,StartBit);  
                    int chroma_sample_loc_type_bottom_field=Ue(buf,nLen,StartBit);  
                }  
                int timing_info_present_flag=u(1,buf,StartBit);  
      
                if(timing_info_present_flag)  
                {  
                    int num_units_in_tick=u(32,buf,StartBit);  
                    int time_scale=u(32,buf,StartBit);  
                    fps=time_scale/num_units_in_tick;  
                    int fixed_frame_rate_flag=u(1,buf,StartBit);  
                    if(fixed_frame_rate_flag)  
                    {  
                        fps=fps/2;  
                    }  
                }  
            }  
            return true;  
        }  
        else  
            return false;  
    }  


    #define H264_FILE "1080P.h264"

    int main()
    {
        FILE *fpStrm = NULL;
        int s32ReadLen = 0;
        BYTE buffer[512] = {0};
        int width = 0;
        int height = 0;
        int fps = 0;
        
        fpStrm = fopen(H264_FILE, "rb");
        
        s32ReadLen = fread(&buffer, 1, 256, fpStrm);
        h264_decode_sps(&buffer[4], 128, width, height, fps);
        printf("width:%d height:%d fps:%d.\n", width, height, fps);
        return 0;
    }

编译：g++ -o h264_parse h264_parse.c

执行结果：

num_ref_frames:1.
vui_parameter_present_flag:0.
width:1920 height:1088 fps:0.

从上述结果可以看到，h264帧率未正确获取到

timing_info_present_flag等于1表示num_units_in_tick，time_scale和fixed_frame_rate_flag在比特流中存在。

timing_info_present_flag等于0表示num_units_in_tick，time_scale和fixed_frame_rate_flag在比特流中不存在。

因此，当timing_info_present_flag等于0时，无法得到码率，bool h264_decode_sps(BYTE * buf,unsigned int nLen,int &width,int &height,int &fps)参数fps返回值为0，可据此设置一个默认帧率。

H264码流片段：（H264，1920*1088@30fps）

20 20 20 01 67 4d 20 2a 95 a8 1e 20 89 f9 50 20 20 20 01 68 ee 3c 80 20 20 20 01 06 e5 01 d8 80 20 20 20 01 65 b8 20 20 0b f8 41 ff da 08 b0 ab af 5f ef 75 38 ad 10 e5 99 b4 61 03 0c 05 83 89 51 e9 42 d7 5a ed 91 9a 37 32 fb d5 8f 16 51 e6 08 75 0f 50 6c 29 1a 7e f1 6b 42 97 31 60 32 d5 4f 30 2f 57 c1 63 2c 93 43 9f 62 99 bb d5 bb f7 18 b2 72 48 0a 9e ab d1 fe b6 5c a8 d3 0e c4 77 86 95 2b 6e f4 5c 0f eb e3 bf f8 4b 19 78 25 19  

460833359
关注
专栏目录
解sps获取分辨率宽高
10-18
从网上找的代码，使用时候参考了，还不错里边有readme，比较详细的使用方法
H264（代码）---序列参数集（SPS）---解析并获取帧率
qq_42024067的博客
08-23 2594
H.264（H264）解码SPS获取分辨率和帧率 实例代码 H264ParseSPS.h // H264ParseSPS.h #ifndef H264ParseSPS_h #define H264ParseSPS_h #include <stdio.h> typedef struct { unsigned int profile_idc; unsigned int level_idc; unsigned int width; unsign
H264 帧率的计算
热门推荐
风衣吹的博客
07-01 1万+
这两天做h264 rtmp协议上传需要计算帧率，踩了很多坑记录下. 第一步当然要解析sps，解析sps的资料网上很多。 关键得到两个值：1、num_units_in_tick；2、time_scale； fps=time_scale/num_units_in_tick; 这个值是不准确的，网上查了各种资料说nuit_field_based_flag=1时要除以2，值=0
H264之sps解析分辨率
06-19 5025
sps定义如下：解析如下：分辨率：pic_width_in_mbs_minusl =29  ===&gt;(29+1)*16 =480pic_height_in_map_units_minusl=16 ===&gt;(16+1)*16=272
java h264 sps解码,H.264（H264）解码SPS获取分辨率和帧率
weixin_36180611的博客
03-19 1014
h264 ES流中的sps nalu中可以提取出视频宽度和高度的信息，有时可以得到固定帧率的信息，而对于变帧率的视频有时候得不到帧率信息，需要根据时间戳来呈现。代码可以实现这个功能。#include#include#include#includetypedefunsignedintUINT;typedefunsignedcharBYTE;typedefunsignedlongDWORD;U...
h264sps解析获取分辨率
05-17
解析H.264 SPS是理解视频流特性，特别是获取视频分辨率的关键步骤。 H.264编码流程中，SPS通常位于NAL单元（Network Abstraction Layer Unit）中，由一个起始码（通常为0x000001或0x00000001）和随后的数据组成。...
从码流获取H264、H265的分辨率信息
10-02
从码流获取H264、H265的分辨率信息是一个复杂的过程，需要正确地理解H264和H265视频流的SPS字段结构和计算公式。只有正确地获取了分辨率信息，才能正确地解析和处理视频流。本文提供了详细的计算公式和步骤，希望...
解析h264 sps获取分辨率
08-19
3. **解码SPS语法**：SPS数据遵循特定的二进制语法，你需要按照H264标准解析它。SPS的基本结构包括： - **Profile IDC**：定义编码的级别和特性。 - **Level IDC**：定义编码的复杂度水平。 - **...
h264parseSPS_h264编码_
10-02
解析h264编码中的sps帧获取视频信息
ffmpeg中求h264视频宽高和帧率的代码
11-24
ffmpeg中求h264视频宽高和帧率的代码，支持三种规格，尤其是正在为high规格发愁的可以下载看看，我认为我的劳动成果绝对不止一分。程序运行需要你有一个h264文件。
从H264编码的sps解析出来图像参数
04-08
从h264图像编码里的sps nalu里解析出来图像的宽和高，级别等参数。
H264 spsparser
07-13
H264 SPS解析工具
视频知识点（20）- H264码流如何在SPS中获取宽高信息？
liuzhen007的专栏
02-11 669
了解H264视频编码格式的小伙伴都知道，H264编码中存在两个非常重要的参数集。没错，它们就是序列参数集（SPS）和图像参数集（PPS），而且通常情况下，PPS会依赖SPS中的部分参数信息，同时，视频码流的宽高信息也存储在SPS中，那么如何从中获取宽高呢，就是今天本文的主要内容。
获取H264视频分辨率的方法
qq_23552895的博客
03-05 2136
以下内容主要参考了这篇文章：https://www.cnblogs.com/likwo/p/3531241.html H.264码流的流信息都存储在了特殊的结构中，叫做SPS(Sequence Parameter Set)。要解析SPS就需要知道一些H.264码流的格式信息。 在H.264码流中，都是以0x00 0x00 0x01或者0x00 0x00 0x00 0...
H264解析帧率信息
最新发布
嵌入式大师之路
08-16 1000
主要分析Annex-B格式的H264码流，该格式常见于编码器输出，码流由多个NALU单元组成，网络流媒体传输时需要将每帧数据解析出来，进一步打包成RTP包发送。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值