h264 sps解析，提取宽高

最新推荐文章于 2024-04-17 21:00:20 发布
最新推荐文章于 2024-04-17 21:00:20 发布
阅读量2.3k 收藏 3
点赞数 1
分类专栏： x264 文章标签： h264
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CodySnow/article/details/51576735
版权

1、sps 数据结构
1）、从Bit流中取出句法元素的方法。
|编号 | 语法 |说明|

1              ae(e)          CABAC
2              b(8)            读进连续的8个Bit
3              ce(v)          CAVLC
4              f(n)             读进连续的n个Bit
5              i(n)/i(v)    读进连续的若干Bit，并把它们解释为有符号整数
6              me(v)           映射指数Golomb熵编码
7              se(v)            有符号指数Golomb熵编码
8              te(v)             截断指数Golomb熵编码
9              u(n)/u(v)  读进连续的若干Bit，并把它们解释为无符号整数
10             ue(v)              无符号指数Golomb熵编码

主要是同过bitstream.h 进行处理的 代码如下：

# ifdef NOCACHE

typedef struct {
    const uint8_t *data; //存放除了sps数据
    int            count; /* in bits */
    int            index; /* in bits */ 
} br_state;

#define BR_INIT(data,bytes) {(data), 8*(bytes), 0}

#define BR_EOF(br) ((br)->index >= (br)->count)

static inline void br_init(br_state *br, const uint8_t *data, int bytes)
{

    br->data  = data;
    br->count = 8*bytes;
    br->index = 0;

}

static inline int br_get_bit(br_state *br)
{

    if(br->index >= br->count)
        return 1; /* -> no infinite colomb's ... */

    int r = (br->data[br->index>>3] >> (7 - (br->index&7))) & 1;
    br->index++;
    return r;

}

static inline uint32_t br_get_bits(br_state *br, uint32_t n)
{

    uint32_t r = 0;
    while(n--)
        r = r | (br_get_bit(br) << n);
    return r;

}

#define br_skip_bit(br) br_skip_bits(br,1)

static inline void br_skip_bits(br_state *br, int n)
{

    br->index += n;

}


# else /* NOCACHE */


typedef struct {

    uint8_t *data;
    uint8_t *data_end;
    uint32_t cache;
    uint32_t cache_bits;

} br_state;

#define BR_INIT(data,bytes) {(data), (data)+(bytes), 0, 0}

static inline void br_init(br_state *br, const uint8_t *data, int bytes)
{

    br->data       = data;
    br->data_end   = data + bytes;
    br->cache      = 0;
    br->cache_bits = 0;

}

#define BR_GET_BYTE(br) \
(br->data < br->data_end ? *br->data++ : 0xff)

#define BR_EOF(br) ((br)->data >= (br)->data_end)

static inline uint32_t br_get_bits(br_state *br, uint32_t n)
{

    if(n > 24)
        return (br_get_bits(br, 16) << 16) | br_get_bits(br, n-16);

    while (br->cache_bits < 24) {

        br->cache = (br->cache<<8) | BR_GET_BYTE(br);
        br->cache_bits += 8;

    }

    br->cache_bits -= n;
    return (br->cache >> br->cache_bits) & ((1<<n) - 1);

}

static inline int br_get_bit(br_state *br)
{

    if(!br->cache_bits) {

        br->cache = BR_GET_BYTE(br);
        br->cache_bits = 7;

    } else {

        br->cache_bits--;

    }
    return (br->cache >> br->cache_bits) & 1;

}

static inline void br_skip_bit(br_state *br)
{

    if(!br->cache_bits) {

        br->cache = BR_GET_BYTE(br);
        br->cache_bits = 7;

    } else {

        br->cache_bits--;

    }

}

static inline void br_skip_bits(br_state *br, int n)
{

    if(br->cache_bits >= n) {

        br->cache_bits -= n;

    } else {

        /* drop cached bits */
        n -= br->cache_bits;

        /* drop full bytes */
        br->data += (n >> 3);
        n &= 7;

        /* update cache */
        if(n) {

            br->cache = BR_GET_BYTE(br);
            br->cache_bits = 8 - n;

        } else {

            br->cache_bits = 0;

        }

    }

}


# endif /* NOCACHE */


#define br_get_u8(br)         br_get_bits(br, 8)
#define br_get_u16(br)        ((br_get_bits(br, 8)<<8) | br_get_bits(br, 8))

static inline uint32_t br_get_ue_golomb(br_state *br)
{

    int n = 0;
    while (!br_get_bit(br) && n < 32)
        n++;
    return n ? ((1<<n) - 1) + br_get_bits(br, n) : 0;

}

#pragma warning(disable: 4146)

static inline int32_t br_get_se_golomb(br_state *br)
{

    uint32_t r = br_get_ue_golomb(br) + 1;
    return (r&1) ? -(r>>1) : (r>>1);

}

static inline void br_skip_golomb(br_state *br)
{

    int n = 0;
    while (!br_get_bit(br) && n < 32)
        n++;
    br_skip_bits(br, n);

}

#define br_skip_ue_golomb(br) br_skip_golomb(br)
#define br_skip_se_golomb(br) br_skip_golomb(br)

2、nal 语法
自己百度或google。这里就不介绍了，下面具体说下sps结构体里面的字段
3、sps
详细信息可以参考链接sps详解介绍
4、代码实现

#ifndef __SPSparse__SPS__
#define __SPSparse__SPS__

#include <stdio.h>
#ifdef _MSC_VER
typedef signed char     int8_t;
typedef unsigned char   uint8_t;
typedef short           int16_t;
typedef unsigned short  uint16_t;
typedef int             int32_t;
typedef unsigned        uint32_t;
#else
#include <stdint.h>
#endif //

#ifdef __cplusplus
extern "C" {

#endif


#define NAL_SPS     0x07 /* Sequence Parameter Set */
#define NAL_AUD     0x09 /* Access Unit Delimiter */
#define NAL_END_SEQ 0x0a /* End of Sequence */


#if defined(__i386__) || defined(__x86_64__)
#  define IS_NAL_SPS(buf)     (*(const uint32_t *)(buf) == 0x07010000U)
#  define IS_NAL_AUD(buf)     (*(const uint32_t *)(buf) == 0x09010000U)
#  define IS_NAL_END_SEQ(buf) (*(const uint32_t *)(buf) == 0x0a010000U)
#else
#  define IS_NAL_SPS(buf)     ((buf)[0] == 0 && (buf)[1] == 0 && (buf)[2] == 1 && (buf)[3] == NAL_SPS)
#  define IS_NAL_AUD(buf)     ((buf)[0] == 0 && (buf)[1] == 0 && (buf)[2] == 1 && (buf)[3] == NAL_AUD)
#  define IS_NAL_END_SEQ(buf) ((buf)[0] == 0 && (buf)[1] == 0 && (buf)[2] == 1 && (buf)[3] == NAL_END_SEQ)
#endif


    typedef struct mpeg_rational_s {

        int num;
        int den;

    } mpeg_rational_t;

    typedef struct video_size_s {

        uint16_t        width;
        uint16_t        height;
        mpeg_rational_t pixel_aspect;

    } video_size_t;

    typedef struct {

        uint16_t        width;
        uint16_t        height;
        mpeg_rational_t pixel_aspect;
        uint8_t   profile;
        uint8_t   level;

    } h264_sps_data_t;

    struct video_size_s;


    /*
     * input: start of NAL SPS ( 00 00 01 07 or 00 00 00 01 67 0r 67)
     */
    int h264_parse_sps(const uint8_t *buf, int len, h264_sps_data_t *sps);

#ifdef __cplusplus
}

#endif

#endif /* defined(__SPSparse__SPS__) */
#include "SPS.h"


#include <string.h>
#include <stdio.h>

#define NOCACHE 1
#include "BitStream.h"


int h264_parse_sps(const uint8_t *buf, int len, h264_sps_data_t *sps) {

        //find sps
    bool findSPS = false;

    if (buf[2] == 0) {
        if ((buf[4]&0x1f) == 7) { //start code 0 0 0 1
            len -= 5;
            buf += 5;
            findSPS = true;
        }
    } else if (buf[2] == 1) {//start code 0 0 1
        if ((buf[3]&0x1f) == 7) {
            len -= 4;
            buf += 4;
            findSPS = true;
        }
    } else {
        if ((buf[0]&0x1f) == 7) { //no start code 0x67 开头
            len -= 1;
            buf += 1;
            findSPS = true;
        }
    }


    br_state br = BR_INIT(buf, len);
    int profile_idc, pic_order_cnt_type;
    int frame_mbs_only;
    int i, j;

    profile_idc = br_get_u8(&br);
    sps->profile = profile_idc;
    printf("H.264 SPS: profile_idc %d", profile_idc);
    /* constraint_set0_flag = br_get_bit(br);    */
    /* constraint_set1_flag = br_get_bit(br);    */
    /* constraint_set2_flag = br_get_bit(br);    */
    /* constraint_set3_flag = br_get_bit(br);    */
    /* reserved             = br_get_bits(br,4); */
    sps->level = br_get_u8(&br);
    br_skip_bits(&br, 8);
    br_skip_ue_golomb(&br);   /* seq_parameter_set_id */
    if (profile_idc >= 100) {

        if (br_get_ue_golomb(&br) == 3) /* chroma_format_idc      */
            br_skip_bit(&br);     /* residual_colour_transform_flag */
        br_skip_ue_golomb(&br); /* bit_depth_luma - 8             */
        br_skip_ue_golomb(&br); /* bit_depth_chroma - 8           */
        br_skip_bit(&br);       /* transform_bypass               */
        if (br_get_bit(&br))    /* seq_scaling_matrix_present     */
            for (i = 0; i < 8; i++)
                if (br_get_bit(&br)) {
                    /* seq_scaling_list_present    */
                    int last = 8, next = 8, size = (i<6) ? 16 : 64;
                    for (j = 0; j < size; j++) {

                        if (next)
                            next = (last + br_get_se_golomb(&br)) & 0xff;
                        last = next ? next: last;

                    }

                }

    }

    br_skip_ue_golomb(&br);      /* log2_max_frame_num - 4 */
    pic_order_cnt_type = br_get_ue_golomb(&br);
    if (pic_order_cnt_type == 0)
        br_skip_ue_golomb(&br);    /* log2_max_poc_lsb - 4 */
    else if (pic_order_cnt_type == 1) {

        br_skip_bit(&br);          /* delta_pic_order_always_zero     */
        br_skip_se_golomb(&br);    /* offset_for_non_ref_pic          */
        br_skip_se_golomb(&br);    /* offset_for_top_to_bottom_field  */
        j = br_get_ue_golomb(&br); /* num_ref_frames_in_pic_order_cnt_cycle */
        for (i = 0; i < j; i++)
            br_skip_se_golomb(&br);  /* offset_for_ref_frame[i]         */

    }
    br_skip_ue_golomb(&br);      /* ref_frames                      */
    br_skip_bit(&br);            /* gaps_in_frame_num_allowed       */
    sps->width  /* mbs */ = br_get_ue_golomb(&br) + 1;
    sps->height /* mbs */ = br_get_ue_golomb(&br) + 1;
    frame_mbs_only        = br_get_bit(&br);
    printf("H.264 SPS: pic_width:  %u mbs", (unsigned) sps->width);
    printf("H.264 SPS: pic_height: %u mbs", (unsigned) sps->height);
    printf("H.264 SPS: frame only flag: %d", frame_mbs_only);

    sps->width  *= 16;
    sps->height *= 16 * (2-frame_mbs_only);

    if (!frame_mbs_only)
        if (br_get_bit(&br)) /* mb_adaptive_frame_field_flag */
            printf("H.264 SPS: MBAFF");
    br_skip_bit(&br);      /* direct_8x8_inference_flag    */
    if (br_get_bit(&br)) {
        /* frame_cropping_flag */
        uint32_t crop_left   = br_get_ue_golomb(&br);
        uint32_t crop_right  = br_get_ue_golomb(&br);
        uint32_t crop_top    = br_get_ue_golomb(&br);
        uint32_t crop_bottom = br_get_ue_golomb(&br);
        printf("H.264 SPS: cropping %d %d %d %d",
               crop_left, crop_top, crop_right, crop_bottom);

        sps->width -= 2*(crop_left + crop_right);
        if (frame_mbs_only)
            sps->height -= 2*(crop_top + crop_bottom);
        else
            sps->height -= 4*(crop_top + crop_bottom);

    }

    /* VUI parameters */
    sps->pixel_aspect.num = 0;
    if (br_get_bit(&br)) {
        /* vui_parameters_present flag */
        if (br_get_bit(&br)) {
            /* aspect_ratio_info_present */
            uint32_t aspect_ratio_idc = br_get_u8(&br);
            printf("H.264 SPS: aspect_ratio_idc %d", aspect_ratio_idc);

            if (aspect_ratio_idc == 255 /* Extended_SAR */) {

                sps->pixel_aspect.num = br_get_u16(&br); /* sar_width */
                sps->pixel_aspect.den = br_get_u16(&br); /* sar_height */
                printf("H.264 SPS: -> sar %dx%d", sps->pixel_aspect.num, sps->pixel_aspect.den);

            } else {

                static const mpeg_rational_t aspect_ratios[] =
                {
                /* page 213: */
                /* 0: unknown */
                    {
                    0, 1
                    },
                /* 1...16: */
                    {
                    1,  1
                    }, {
                        12, 11
                    }, {
                        10, 11
                    }, {
                        16, 11
                    }, {
                        40, 33
                    }, {
                        24, 11
                    }, {
                        20, 11
                    }, {
                        32, 11
                    }, 
                    {
                    80, 33
                    }, {
                        18, 11
                    }, {
                        15, 11
                    }, {
                        64, 33
                    }, {
                        160, 99
                    }, {
                        4,  3
                    }, {
                        3,  2
                    }, {
                        2,  1
                    }

                };

                if (aspect_ratio_idc < sizeof(aspect_ratios)/sizeof(aspect_ratios[0])) {

                    memcpy(&sps->pixel_aspect, &aspect_ratios[aspect_ratio_idc], sizeof(mpeg_rational_t));
                    printf("H.264 SPS: -> aspect ratio %d / %d", sps->pixel_aspect.num, sps->pixel_aspect.den);

                } else {

                    printf("H.264 SPS: aspect_ratio_idc out of range !");

                }

            }

        }

    }


    printf("H.264 SPS: -> video size %dx%d, aspect %d:%d",
           sps->width, sps->height, sps->pixel_aspect.num, sps->pixel_aspect.den);


    return 1;
}
CodySnow
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最权威的从H264码流中,解析出最全的SPS信息. 包括宽高等.
12-01
最权威的从H264码流中,解析出最全的SPS信息. 包括宽高等. 包含使用说明
通过SPS计算视频的宽高及帧率等参数
senfelai的博客
03-12 3506
1、H264 计算宽高根据标识不同有两种（都是从SPS字段中取值） 第一种: Width = (pic_width_in_mbs_minus1+1)*16; Height = (pic_height_in_map_units_minus1+1)*16; 第二种条件， frame_cropping_flag 值为1，frame_mbs_only_flag 为1，公式如下： (也可以认为统一使用下面的...
【FFmpeg】视频裁剪与拼接命令 ( 裁剪视频命令 | h264 编码的 SPS 和 PPS 数据 | 拼接视频 - 相同编码和相同容器格式的拼接 | 拼接视频 - 不同编码和容器格式的拼接测试 )
最新发布
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
04-17 1633
一、裁剪视频 1、裁剪视频命令 2、h264 编码的 SPS 和 PPS 数据 3、将裁剪的视频转为 ts 格式 4、将裁剪的视频转为 flv 格式 二、拼接视频 - 相同编码和相同容器格式的拼接测试 1、拼接视频命令 - mp4 格式 直接使用命令拼接 mp4 视频 - 拼接失败 指定文件列表拼接 mp4 视频 - 拼接成功但是播放不正常 2、拼接视频命令 - ts 格式 直接使用命令拼接 ts 视频 - 拼接成功 指定文件列表拼接 ts 视频 - 拼接成功 3、拼接视频命令 - flv 格式
从H264/H265码流sps中获取宽、高及帧率
翻肚鱼儿的博客
10-23 5586
在做码流分析时，图像分辨率、帧率这类的基本信息，当然不可少。本文介绍如何从NAL中计算到图像宽、高，还有分辨率。由于H264和H265有相似性，就在一起写了。 一、从码流获得宽、高 1、H264 宽高可从SPS字段计算得到，公式如下： Width = (pic_width_in_mbs_minus1+1)16; Height = (pic_height_in_map_units_minus1+1)16; 但以上是针对宽高是16的整数倍的情况，当不是16整数倍时，frame_cropping_flag
获取.h264视频宽高的方法
ice6015的专栏
08-10 4929
花了2个通宵终于搞定。（后面附上完整代码） http://write.blog.csdn.net/postedit/7852406 基础知识一：无符号哥伦布编码的解码原理以及C++实现（学习了http://www.cnblogs.com/acloud/archive/2011/12/26/2301623.html） 哥伦布编码的码字code_word由三部分组
h264编码概述七(SPS解析)
CrystalShaw的博客
03-07 2354
H.264标准协议中规定的SPS格式位于文档的7.3.2.1.1，如下图所示：根据《T-REC-H.264-201402-I!!PDF-E》的附件A.2定义，profiles有如下类型：profile_idc的值用来确定码流符合哪一种档次。profiles66778810011012244辅助profile_idc确定编码的profiles。constraint_set0_flag 等于1是指比特流遵从A.2.1节中的所有规定。
解析264SPS获取分辨率
weixin_33721344的博客
05-23 154
2019独角兽企业重金招聘Python工程师标准>>> ...
h264 sps pps详解
热门推荐
yuanbinquan的专栏
03-03 2万+
1、学习路线 step1、初步了解h264，了解h264数据帧分类和识别 step2、h264专业名词解析 step3、sps、pps帧语法定义 2、h264简介   3、h264名词解析   4、sps语法   5、pps语法
H264SPS计算宽高详解文档和相关代码
07-29
详细解析从H264中的SPS中获取宽高步骤，包括SPS每一个选项，包括代码实现和文档说明。注意.txt文件用Notepad++打开,否则因为对不齐可能看起来很乱
h264 sps帧解析出宽高等信息(c c++).rar
05-19
H264的sps帧解析出宽高等信息包含c/c++两种语言，可以使用。
h264sps解析获取分辨率
05-17
h264sps解析获取分辨率
解sps获取分辨率宽高
10-18
从网上找的代码，使用时候参考了，还不错里边有readme，比较详细的使用方法
从H264编码的sps解析出来图像参数
04-08
从h264图像编码里的sps nalu里解析出来图像的宽和高，级别等参数。
H264的sps和pps涵义解析
04-20
H.264 编码算法中 SPS 和 PPS 的涵义解析 H.264 编码算法中的序列参数集（Sequence Parameter Set，SPS）和图像参数集（Picture Parameter Set，PPS）是两个非常重要的概念，它们都是 H.264 编码算法中用于描述视频...
H264 sps pps解析
01-18
可在linux下编译通过的c++ sps pps解析类。读取文件（包中有测试文件），解析结果显示在打印里。可自行修改。
音视频系列--哥伦布编码和H264片段sps解析宽高信息
夏的专栏
12-20 950
H.264码流中的NALU进行了一个简单的划分，标出了NALU的类型和长度等信息。因为我们在解析SPS和PPS中要使用到指数哥伦布编码的解析，所以有必要了解一下指数哥伦布编码。 一、指数哥伦布编码（理论篇） 指数哥伦布码（Exponential-Golomb code， 即Exp-Golomb code）是熵编码的一种编码方式，正常来说，可以拓展为k阶，但是在H264中使用的是0阶指数哥伦布编码，在H.264中使用ue(v)表示0阶无符号指数哥伦布编码的解码过程，用se(v)表示0阶有符号指数哥伦布编码过
H.264 sequence parameter sets成员值含义学习笔记
jasonme的专栏
03-28 2611
sequence_parameter_set_rbsp_t结构体内成员及用途:1. unsigned profile_idc:它指的是码流对应的profile.1.1 基线profile(Baseline profile)遵循基线profile的码流应该遵循以下的约束:a) 只有I和P切片存在b) NAL单元流不应该有范围在2到4的nal_unit_type值,包括2和4.c) 序列参数集(sps
H.264 SPS、PPS详解
weixin_39399492的博客
10-06 3721
h.264 sps pps详解
H264码流中SPS PPS详解
holly的专栏
09-25 602
PPS SPS
H264 NALU解析
07-28
H264是一种视频编码标准，NALU（Network Abstraction Layer Unit）是H264视频流中的基本单元。在H264码流中，视频帧被分割成多个NALU进行传输。 要解析H264 NALU，你需要按照H264的规范进行处理。首先，你需要从码流中读取NALU的起始码（Start Code）来识别NALU的开始位置。NALU起始码是一个3字节的标识符（0x00 0x00 0x01），用于标记NALU的开始。 在读取到NALU的起始码后，你需要解析NALU头部信息。NALU头部包含了NALU的类型、大小等信息。NALU类型指示了该NALU的作用，例如关键帧、非关键帧等。NALU大小表示了该NALU数据的字节数。 解析完NALU头部后，你可以继续解析NALU的数据部分。根据NALU的类型不同，数据部分可能包含视频帧的压缩数据、参数集等。 需要注意的是，H264码流中的NALU可能有多个层次（例如SPS、PPS、Slice等），在解析时需要按照顺序进行处理，并根据需要提取所需的信息。 以上是对H264 NALU解析的简要介绍，具体实现时需要参考H264的规范以及相关库或工具的文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值