=====================================================HEVC源代码分析文章列表：【解码 -libavcodec HEVC 解码器】===================================================== 上篇文章概述了FFmpeg的libavcodec中HEVC（H.265）解码器的结构；从这篇文章开始，具体研究HEVC解码器的源代码。本文分析HEVC解码器中解析器（Parser）部分的源代码。这部分的代码用于分割HEVC的NALU，并且解析SPS、PPS、SEI等信息。解析HEVC码流（对应AVCodecParser结构体中的函数）和解码HEVC码流（对应AVCodec结构体中的函数）的时候都会调用该部分的代码完成相应的功能。函数调用关系图FFmpeg HEVC解析器（Parser）部分在整个HEVC解码器中的位置如下图所示。HEVC解析器（Parser）部分的源代码的调用关系如下图所示。从图中可以看出，HEVC解析器调用了parse_nal_units()，HEVC解码器调用了decode_nal_units()，而上述两个函数都调用了下面几个解析函数：ff_hevc_decode_nal_vps()：解析VPS。ff_hevc_decode_nal_sps()：解析SPS。ff_hevc_decode_nal_pps()：解析PPS。ff_hevc_decode_nal_sei()：解析SEI。下文将会分别这几个函数。ff_hevc_decoderff_hevc_decoder是HEVC解码器对应的AVCodec结构体。该结构体的定义位于libavcodec\hevc.c，如下所示。AVCodec ff_hevc_decoder = {
.long_name
= NULL_IF_CONFIG_SMALL(&HEVC (High Efficiency Video Coding)&),
= AVMEDIA_TYPE_VIDEO,
= AV_CODEC_ID_HEVC,
.priv_data_size
= sizeof(HEVCContext),
.priv_class
= &hevc_decoder_class,
= hevc_decode_init,
= hevc_decode_free,
= hevc_decode_frame,
= hevc_decode_flush,
.update_thread_context = hevc_update_thread_context,
.init_thread_copy
= hevc_init_thread_copy,
.capabilities
= CODEC_CAP_DR1 | CODEC_CAP_DELAY |
CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
= NULL_IF_CONFIG_SMALL(profiles),
};从源代码中可以看出，HEVC解码器的解码函数是hevc_decode_frame()。由于本文主要分析HEVC解析器，所以不对解码函数进行分析。在这里只需要知道hevc_decode_frame()调用了decode_nal_units()，而decode_nal_units()最终调用了ff_hevc_decode_nal_sps()等解析函数即可。ff_hevc_parserff_hevc_parser是HEVC解析器对应的AVCodecParser结构体。该结构体的定义位于libavcodec\hevc_parser.c，如下所示。AVCodecParser ff_hevc_parser = {
.codec_ids
= { AV_CODEC_ID_HEVC },
.priv_data_size = sizeof(HEVCParseContext),
.parser_init
= hevc_init,
.parser_parse
= hevc_parse,
.parser_close
= hevc_close,
= hevc_split,
};从源代码可以看出，HEVC解析器的初始化函数是hevc_init()，解析函数是hevc_parse()，关闭函数是hevc_close()。hevc_init()hevc_init()是HEVC解析器的初始化函数，该函数的定义如下所示。static int hevc_init(AVCodecParserContext *s)
HEVCContext
= &((HEVCParseContext *)s-&priv_data)-&h;
h-&HEVClc = av_mallocz(sizeof(HEVCLocalContext));
h-&skipped_bytes_pos_size = INT_MAX;
}可以看出hevc_init()简单地给内部成员变量分配了内存。hevc_close()hevc_close()是HEVC解析器的关闭函数，该函数的定义如下所示。static void hevc_close(AVCodecParserContext *s)
HEVCContext
= &((HEVCParseContext *)s-&priv_data)-&h;
ParseContext *pc = &((HEVCParseContext *)s-&priv_data)-&
av_freep(&h-&skipped_bytes_pos);
av_freep(&h-&HEVClc);
av_freep(&pc-&buffer);
for (i = 0; i & FF_ARRAY_ELEMS(h-&vps_list); i++)
av_buffer_unref(&h-&vps_list[i]);
for (i = 0; i & FF_ARRAY_ELEMS(h-&sps_list); i++)
av_buffer_unref(&h-&sps_list[i]);
for (i = 0; i & FF_ARRAY_ELEMS(h-&pps_list); i++)
av_buffer_unref(&h-&pps_list[i]);
av_buffer_unref(&h-&current_sps);
h-&sps = NULL;
for (i = 0; i & h-&nals_ i++)
av_freep(&h-&nals[i].rbsp_buffer);
av_freep(&h-&nals);
h-&nals_allocated = 0;
}可以看出hevc_close()释放了内部成员变量的内存。hevc_parse()hevc_parse()是HEVC解析器中最关键的解析函数。该函数的定义如下所示。/*
* 解析码流
* 注释：雷霄骅
* http://blog.csdn.net/leixiaohua1020
static int hevc_parse(AVCodecParserContext *s,
AVCodecContext *avctx,
const uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size)
ParseContext *pc = &((HEVCParseContext *)s-&priv_data)-&
//PARSER_FLAG_COMPLETE_FRAMES为1的时候说明传入的就是完整的1帧数据
//这时候不用再分割NALU
//PARSER_FLAG_COMPLETE_FRAMES为0的时候说明传入的是任意一段数据
//需要先分离出完整的NALU
if (s-&flags & PARSER_FLAG_COMPLETE_FRAMES) {
next = buf_
//分割NALU
//通过查找起始码0x000001的方法
next = hevc_find_frame_end(s, buf, buf_size);
if (ff_combine_frame(pc, next, &buf, &buf_size) & 0) {
*poutbuf_size = 0;
return buf_
//解析NALU内容（不解码）
parse_nal_units(s, avctx, buf, buf_size);
*poutbuf_size = buf_
从源代码可以看出，hevc_parse()主要做了两步工作：（1）判断传入的flags 中是否包含PARSER_FLAG_COMPLETE_FRAMES。如果包含，则说明传入的是完整的一帧数据，不作任何处理；如果不包含，则说明传入的不是完整的一帧数据而是任意一段HEVC数据，则需要调用hevc_find_frame_end()通过查找“起始码”（0x或者0x000001）的方法，分离出完整的一帧数据。（2）调用parse_nal_units()完成了NALU的解析工作。下面分别看一下这两步中的两个函数。hevc_find_frame_end()hevc_find_frame_end()用于从HEVC码流中分离出完整的NALU。该函数的定义位于libavcodec\hevc_parser.c，如下所示。/**
* Find the end of the current frame in the bitstream.
* @return the position of the first byte of the next frame, or END_NOT_FOUND
//分割NALU
static int hevc_find_frame_end(AVCodecParserContext *s, const uint8_t *buf,
int buf_size)
ParseContext *pc = &((HEVCParseContext *)s-&priv_data)-&
//一个一个字节进行处理
for (i = 0; i & buf_ i++) {
//state64可以存8个字节
//buf[i]存入state64
pc-&state64 = (pc-&state64 && 8) | buf[i];
//起始码定义#define START_CODE 0x000001
//state64右移24bit之后，再对比是否为起始码0x000001
if (((pc-&state64 && 3 * 8) & 0xFFFFFF) != START_CODE)
//找到起始码之后
* 此时state64内容如下：
Start Code
| NALU Header |
* |------|------|------|------|------|------|------|------|
| [t-5]| [t-4]| [t-3]| [t-2]| [t-1]|
* Start Code:
* 0x000001
* NALU Header:
* forbidden_zero_bit: 1bit。取值0。
* nal_unit_type: 6 bit。NALU类型。
* nuh_layer_id: 6 bit。目前取值为0（保留以后使用）.
* nuh_temporal_id_plus1: 3 bit。减1后为NALU时域层标识号TemporalID。
//state64右移16bit之后，state64最低字节为起始码后面的1Byte。即为NALU Header的前一个字节
//NALU Header的前一个字节中，第1bit为forbidden_zero_bit，取值为0；
//2-7bit为nal_unit_type；第8bit为nuh_layer_id，取值为0。
//在这里state64右移(16+1)bit，然后相与0x3F()
//即得到了nal_unit_type
nut = (pc-&state64 && 2 * 8 + 1) & 0x3F;
// Beginning of access unit
if ((nut &= NAL_VPS && nut &= NAL_AUD) || nut == NAL_SEI_PREFIX ||
(nut &= 41 && nut &= 44) || (nut &= 48 && nut &= 55)) {
if (pc-&frame_start_found) {
pc-&frame_start_found = 0;
//返回起始码开始位置
return i - 5;
} else if (nut &= NAL_RASL_R ||
(nut &= NAL_BLA_W_LP && nut &= NAL_CRA_NUT)) {
int first_slice_segment_in_pic_flag = buf[i] && 7;
if (first_slice_segment_in_pic_flag) {
if (!pc-&frame_start_found) {
pc-&frame_start_found = 1;
} else { // First slice of next frame found
pc-&frame_start_found = 0;
//返回起始码开始位置
return i - 5;
return END_NOT_FOUND;
从源代码可以看出，hevc_find_frame_end()使用ParseContext中的state64临时缓存读取的字节。state64是一个uint64_t类型的变量，一共可以存储8Byte的数据。函数体的for()循环一次读取一个字节，读取完成后将该字节放入state64变量中；接着与起始码“0x000001”进行比较，如果不相等则继续读取，如果相等的话则提取NALU Header中nal_unit_type信息做相应处理后返回起始码开始的位置。parse_nal_units()parse_nal_units()用于解析一些NALU（VPS、SPS、PPS）的信息。该函数的定义位于libavcodec\hevc_parser.c，如下所示。/**
* Parse NAL units of found picture and decode some basic information.
* @param s parser context.
* @param avctx codec context.
* @param buf buffer with field/frame data.
* @param buf_size size of the buffer.
* 解析NALU内容（不解码）
* 注释：雷霄骅
* http://blog.csdn.net/leixiaohua1020
static inline int parse_nal_units(AVCodecParserContext *s, AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
HEVCContext
= &((HEVCParseContext *)s-&priv_data)-&h;
GetBitContext *gb = &h-&HEVClc-&
SliceHeader
*sh = &h-&
const uint8_t *buf_end = buf + buf_
int state = -1,
/* set some sane default values */
s-&pict_type
= AV_PICTURE_TYPE_I;
s-&key_frame
s-&picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
h-&avctx =
if (!buf_size)
if (h-&nals_allocated & 1) {
HEVCNAL *tmp = av_realloc_array(h-&nals, 1, sizeof(*tmp));
return AVERROR(ENOMEM);
memset(h-&nals, 0, sizeof(*tmp));
h-&nals_allocated = 1;
nal = &h-&nals[0];
for (;;) {
int src_length,
buf = avpriv_find_start_code(buf, buf_end, &state);
if (--buf + 2 &= buf_end)
src_length = buf_end -
h-&nal_unit_type = (*buf && 1) & 0x3f;
h-&temporal_id
= (*(buf + 1) & 0x07) - 1;
if (h-&nal_unit_type &= NAL_CRA_NUT) {
// Do not walk the whole buffer just to decode slice segment header
if (src_length & 20)
src_length = 20;
//类似于H.264解析器中的ff_h264_decode_nal()
consumed = ff_hevc_extract_rbsp(h, buf, src_length, nal);
if (consumed & 0)
init_get_bits8(gb, nal-&data + 2, nal-&size);
* 几种NALU之间的关系
+--PPS1&--+
+--SPS1&--+
//解析不同种类的NALU
switch (h-&nal_unit_type) {
case NAL_VPS:
//VPS主要传输视频分级信息，有利于兼容可分级视频编码以及多视点视频编码
ff_hevc_decode_nal_vps(h);
case NAL_SPS:
ff_hevc_decode_nal_sps(h);
case NAL_PPS:
ff_hevc_decode_nal_pps(h);
case NAL_SEI_PREFIX:
case NAL_SEI_SUFFIX:
ff_hevc_decode_nal_sei(h);
case NAL_TRAIL_N:
case NAL_TRAIL_R:
case NAL_TSA_N:
case NAL_TSA_R:
case NAL_STSA_N:
case NAL_STSA_R:
case NAL_RADL_N:
case NAL_RADL_R:
case NAL_RASL_N:
case NAL_RASL_R:
case NAL_BLA_W_LP:
case NAL_BLA_W_RADL:
case NAL_BLA_N_LP:
case NAL_IDR_W_RADL:
case NAL_IDR_N_LP:
case NAL_CRA_NUT:
//解析 SS Header
//按照解码顺序，当前SS是否为第1个SS（Slice Segment）
sh-&first_slice_in_pic_flag = get_bits1(gb);
s-&picture_structure = h-&picture_
s-&field_order = h-&picture_
//IRAP, Intra Random Access Point, 随机介入点
//包括 IDR, CRA, BLA
if (IS_IRAP(h)) {
//设置关键帧
s-&key_frame = 1;
sh-&no_output_of_prior_pics_flag = get_bits1(gb);
//当前Slice引用的PPS的ID号
sh-&pps_id = get_ue_golomb(gb);
if (sh-&pps_id &= MAX_PPS_COUNT || !h-&pps_list[sh-&pps_id]) {
av_log(h-&avctx, AV_LOG_ERROR, &PPS id out of range: %d\n&, sh-&pps_id);
return AVERROR_INVALIDDATA;
h-&pps = (HEVCPPS*)h-&pps_list[sh-&pps_id]-&
if (h-&pps-&sps_id &= MAX_SPS_COUNT || !h-&sps_list[h-&pps-&sps_id]) {
av_log(h-&avctx, AV_LOG_ERROR, &SPS id out of range: %d\n&, h-&pps-&sps_id);
return AVERROR_INVALIDDATA;
if (h-&sps != (HEVCSPS*)h-&sps_list[h-&pps-&sps_id]-&data) {
h-&sps = (HEVCSPS*)h-&sps_list[h-&pps-&sps_id]-&
h-&vps = (HEVCVPS*)h-&vps_list[h-&sps-&vps_id]-&
//当前Slice不是第一个SS
if (!sh-&first_slice_in_pic_flag) {
int slice_address_
//当前SS是否依赖SS
if (h-&pps-&dependent_slice_segments_enabled_flag)
sh-&dependent_slice_segment_flag = get_bits1(gb);
sh-&dependent_slice_segment_flag = 0;
slice_address_length = av_ceil_log2_c(h-&sps-&ctb_width *
h-&sps-&ctb_height);
//当前SS中第一个CTU的地址
sh-&slice_segment_addr = get_bits(gb, slice_address_length);
if (sh-&slice_segment_addr &= h-&sps-&ctb_width * h-&sps-&ctb_height) {
av_log(h-&avctx, AV_LOG_ERROR, &Invalid slice segment address: %u.\n&,
sh-&slice_segment_addr);
return AVERROR_INVALIDDATA;
sh-&dependent_slice_segment_flag = 0;//独立SS
if (sh-&dependent_slice_segment_flag)//依赖SS
for (i = 0; i & h-&pps-&num_extra_slice_header_ i++)
skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
//slice type定义：
0: B Slice
1: P Slice
2: I Slice
sh-&slice_type = get_ue_golomb(gb);//
if (!(sh-&slice_type == I_SLICE || sh-&slice_type == P_SLICE ||
sh-&slice_type == B_SLICE)) {
av_log(h-&avctx, AV_LOG_ERROR, &Unknown slice type: %d.\n&,
sh-&slice_type);
return AVERROR_INVALIDDATA;
s-&pict_type = sh-&slice_type == B_SLICE ? AV_PICTURE_TYPE_B :
sh-&slice_type == P_SLICE ? AV_PICTURE_TYPE_P :
AV_PICTURE_TYPE_I;
if (h-&pps-&output_flag_present_flag)
sh-&pic_output_flag = get_bits1(gb);
if (h-&sps-&separate_colour_plane_flag)
sh-&colour_plane_id = get_bits(gb, 2);
if (!IS_IDR(h)) {
//不是IDR，则计算POC
sh-&pic_order_cnt_lsb = get_bits(gb, h-&sps-&log2_max_poc_lsb);
s-&output_picture_number = h-&poc = ff_hevc_compute_poc(h, sh-&pic_order_cnt_lsb);
s-&output_picture_number = h-&poc = 0;
if (h-&temporal_id == 0 &&
h-&nal_unit_type != NAL_TRAIL_N &&
h-&nal_unit_type != NAL_TSA_N &&
h-&nal_unit_type != NAL_STSA_N &&
h-&nal_unit_type != NAL_RADL_N &&
h-&nal_unit_type != NAL_RASL_N &&
h-&nal_unit_type != NAL_RADL_R &&
h-&nal_unit_type != NAL_RASL_R)
h-&pocTid0 = h-&
return 0; /* no need to evaluate the rest */
/* didn't find a picture! */
av_log(h-&avctx, AV_LOG_ERROR, &missing picture in access unit\n&);
return -1;
从源代码可以看出，parse_nal_units()根据nal_unit_type的不同，调用不同的解析函数进行处理。例如：a)解析VPS的时候调用ff_hevc_decode_nal_vps()b)解析SPS的时候调用ff_hevc_decode_nal_sps()c)解析PPS的时候调用ff_hevc_decode_nal_pps()d)解析SEI的时候调用ff_hevc_decode_nal_sei()e)解析SS Header的一部分信息。下文简单分析这几种NALU的解析函数。ff_hevc_decode_nal_vps()目前还没有研究过VPS，所以没有分析该函数。ff_hevc_decode_nal_sps()ff_hevc_decode_nal_sps()用于解析HEVC码流中的SPS。该函数的定义位于libavcodec\hevc_ps.c，如下所示。//解析SPS
int ff_hevc_decode_nal_sps(HEVCContext *s)
const AVPixFmtDescriptor *
GetBitContext *gb = &s-&HEVClc-&
int ret = 0;
unsigned int sps_id = 0;
int log2_diff_max_min_transform_block_
int bit_depth_chroma, start, vui_present, sublayer_ordering_
AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
if (!sps_buf)
return AVERROR(ENOMEM);
sps = (HEVCSPS*)sps_buf-&
av_log(s-&avctx, AV_LOG_DEBUG, &Decoding SPS\n&);
// Coded parameters
// 当前引用的VPS的ID
sps-&vps_id = get_bits(gb, 4);
if (sps-&vps_id &= MAX_VPS_COUNT) {
av_log(s-&avctx, AV_LOG_ERROR, &VPS id out of range: %d\n&, sps-&vps_id);
ret = AVERROR_INVALIDDATA;
if (!s-&vps_list[sps-&vps_id]) {
av_log(s-&avctx, AV_LOG_ERROR, &VPS %d does not exist\n&,
sps-&vps_id);
ret = AVERROR_INVALIDDATA;
//时域子层的最大数目
sps-&max_sub_layers = get_bits(gb, 3) + 1;
if (sps-&max_sub_layers & MAX_SUB_LAYERS) {
av_log(s-&avctx, AV_LOG_ERROR, &sps_max_sub_layers out of range: %d\n&,
sps-&max_sub_layers);
ret = AVERROR_INVALIDDATA;
skip_bits1(gb); // temporal_id_nesting_flag
if (parse_ptl(s, &sps-&ptl, sps-&max_sub_layers) & 0)
//当前SPS的ID
sps_id = get_ue_golomb_long(gb);
if (sps_id &= MAX_SPS_COUNT) {
av_log(s-&avctx, AV_LOG_ERROR, &SPS id out of range: %d\n&, sps_id);
ret = AVERROR_INVALIDDATA;
* chroma_format_idc色度取样格式
* 1: YUV420P
* 2: YUV422P
* 3: YUV444P
sps-&chroma_format_idc = get_ue_golomb_long(gb);
if (!(sps-&chroma_format_idc == 1 || sps-&chroma_format_idc == 2 || sps-&chroma_format_idc == 3)) {
avpriv_report_missing_feature(s-&avctx, &chroma_format_idc != {1, 2, 3}\n&);
ret = AVERROR_PATCHWELCOME;
//YUV444的时候，标记是否对3个分量单独编码
if (sps-&chroma_format_idc == 3)
sps-&separate_colour_plane_flag = get_bits1(gb);
if (sps-&separate_colour_plane_flag)
sps-&chroma_format_idc = 0;
sps-&width
= get_ue_golomb_long(gb);
sps-&height = get_ue_golomb_long(gb);
if ((ret = av_image_check_size(sps-&width,
sps-&height, 0, s-&avctx)) & 0)
//裁剪相关
if (get_bits1(gb)) { // pic_conformance_flag
//TODO: * 2 is only valid for 420
sps-&pic_conf_win.left_offset
= get_ue_golomb_long(gb) * 2;
sps-&pic_conf_win.right_offset
= get_ue_golomb_long(gb) * 2;
sps-&pic_conf_win.top_offset
= get_ue_golomb_long(gb) * 2;
sps-&pic_conf_win.bottom_offset = get_ue_golomb_long(gb) * 2;
if (s-&avctx-&flags2 & CODEC_FLAG2_IGNORE_CROP) {
av_log(s-&avctx, AV_LOG_DEBUG,
&discarding sps conformance window, &
&original values are l:%u r:%u t:%u b:%u\n&,
sps-&pic_conf_win.left_offset,
sps-&pic_conf_win.right_offset,
sps-&pic_conf_win.top_offset,
sps-&pic_conf_win.bottom_offset);
sps-&pic_conf_win.left_offset
sps-&pic_conf_win.right_offset
sps-&pic_conf_win.top_offset
sps-&pic_conf_win.bottom_offset = 0;
sps-&output_window = sps-&pic_conf_
//亮度像素的颜色位深
sps-&bit_depth
= get_ue_golomb_long(gb) + 8;
//色度像素的颜色位深
bit_depth_chroma = get_ue_golomb_long(gb) + 8;
if (bit_depth_chroma != sps-&bit_depth) {
av_log(s-&avctx, AV_LOG_ERROR,
&Luma bit depth (%d) is different from chroma bit depth (%d), &
&this is unsupported.\n&,
sps-&bit_depth, bit_depth_chroma);
ret = AVERROR_INVALIDDATA;
//根据颜色位深和色度采样格式设定pix_fmt
switch (sps-&bit_depth) {
if (sps-&chroma_format_idc == 1) sps-&pix_fmt = AV_PIX_FMT_YUV420P;
if (sps-&chroma_format_idc == 2) sps-&pix_fmt = AV_PIX_FMT_YUV422P;
if (sps-&chroma_format_idc == 3) sps-&pix_fmt = AV_PIX_FMT_YUV444P;
if (sps-&chroma_format_idc == 1) sps-&pix_fmt = AV_PIX_FMT_YUV420P9;
if (sps-&chroma_format_idc == 2) sps-&pix_fmt = AV_PIX_FMT_YUV422P9;
if (sps-&chroma_format_idc == 3) sps-&pix_fmt = AV_PIX_FMT_YUV444P9;
if (sps-&chroma_format_idc == 1) sps-&pix_fmt = AV_PIX_FMT_YUV420P10;
if (sps-&chroma_format_idc == 2) sps-&pix_fmt = AV_PIX_FMT_YUV422P10;
if (sps-&chroma_format_idc == 3) sps-&pix_fmt = AV_PIX_FMT_YUV444P10;
if (sps-&chroma_format_idc == 1) sps-&pix_fmt = AV_PIX_FMT_YUV420P12;
if (sps-&chroma_format_idc == 2) sps-&pix_fmt = AV_PIX_FMT_YUV422P12;
if (sps-&chroma_format_idc == 3) sps-&pix_fmt = AV_PIX_FMT_YUV444P12;
av_log(s-&avctx, AV_LOG_ERROR,
&4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\n&);
ret = AVERROR_PATCHWELCOME;
desc = av_pix_fmt_desc_get(sps-&pix_fmt);
if (!desc) {
ret = AVERROR(EINVAL);
sps-&hshift[0] = sps-&vshift[0] = 0;
sps-&hshift[2] = sps-&hshift[1] = desc-&log2_chroma_w;
sps-&vshift[2] = sps-&vshift[1] = desc-&log2_chroma_h;
sps-&pixel_shift = sps-&bit_depth & 8;
//用于计算POC
sps-&log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
if (sps-&log2_max_poc_lsb & 16) {
av_log(s-&avctx, AV_LOG_ERROR, &log2_max_pic_order_cnt_lsb_minus4 out range: %d\n&,
sps-&log2_max_poc_lsb - 4);
ret = AVERROR_INVALIDDATA;
sublayer_ordering_info = get_bits1(gb);
start = sublayer_ordering_info ? 0 : sps-&max_sub_layers - 1;
for (i = i & sps-&max_sub_ i++) {
sps-&temporal_layer[i].max_dec_pic_buffering = get_ue_golomb_long(gb) + 1;
sps-&temporal_layer[i].num_reorder_pics
= get_ue_golomb_long(gb);
sps-&temporal_layer[i].max_latency_increase
= get_ue_golomb_long(gb) - 1;
if (sps-&temporal_layer[i].max_dec_pic_buffering & MAX_DPB_SIZE) {
av_log(s-&avctx, AV_LOG_ERROR, &sps_max_dec_pic_buffering_minus1 out of range: %d\n&,
sps-&temporal_layer[i].max_dec_pic_buffering - 1);
ret = AVERROR_INVALIDDATA;
if (sps-&temporal_layer[i].num_reorder_pics & sps-&temporal_layer[i].max_dec_pic_buffering - 1) {
av_log(s-&avctx, AV_LOG_WARNING, &sps_max_num_reorder_pics out of range: %d\n&,
sps-&temporal_layer[i].num_reorder_pics);
if (s-&avctx-&err_recognition & AV_EF_EXPLODE ||
sps-&temporal_layer[i].num_reorder_pics & MAX_DPB_SIZE - 1) {
ret = AVERROR_INVALIDDATA;
sps-&temporal_layer[i].max_dec_pic_buffering = sps-&temporal_layer[i].num_reorder_pics + 1;
if (!sublayer_ordering_info) {
for (i = 0; i & i++) {
sps-&temporal_layer[i].max_dec_pic_buffering = sps-&temporal_layer[start].max_dec_pic_
sps-&temporal_layer[i].num_reorder_pics
= sps-&temporal_layer[start].num_reorder_
sps-&temporal_layer[i].max_latency_increase
= sps-&temporal_layer[start].max_latency_
//亮度编码块-最小尺寸
sps-&log2_min_cb_size
= get_ue_golomb_long(gb) + 3;
//亮度编码块-最大尺寸和最小尺寸插值
sps-&log2_diff_max_min_coding_block_size = get_ue_golomb_long(gb);
//亮度变换块-最小尺寸
sps-&log2_min_tb_size
= get_ue_golomb_long(gb) + 2;
//亮度变换块-最大尺寸和最小尺寸插值
log2_diff_max_min_transform_block_size
= get_ue_golomb_long(gb);
sps-&log2_max_trafo_size
= log2_diff_max_min_transform_block_size +
sps-&log2_min_tb_
if (sps-&log2_min_tb_size &= sps-&log2_min_cb_size) {
av_log(s-&avctx, AV_LOG_ERROR, &Invalid value for log2_min_tb_size&);
ret = AVERROR_INVALIDDATA;
//帧间预测变换块-最大划分深度
sps-&max_transform_hierarchy_depth_inter = get_ue_golomb_long(gb);
//帧内预测变换块-最大划分深度
sps-&max_transform_hierarchy_depth_intra = get_ue_golomb_long(gb);
//是否使用量化矩阵
sps-&scaling_list_enable_flag = get_bits1(gb);
if (sps-&scaling_list_enable_flag) {
set_default_scaling_list_data(&sps-&scaling_list);
if (get_bits1(gb)) {
ret = scaling_list_data(s, &sps-&scaling_list, sps);
if (ret & 0)
//是否使用非对称划分模式
sps-&amp_enabled_flag = get_bits1(gb);
//是否在去块效应滤波过程中使用样点自适应补偿SAO
sps-&sao_enabled
= get_bits1(gb);
//允许PCM编码
sps-&pcm_enabled_flag = get_bits1(gb);
//有关PCM编码的参数
if (sps-&pcm_enabled_flag) {
sps-&pcm.bit_depth
= get_bits(gb, 4) + 1;
sps-&pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
sps-&pcm.log2_min_pcm_cb_size = get_ue_golomb_long(gb) + 3;
sps-&pcm.log2_max_pcm_cb_size = sps-&pcm.log2_min_pcm_cb_size +
get_ue_golomb_long(gb);
if (sps-&pcm.bit_depth & sps-&bit_depth) {
av_log(s-&avctx, AV_LOG_ERROR,
&PCM bit depth (%d) is greater than normal bit depth (%d)\n&,
sps-&pcm.bit_depth, sps-&bit_depth);
ret = AVERROR_INVALIDDATA;
sps-&pcm.loop_filter_disable_flag = get_bits1(gb);
//短期参考num_short_term_ref_pic_set
sps-&nb_st_rps = get_ue_golomb_long(gb);
if (sps-&nb_st_rps & MAX_SHORT_TERM_RPS_COUNT) {
av_log(s-&avctx, AV_LOG_ERROR, &Too many short term RPS: %d.\n&,
sps-&nb_st_rps);
ret = AVERROR_INVALIDDATA;
for (i = 0; i & sps-&nb_st_ i++) {
if ((ret = ff_hevc_decode_short_term_rps(s, &sps-&st_rps[i],
sps, 0)) & 0)
//长期参考num_long_term_ref_pic_set
sps-&long_term_ref_pics_present_flag = get_bits1(gb);
if (sps-&long_term_ref_pics_present_flag) {
sps-&num_long_term_ref_pics_sps = get_ue_golomb_long(gb);
if (sps-&num_long_term_ref_pics_sps & 31U) {
av_log(0, AV_LOG_ERROR, &num_long_term_ref_pics_sps %d is out of range.\n&,
sps-&num_long_term_ref_pics_sps);
for (i = 0; i & sps-&num_long_term_ref_pics_ i++) {
sps-&lt_ref_pic_poc_lsb_sps[i]
= get_bits(gb, sps-&log2_max_poc_lsb);
sps-&used_by_curr_pic_lt_sps_flag[i] = get_bits1(gb);
//是否使用时域MV预测
sps-&sps_temporal_mvp_enabled_flag
= get_bits1(gb);
//滤波过程是否使用双线性插值
sps-&sps_strong_intra_smoothing_enable_flag = get_bits1(gb);
sps-&vui.sar = (AVRational){0, 1};
vui_present = get_bits1(gb);
if (vui_present)
decode_vui(s, sps);
if (get_bits1(gb)) { // sps_extension_flag
int sps_extension_flag[1];
for (i = 0; i & 1; i++)
sps_extension_flag[i] = get_bits1(gb);
skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
if (sps_extension_flag[0]) {
int extended_precision_processing_
int high_precision_offsets_enabled_
int cabac_bypass_alignment_enabled_
sps-&transform_skip_rotation_enabled_flag = get_bits1(gb);
sps-&transform_skip_context_enabled_flag
= get_bits1(gb);
sps-&implicit_rdpcm_enabled_flag = get_bits1(gb);
sps-&explicit_rdpcm_enabled_flag = get_bits1(gb);
extended_precision_processing_flag = get_bits1(gb);
if (extended_precision_processing_flag)
av_log(s-&avctx, AV_LOG_WARNING,
&extended_precision_processing_flag not yet implemented\n&);
sps-&intra_smoothing_disabled_flag
= get_bits1(gb);
high_precision_offsets_enabled_flag
= get_bits1(gb);
if (high_precision_offsets_enabled_flag)
av_log(s-&avctx, AV_LOG_WARNING,
&high_precision_offsets_enabled_flag not yet implemented\n&);
sps-&persistent_rice_adaptation_enabled_flag = get_bits1(gb);
cabac_bypass_alignment_enabled_flag
= get_bits1(gb);
if (cabac_bypass_alignment_enabled_flag)
av_log(s-&avctx, AV_LOG_WARNING,
&cabac_bypass_alignment_enabled_flag not yet implemented\n&);
if (s-&apply_defdispwin) {
sps-&output_window.left_offset
+= sps-&vui.def_disp_win.left_
sps-&output_window.right_offset
+= sps-&vui.def_disp_win.right_
sps-&output_window.top_offset
+= sps-&vui.def_disp_win.top_
sps-&output_window.bottom_offset += sps-&vui.def_disp_win.bottom_
if (sps-&output_window.left_offset & (0x1F && (sps-&pixel_shift)) &&
!(s-&avctx-&flags & CODEC_FLAG_UNALIGNED)) {
sps-&output_window.left_offset &= ~(0x1F && (sps-&pixel_shift));
av_log(s-&avctx, AV_LOG_WARNING, &Reducing left output window to %d &
&chroma samples to preserve alignment.\n&,
sps-&output_window.left_offset);
sps-&output_width
= sps-&width -
(sps-&output_window.left_offset + sps-&output_window.right_offset);
sps-&output_height = sps-&height -
(sps-&output_window.top_offset + sps-&output_window.bottom_offset);
if (sps-&output_width &= 0 || sps-&output_height &= 0) {
av_log(s-&avctx, AV_LOG_WARNING, &Invalid visible frame dimensions: %dx%d.\n&,
sps-&output_width, sps-&output_height);
if (s-&avctx-&err_recognition & AV_EF_EXPLODE) {
ret = AVERROR_INVALIDDATA;
av_log(s-&avctx, AV_LOG_WARNING,
&Displaying the whole video surface.\n&);
memset(&sps-&pic_conf_win, 0, sizeof(sps-&pic_conf_win));
memset(&sps-&output_window, 0, sizeof(sps-&output_window));
sps-&output_width
sps-&output_height
// Inferred parameters
// 推算出来的参数
sps-&log2_ctb_size = sps-&log2_min_cb_size +
sps-&log2_diff_max_min_coding_block_
sps-&log2_min_pu_size = sps-&log2_min_cb_size - 1;
sps-&ctb_width
= (sps-&width
+ (1 && sps-&log2_ctb_size) - 1) && sps-&log2_ctb_
sps-&ctb_height = (sps-&height + (1 && sps-&log2_ctb_size) - 1) && sps-&log2_ctb_
sps-&ctb_size
= sps-&ctb_width * sps-&ctb_
sps-&min_cb_width
= sps-&width
&& sps-&log2_min_cb_
sps-&min_cb_height = sps-&height && sps-&log2_min_cb_
sps-&min_tb_width
= sps-&width
&& sps-&log2_min_tb_
sps-&min_tb_height = sps-&height && sps-&log2_min_tb_
sps-&min_pu_width
= sps-&width
&& sps-&log2_min_pu_
sps-&min_pu_height = sps-&height && sps-&log2_min_pu_
sps-&tb_mask
= (1 && (sps-&log2_ctb_size - sps-&log2_min_tb_size)) - 1;
sps-&qp_bd_offset = 6 * (sps-&bit_depth - 8);
if (sps-&width
& ((1 && sps-&log2_min_cb_size) - 1) ||
sps-&height & ((1 && sps-&log2_min_cb_size) - 1)) {
av_log(s-&avctx, AV_LOG_ERROR, &Invalid coded frame dimensions.\n&);
if (sps-&log2_ctb_size & MAX_LOG2_CTB_SIZE) {
av_log(s-&avctx, AV_LOG_ERROR, &CTB size out of range: 2^%d\n&, sps-&log2_ctb_size);
if (sps-&max_transform_hierarchy_depth_inter & sps-&log2_ctb_size - sps-&log2_min_tb_size) {
av_log(s-&avctx, AV_LOG_ERROR, &max_transform_hierarchy_depth_inter out of range: %d\n&,
sps-&max_transform_hierarchy_depth_inter);
if (sps-&max_transform_hierarchy_depth_intra & sps-&log2_ctb_size - sps-&log2_min_tb_size) {
av_log(s-&avctx, AV_LOG_ERROR, &max_transform_hierarchy_depth_intra out of range: %d\n&,
sps-&max_transform_hierarchy_depth_intra);
if (sps-&log2_max_trafo_size & FFMIN(sps-&log2_ctb_size, 5)) {
av_log(s-&avctx, AV_LOG_ERROR,
&max transform block size out of range: %d\n&,
sps-&log2_max_trafo_size);
if (get_bits_left(gb) & 0) {
av_log(s-&avctx, AV_LOG_ERROR,
&Overread SPS by %d bits\n&, -get_bits_left(gb));
if (s-&avctx-&debug & FF_DEBUG_BITSTREAM) {
av_log(s-&avctx, AV_LOG_DEBUG,
&Parsed SPS: id %d; coded wxh: %dx%d; &
&cropped wxh: %dx%d; pix_fmt: %s.\n&,
sps_id, sps-&width, sps-&height,
sps-&output_width, sps-&output_height,
av_get_pix_fmt_name(sps-&pix_fmt));
/* check if this is a repeat of an already parsed SPS, then keep the
* original one.
* otherwise drop all PPSes that depend on it */
if (s-&sps_list[sps_id] &&
!memcmp(s-&sps_list[sps_id]-&data, sps_buf-&data, sps_buf-&size)) {
av_buffer_unref(&sps_buf);
for (i = 0; i & FF_ARRAY_ELEMS(s-&pps_list); i++) {
if (s-&pps_list[i] && ((HEVCPPS*)s-&pps_list[i]-&data)-&sps_id == sps_id)
av_buffer_unref(&s-&pps_list[i]);
if (s-&sps_list[sps_id] && s-&sps == (HEVCSPS*)s-&sps_list[sps_id]-&data) {
av_buffer_unref(&s-&current_sps);
s-&current_sps = av_buffer_ref(s-&sps_list[sps_id]);
if (!s-&current_sps)
s-&sps = NULL;
av_buffer_unref(&s-&sps_list[sps_id]);
s-&sps_list[sps_id] = sps_
av_buffer_unref(&sps_buf);
解析SPS源代码并不是很有“技术含量”。只要参考ITU-T的《HEVC标准》就可以理解了，不再做过多详细的分析。ff_hevc_decode_nal_pps()ff_hevc_decode_nal_pps()用于解析HEVC码流中的PPS。该函数的定义位于libavcodec\hevc_ps.c，如下所示。//解析PPS
int ff_hevc_decode_nal_pps(HEVCContext *s)
GetBitContext *gb = &s-&HEVClc-&
*sps = NULL;
int pic_area_in_
int log2_diff_ctb_min_tb_
int i, j, x, y, ctb_addr_rs, tile_
int ret = 0;
unsigned int pps_id = 0;
AVBufferRef *pps_
HEVCPPS *pps = av_mallocz(sizeof(*pps));
return AVERROR(ENOMEM);
pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
hevc_pps_free, NULL, 0);
if (!pps_buf) {
av_freep(&pps);
return AVERROR(ENOMEM);
av_log(s-&avctx, AV_LOG_DEBUG, &Decoding PPS\n&);
// Default values
pps-&loop_filter_across_tiles_enabled_flag = 1;
pps-&num_tile_columns
pps-&num_tile_rows
pps-&uniform_spacing_flag
pps-&disable_dbf
pps-&beta_offset
pps-&tc_offset
pps-&log2_max_transform_skip_block_size
// Coded parameters
//当前PPS的ID
pps_id = get_ue_golomb_long(gb);
if (pps_id &= MAX_PPS_COUNT) {
av_log(s-&avctx, AV_LOG_ERROR, &PPS id out of range: %d\n&, pps_id);
ret = AVERROR_INVALIDDATA;
//引用的SPS的ID
pps-&sps_id = get_ue_golomb_long(gb);
if (pps-&sps_id &= MAX_SPS_COUNT) {
av_log(s-&avctx, AV_LOG_ERROR, &SPS id out of range: %d\n&, pps-&sps_id);
ret = AVERROR_INVALIDDATA;
if (!s-&sps_list[pps-&sps_id]) {
av_log(s-&avctx, AV_LOG_ERROR, &SPS %u does not exist.\n&, pps-&sps_id);
ret = AVERROR_INVALIDDATA;
sps = (HEVCSPS *)s-&sps_list[pps-&sps_id]-&
//判断当前Slice是否包含依赖片
pps-&dependent_slice_segments_enabled_flag = get_bits1(gb);
pps-&output_flag_present_flag
= get_bits1(gb);
pps-&num_extra_slice_header_bits
= get_bits(gb, 3);
pps-&sign_data_hiding_flag = get_bits1(gb);
//在CABAC中用何种方式确定上下文变量的初始值
pps-&cabac_init_present_flag = get_bits1(gb);
//list0中参考图像数目的默认最大值
pps-&num_ref_idx_l0_default_active = get_ue_golomb_long(gb) + 1;
//list1中参考图像数目的默认最大值
pps-&num_ref_idx_l1_default_active = get_ue_golomb_long(gb) + 1;
//亮度分量QP的初始值
pps-&pic_init_qp_minus26 = get_se_golomb(gb);
pps-&constrained_intra_pred_flag = get_bits1(gb);
pps-&transform_skip_enabled_flag = get_bits1(gb);
pps-&cu_qp_delta_enabled_flag = get_bits1(gb);
pps-&diff_cu_qp_delta_depth
if (pps-&cu_qp_delta_enabled_flag)
pps-&diff_cu_qp_delta_depth = get_ue_golomb_long(gb);
if (pps-&diff_cu_qp_delta_depth & 0 ||
pps-&diff_cu_qp_delta_depth & sps-&log2_diff_max_min_coding_block_size) {
av_log(s-&avctx, AV_LOG_ERROR, &diff_cu_qp_delta_depth %d is invalid\n&,
pps-&diff_cu_qp_delta_depth);
ret = AVERROR_INVALIDDATA;
pps-&cb_qp_offset = get_se_golomb(gb);
if (pps-&cb_qp_offset & -12 || pps-&cb_qp_offset & 12) {
av_log(s-&avctx, AV_LOG_ERROR, &pps_cb_qp_offset out of range: %d\n&,
pps-&cb_qp_offset);
ret = AVERROR_INVALIDDATA;
pps-&cr_qp_offset = get_se_golomb(gb);
if (pps-&cr_qp_offset & -12 || pps-&cr_qp_offset & 12) {
av_log(s-&avctx, AV_LOG_ERROR, &pps_cr_qp_offset out of range: %d\n&,
pps-&cr_qp_offset);
ret = AVERROR_INVALIDDATA;
pps-&pic_slice_level_chroma_qp_offsets_present_flag = get_bits1(gb);
//P Slice是否使用加权预测
pps-&weighted_pred_flag
= get_bits1(gb);
//B Slice是否使用加权预测
pps-&weighted_bipred_flag = get_bits1(gb);
pps-&transquant_bypass_enable_flag
= get_bits1(gb);
//是否使用tile
pps-&tiles_enabled_flag
= get_bits1(gb);
pps-&entropy_coding_sync_enabled_flag = get_bits1(gb);
if (pps-&tiles_enabled_flag) {
//Tile的列数
pps-&num_tile_columns = get_ue_golomb_long(gb) + 1;
//Tile的行数
pps-&num_tile_rows
= get_ue_golomb_long(gb) + 1;
if (pps-&num_tile_columns == 0 ||
pps-&num_tile_columns &= sps-&width) {
av_log(s-&avctx, AV_LOG_ERROR, &num_tile_columns_minus1 out of range: %d\n&,
pps-&num_tile_columns - 1);
ret = AVERROR_INVALIDDATA;
if (pps-&num_tile_rows == 0 ||
pps-&num_tile_rows &= sps-&height) {
av_log(s-&avctx, AV_LOG_ERROR, &num_tile_rows_minus1 out of range: %d\n&,
pps-&num_tile_rows - 1);
ret = AVERROR_INVALIDDATA;
pps-&column_width = av_malloc_array(pps-&num_tile_columns, sizeof(*pps-&column_width));
pps-&row_height
= av_malloc_array(pps-&num_tile_rows,
sizeof(*pps-&row_height));
if (!pps-&column_width || !pps-&row_height) {
ret = AVERROR(ENOMEM);
pps-&uniform_spacing_flag = get_bits1(gb);
if (!pps-&uniform_spacing_flag) {
uint64_t sum = 0;
//每个Tile的宽度和高度
for (i = 0; i & pps-&num_tile_columns - 1; i++) {
pps-&column_width[i] = get_ue_golomb_long(gb) + 1;
+= pps-&column_width[i];
if (sum &= sps-&ctb_width) {
av_log(s-&avctx, AV_LOG_ERROR, &Invalid tile widths.\n&);
ret = AVERROR_INVALIDDATA;
pps-&column_width[pps-&num_tile_columns - 1] = sps-&ctb_width -
for (i = 0; i & pps-&num_tile_rows - 1; i++) {
pps-&row_height[i] = get_ue_golomb_long(gb) + 1;
+= pps-&row_height[i];
if (sum &= sps-&ctb_height) {
av_log(s-&avctx, AV_LOG_ERROR, &Invalid tile heights.\n&);
ret = AVERROR_INVALIDDATA;
pps-&row_height[pps-&num_tile_rows - 1] = sps-&ctb_height -
pps-&loop_filter_across_tiles_enabled_flag = get_bits1(gb);
pps-&seq_loop_filter_across_slices_enabled_flag = get_bits1(gb);
//是否存在去方块滤波的控制信息
pps-&deblocking_filter_control_present_flag = get_bits1(gb);
if (pps-&deblocking_filter_control_present_flag) {
pps-&deblocking_filter_override_enabled_flag = get_bits1(gb);
//是否使用去方块滤波
pps-&disable_dbf
= get_bits1(gb);
if (!pps-&disable_dbf) {
pps-&beta_offset = get_se_golomb(gb) * 2;
pps-&tc_offset = get_se_golomb(gb) * 2;
if (pps-&beta_offset/2 & -6 || pps-&beta_offset/2 & 6) {
av_log(s-&avctx, AV_LOG_ERROR, &pps_beta_offset_div2 out of range: %d\n&,
pps-&beta_offset/2);
ret = AVERROR_INVALIDDATA;
if (pps-&tc_offset/2 & -6 || pps-&tc_offset/2 & 6) {
av_log(s-&avctx, AV_LOG_ERROR, &pps_tc_offset_div2 out of range: %d\n&,
pps-&tc_offset/2);
ret = AVERROR_INVALIDDATA;
pps-&scaling_list_data_present_flag = get_bits1(gb);
if (pps-&scaling_list_data_present_flag) {
set_default_scaling_list_data(&pps-&scaling_list);
ret = scaling_list_data(s, &pps-&scaling_list, sps);
if (ret & 0)
pps-&lists_modification_present_flag = get_bits1(gb);
pps-&log2_parallel_merge_level
= get_ue_golomb_long(gb) + 2;
if (pps-&log2_parallel_merge_level & sps-&log2_ctb_size) {
av_log(s-&avctx, AV_LOG_ERROR, &log2_parallel_merge_level_minus2 out of range: %d\n&,
pps-&log2_parallel_merge_level - 2);
ret = AVERROR_INVALIDDATA;
pps-&slice_header_extension_present_flag = get_bits1(gb);
if (get_bits1(gb)) { // pps_extension_present_flag
int pps_range_extensions_flag = get_bits1(gb);
/* int pps_extension_7bits = */ get_bits(gb, 7);
if (sps-&ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps_range_extensions_flag) {
if ((ret = pps_range_extensions(s, pps, sps)) & 0)
// Inferred parameters
pps-&col_bd
= av_malloc_array(pps-&num_tile_columns + 1, sizeof(*pps-&col_bd));
pps-&row_bd
= av_malloc_array(pps-&num_tile_rows + 1,
sizeof(*pps-&row_bd));
pps-&col_idxX = av_malloc_array(sps-&ctb_width,
sizeof(*pps-&col_idxX));
if (!pps-&col_bd || !pps-&row_bd || !pps-&col_idxX) {
ret = AVERROR(ENOMEM);
if (pps-&uniform_spacing_flag) {
if (!pps-&column_width) {
pps-&column_width = av_malloc_array(pps-&num_tile_columns, sizeof(*pps-&column_width));
pps-&row_height
= av_malloc_array(pps-&num_tile_rows,
sizeof(*pps-&row_height));
if (!pps-&column_width || !pps-&row_height) {
ret = AVERROR(ENOMEM);
for (i = 0; i & pps-&num_tile_ i++) {
pps-&column_width[i] = ((i + 1) * sps-&ctb_width) / pps-&num_tile_columns -
(i * sps-&ctb_width) / pps-&num_tile_
for (i = 0; i & pps-&num_tile_ i++) {
pps-&row_height[i] = ((i + 1) * sps-&ctb_height) / pps-&num_tile_rows -
(i * sps-&ctb_height) / pps-&num_tile_
pps-&col_bd[0] = 0;
for (i = 0; i & pps-&num_tile_ i++)
pps-&col_bd[i + 1] = pps-&col_bd[i] + pps-&column_width[i];
pps-&row_bd[0] = 0;
for (i = 0; i & pps-&num_tile_ i++)
pps-&row_bd[i + 1] = pps-&row_bd[i] + pps-&row_height[i];
for (i = 0, j = 0; i & sps-&ctb_ i++) {
if (i & pps-&col_bd[j])
pps-&col_idxX[i] =
pic_area_in_ctbs
= sps-&ctb_width
* sps-&ctb_
pps-&ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs,
sizeof(*pps-&ctb_addr_rs_to_ts));
pps-&ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs,
sizeof(*pps-&ctb_addr_ts_to_rs));
pps-&tile_id
= av_malloc_array(pic_area_in_ctbs,
sizeof(*pps-&tile_id));
pps-&min_tb_addr_zs_tab = av_malloc_array((sps-&tb_mask+2) * (sps-&tb_mask+2), sizeof(*pps-&min_tb_addr_zs_tab));
if (!pps-&ctb_addr_rs_to_ts || !pps-&ctb_addr_ts_to_rs ||
!pps-&tile_id || !pps-&min_tb_addr_zs_tab) {
ret = AVERROR(ENOMEM);
for (ctb_addr_rs = 0; ctb_addr_rs & pic_area_in_ ctb_addr_rs++) {
= ctb_addr_rs % sps-&ctb_
= ctb_addr_rs / sps-&ctb_
int tile_x = 0;
int tile_y = 0;
for (i = 0; i & pps-&num_tile_ i++) {
if (tb_x & pps-&col_bd[i + 1]) {
for (i = 0; i & pps-&num_tile_ i++) {
if (tb_y & pps-&row_bd[i + 1]) {
for (i = 0; i & tile_x; i++)
val += pps-&row_height[tile_y] * pps-&column_width[i];
for (i = 0; i & tile_y; i++)
val += sps-&ctb_width * pps-&row_height[i];
val += (tb_y - pps-&row_bd[tile_y]) * pps-&column_width[tile_x] +
tb_x - pps-&col_bd[tile_x];
pps-&ctb_addr_rs_to_ts[ctb_addr_rs] =
pps-&ctb_addr_ts_to_rs[val]
= ctb_addr_
for (j = 0, tile_id = 0; j & pps-&num_tile_ j++)
for (i = 0; i & pps-&num_tile_ i++, tile_id++)
for (y = pps-&row_bd[j]; y & pps-&row_bd[j + 1]; y++)
for (x = pps-&col_bd[i]; x & pps-&col_bd[i + 1]; x++)
pps-&tile_id[pps-&ctb_addr_rs_to_ts[y * sps-&ctb_width + x]] = tile_
pps-&tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps-&tile_pos_rs));
if (!pps-&tile_pos_rs) {
ret = AVERROR(ENOMEM);
for (j = 0; j & pps-&num_tile_ j++)
for (i = 0; i & pps-&num_tile_ i++)
pps-&tile_pos_rs[j * pps-&num_tile_columns + i] = pps-&row_bd[j] * sps-&ctb_width + pps-&col_bd[i];
log2_diff_ctb_min_tb_size = sps-&log2_ctb_size - sps-&log2_min_tb_
pps-&min_tb_addr_zs = &pps-&min_tb_addr_zs_tab[1*(sps-&tb_mask+2)+1];
for (y = 0; y & sps-&tb_mask+2; y++) {
pps-&min_tb_addr_zs_tab[y*(sps-&tb_mask+2)] = -1;
pps-&min_tb_addr_zs_tab[y]
for (y = 0; y & sps-&tb_mask+1; y++) {
for (x = 0; x & sps-&tb_mask+1; x++) {
= x && log2_diff_ctb_min_tb_
= y && log2_diff_ctb_min_tb_
int ctb_addr_rs = sps-&ctb_width * tb_y + tb_x;
= pps-&ctb_addr_rs_to_ts[ctb_addr_rs] &&
(log2_diff_ctb_min_tb_size * 2);
for (i = 0; i & log2_diff_ctb_min_tb_ i++) {
int m = 1 &&
val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
pps-&min_tb_addr_zs[y * (sps-&tb_mask+2) + x] =
if (get_bits_left(gb) & 0) {
av_log(s-&avctx, AV_LOG_ERROR,
&Overread PPS by %d bits\n&, -get_bits_left(gb));
av_buffer_unref(&s-&pps_list[pps_id]);
s-&pps_list[pps_id] = pps_
av_buffer_unref(&pps_buf);
与解析SPS类似，解析PPS源代码并不是很有“技术含量”。只要参考ITU-T的《H.264标准》就可以理解了，不再做过多详细的分析。ff_hevc_decode_nal_sei()ff_hevc_decode_nal_sei()用于解析HEVC码流中的SEI。该函数的定义位于libavcodec\hevc_sei.c，如下所示。//解析SEI
int ff_hevc_decode_nal_sei(HEVCContext *s)
//解析SEI信息
ret = decode_nal_sei_message(s);
if (ret & 0)
return(AVERROR(ENOMEM));
} while (more_rbsp_data(&s-&HEVClc-&gb));
从源代码可以看出，ff_hevc_decode_nal_sei()在一个do while循环中调用了另外一个函数decode_nal_sei_message()解析SEI信息。decode_nal_sei_message()decode_nal_sei_message()用于解析SEI信息，它的定义如下。//解析SEI信息
static int decode_nal_sei_message(HEVCContext *s)
GetBitContext *gb = &s-&HEVClc-&
int payload_type = 0;
int payload_size = 0;
int byte = 0xFF;
av_log(s-&avctx, AV_LOG_DEBUG, &Decoding SEI\n&);
while (byte == 0xFF) {
= get_bits(gb, 8);
payload_type +=
byte = 0xFF;
while (byte == 0xFF) {
= get_bits(gb, 8);
payload_size +=
if (s-&nal_unit_type == NAL_SEI_PREFIX) {
if (payload_type == 256 /*&& s-&decode_checksum_sei*/) {
decode_nal_sei_decoded_picture_hash(s);
} else if (payload_type == 45) {
decode_nal_sei_frame_packing_arrangement(s);
} else if (payload_type == 47) {
decode_nal_sei_display_orientation(s);
} else if (payload_type == 1){
int ret = decode_pic_timing(s);
av_log(s-&avctx, AV_LOG_DEBUG, &Skipped PREFIX SEI %d\n&, payload_type);
skip_bits(gb, 8 * payload_size);
} else if (payload_type == 129){
active_parameter_sets(s);
av_log(s-&avctx, AV_LOG_DEBUG, &Skipped PREFIX SEI %d\n&, payload_type);
av_log(s-&avctx, AV_LOG_DEBUG, &Skipped PREFIX SEI %d\n&, payload_type);
skip_bits(gb, 8*payload_size);
} else { /* nal_unit_type == NAL_SEI_SUFFIX */
if (payload_type == 132 /* && s-&decode_checksum_sei */)
decode_nal_sei_decoded_picture_hash(s);
av_log(s-&avctx, AV_LOG_DEBUG, &Skipped SUFFIX SEI %d\n&, payload_type);
skip_bits(gb, 8 * payload_size);
从源代码可以看出，decode_nal_sei_message()根据不同的payload_type调用不同的函数进行处理，例如调用decode_nal_sei_decoded_picture_hash()，decode_nal_sei_frame_packing_arrangement()，decode_nal_sei_display_orientation()等等。雷霄骅http://blog.csdn.net/leixiaohua1020
版权声明：本文为博主原创文章，未经博主允许不得转载。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
姓名：雷霄骅
网名：leixiaohua1020
中国传媒大学-广播电视工程
中国传媒大学-数字电视技术
中国传媒大学-数字视频技术
[注：消息较多，不一定能一一回复，见谅]
主要从事与广播电视有关的视音频技术的研究。包括视音频质量评价，视音频编解码，流媒体，媒资检索等。
【SourceForge】【主】
【Github】
【开源中国】
欢迎转载本博客原创或翻译文章，但请声明出处，谢谢！
本群旨在为视音频技术同行方便交流提供一个平台。无论是实验室，电视台，互联网视频，安防，播放器，媒体中心等等都可以加入讨论。欢迎新手和大牛，多交流可以更快的进步~
本群成员容量为2000人，目前已经接近上限，为了给新成员入群讨论的机会，会定期清理不发言的用户，希望大家理解，谢谢支持！}