=====================================================

HEVC源代码分析文章列表：

【解码 -libavcodec HEVC 解码器】

FFmpeg的HEVC解码器源代码简单分析：概述

FFmpeg的HEVC解码器源代码简单分析：解析器（Parser）部分

FFmpeg的HEVC解码器源代码简单分析：解码器主干部分

FFmpeg的HEVC解码器源代码简单分析：CTU解码（CTU Decode）部分-PU

FFmpeg的HEVC解码器源代码简单分析：CTU解码（CTU Decode）部分-TU

FFmpeg的HEVC解码器源代码简单分析：环路滤波（LoopFilter）

=====================================================

上篇文章概述了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_decoder

ff_hevc_decoder是HEVC解码器对应的AVCodec结构体。该结构体的定义位于libavcodec\hevc.c，如下所示。

AVCodec ff_hevc_decoder = {.name                  = "hevc",.long_name             = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),.type                  = AVMEDIA_TYPE_VIDEO,.id                    = AV_CODEC_ID_HEVC,.priv_data_size        = sizeof(HEVCContext),.priv_class            = &hevc_decoder_class,.init                  = hevc_decode_init,.close                 = hevc_decode_free,.decode                = hevc_decode_frame,.flush                 = 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,.profiles              = 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_parser

ff_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,.split          = hevc_split,
};

从源代码可以看出，HEVC解析器的初始化函数是hevc_init()，解析函数是hevc_parse()，关闭函数是hevc_close()。

hevc_init()

hevc_init()是HEVC解析器的初始化函数，该函数的定义如下所示。

static int hevc_init(AVCodecParserContext *s)
{HEVCContext  *h  = &((HEVCParseContext *)s->priv_data)->h;h->HEVClc = av_mallocz(sizeof(HEVCLocalContext));h->skipped_bytes_pos_size = INT_MAX;return 0;
}

可以看出hevc_init()简单地给内部成员变量分配了内存。

hevc_close()

hevc_close()是HEVC解析器的关闭函数，该函数的定义如下所示。

static void hevc_close(AVCodecParserContext *s)
{int i;HEVCContext  *h  = &((HEVCParseContext *)s->priv_data)->h;ParseContext *pc = &((HEVCParseContext *)s->priv_data)->pc;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_allocated; i++)av_freep(&h->nals[i].rbsp_buffer);av_freep(&h->nals);h->nals_allocated = 0;
}

可以看出hevc_close()释放了内部成员变量的内存。

hevc_parse()

hevc_parse()是HEVC解析器中最关键的解析函数。该函数的定义如下所示。

/** 解析码流** 注释：雷霄骅* leixiaohua1020@126.com* 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)
{int next;ParseContext *pc = &((HEVCParseContext *)s->priv_data)->pc;//PARSER_FLAG_COMPLETE_FRAMES为1的时候说明传入的就是完整的1帧数据//这时候不用再分割NALU//PARSER_FLAG_COMPLETE_FRAMES为0的时候说明传入的是任意一段数据//需要先分离出完整的NALUif (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {next = buf_size;} else {//分割NALU//通过查找起始码0x000001的方法next = hevc_find_frame_end(s, buf, buf_size);//合并if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {*poutbuf      = NULL;*poutbuf_size = 0;return buf_size;}}//解析NALU内容（不解码）parse_nal_units(s, avctx, buf, buf_size);*poutbuf      = buf;*poutbuf_size = buf_size;return next;
}

从源代码可以看出，hevc_parse()主要做了两步工作：

（1）判断传入的flags 中是否包含PARSER_FLAG_COMPLETE_FRAMES。如果包含，则说明传入的是完整的一帧数据，不作任何处理；如果不包含，则说明传入的不是完整的一帧数据而是任意一段HEVC数据，则需要调用hevc_find_frame_end()通过查找“起始码”（0x00000001或者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)
{int i;ParseContext *pc = &((HEVCParseContext *)s->priv_data)->pc;//一个一个字节进行处理for (i = 0; i < buf_size; i++) {int nut;//state64可以存8个字节//buf[i]存入state64pc->state64 = (pc->state64 << 8) | buf[i];//起始码定义#define START_CODE 0x000001//state64右移24bit之后，再对比是否为起始码0x000001if (((pc->state64 >> 3 * 8) & 0xFFFFFF) != START_CODE)continue;//找到起始码之后/** 此时state64内容如下：*               |      Start Code    | NALU Header |* |------|------|------|------|------|------|------|------|**               |  buf |  buf |  buf |  buf |  buf | buf  |*               | [t-5]| [t-4]| [t-3]| [t-2]| [t-1]|  [t] |** 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(00111111)//即得到了nal_unit_typenut = (pc->state64 >> 2 * 8 + 1) & 0x3F;// Beginning of access unitif ((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 foundpc->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内容（不解码）* 注释：雷霄骅* leixiaohua1020@126.com* http://blog.csdn.net/leixiaohua1020**/
static inline int parse_nal_units(AVCodecParserContext *s, AVCodecContext *avctx,const uint8_t *buf, int buf_size)
{HEVCContext   *h  = &((HEVCParseContext *)s->priv_data)->h;GetBitContext *gb = &h->HEVClc->gb;SliceHeader   *sh = &h->sh;const uint8_t *buf_end = buf + buf_size;int state = -1, i;HEVCNAL *nal;/* set some sane default values */s->pict_type         = AV_PICTURE_TYPE_I;s->key_frame         = 0;s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;h->avctx = avctx;if (!buf_size)return 0;if (h->nals_allocated < 1) {HEVCNAL *tmp = av_realloc_array(h->nals, 1, sizeof(*tmp));if (!tmp)return AVERROR(ENOMEM);h->nals = tmp;memset(h->nals, 0, sizeof(*tmp));h->nals_allocated = 1;}nal = &h->nals[0];for (;;) {int src_length, consumed;buf = avpriv_find_start_code(buf, buf_end, &state);if (--buf + 2 >= buf_end)break;src_length = buf_end - buf;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 headerif (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)return consumed;init_get_bits8(gb, nal->data + 2, nal->size);/** 几种NALU之间的关系*                           +--SS1*                           |*                 +--PPS1<--+*                 |         |*       +--SPS1<--+         +--SS2*       |         |* VPS<--+         +--PPS2*       |*       +--SPS2**///解析不同种类的NALUswitch (h->nal_unit_type) {case NAL_VPS://解析VPS//VPS主要传输视频分级信息，有利于兼容可分级视频编码以及多视点视频编码ff_hevc_decode_nal_vps(h);break;case NAL_SPS://解析SPSff_hevc_decode_nal_sps(h);break;case NAL_PPS://解析PPSff_hevc_decode_nal_pps(h);break;case NAL_SEI_PREFIX:case NAL_SEI_SUFFIX://解析SEIff_hevc_decode_nal_sei(h);break;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_struct;s->field_order = h->picture_struct;//IRAP, Intra Random Access Point, 随机介入点//包括 IDR, CRA, BLAif (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]->data;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]->data;h->vps = (HEVCVPS*)h->vps_list[h->sps->vps_id]->data;}//当前Slice不是第一个SSif (!sh->first_slice_in_pic_flag) {int slice_address_length;//当前SS是否依赖SSif (h->pps->dependent_slice_segments_enabled_flag)sh->dependent_slice_segment_flag = get_bits1(gb);elsesh->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;}} elsesh->dependent_slice_segment_flag = 0;//独立SSif (sh->dependent_slice_segment_flag)//依赖SSbreak;for (i = 0; i < h->pps->num_extra_slice_header_bits; i++)skip_bits(gb, 1); // slice_reserved_undetermined_flag[]//slice type定义：//  0: B Slice//  1: P Slice//  2: I Slicesh->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，则计算POCsh->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);} elses->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->poc;return 0; /* no need to evaluate the rest */}buf += consumed;}/* 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 *desc;GetBitContext *gb = &s->HEVClc->gb;int ret = 0;unsigned int sps_id = 0;int log2_diff_max_min_transform_block_size;int bit_depth_chroma, start, vui_present, sublayer_ordering_info;int i;HEVCSPS *sps;AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));if (!sps_buf)return AVERROR(ENOMEM);sps = (HEVCSPS*)sps_buf->data;av_log(s->avctx, AV_LOG_DEBUG, "Decoding SPS\n");// Coded parameters// 当前引用的VPS的IDsps->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;goto err;}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;goto err;}//时域子层的最大数目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;goto err;}skip_bits1(gb); // temporal_id_nesting_flagif (parse_ptl(s, &sps->ptl, sps->max_sub_layers) < 0)goto err;//当前SPS的IDsps_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;goto err;}/** chroma_format_idc色度取样格式* 0: Y* 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;goto err;}//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)goto err;//裁剪相关if (get_bits1(gb)) { // pic_conformance_flag//TODO: * 2 is only valid for 420sps->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_win;}//亮度像素的颜色位深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;goto err;}//根据颜色位深和色度采样格式设定pix_fmtswitch (sps->bit_depth) {case 8: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;break;case 9: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;break;case 10: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;break;case 12: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;break;default: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;goto err;}desc = av_pix_fmt_desc_get(sps->pix_fmt);if (!desc) {ret = AVERROR(EINVAL);goto err;}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;//用于计算POCsps->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;goto err;}sublayer_ordering_info = get_bits1(gb);start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;for (i = start; i < sps->max_sub_layers; 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;goto err;}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;goto err;}sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[i].num_reorder_pics + 1;}}if (!sublayer_ordering_info) {for (i = 0; i < start; i++) {sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[start].max_dec_pic_buffering;sps->temporal_layer[i].num_reorder_pics      = sps->temporal_layer[start].num_reorder_pics;sps->temporal_layer[i].max_latency_increase  = sps->temporal_layer[start].max_latency_increase;}}//亮度编码块-最小尺寸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_size;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;goto err;}//帧间预测变换块-最大划分深度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)goto err;}}//是否使用非对称划分模式sps->amp_enabled_flag = get_bits1(gb);//是否在去块效应滤波过程中使用样点自适应补偿SAOsps->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;goto err;}sps->pcm.loop_filter_disable_flag = get_bits1(gb);}//短期参考num_short_term_ref_pic_setsps->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;goto err;}for (i = 0; i < sps->nb_st_rps; i++) {if ((ret = ff_hevc_decode_short_term_rps(s, &sps->st_rps[i],sps, 0)) < 0)goto err;}//长期参考num_long_term_ref_pic_setsps->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);goto err;}for (i = 0; i < sps->num_long_term_ref_pics_sps; 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_flagint 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_flag;int high_precision_offsets_enabled_flag;int cabac_bypass_alignment_enabled_flag;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_offset;sps->output_window.right_offset  += sps->vui.def_disp_win.right_offset;sps->output_window.top_offset    += sps->vui.def_disp_win.top_offset;sps->output_window.bottom_offset += sps->vui.def_disp_win.bottom_offset;}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;goto err;}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->width;sps->output_height              = sps->height;}// Inferred parameters// 推算出来的参数sps->log2_ctb_size = sps->log2_min_cb_size +sps->log2_diff_max_min_coding_block_size;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_size;sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;sps->ctb_size   = sps->ctb_width * sps->ctb_height;sps->min_cb_width  = sps->width  >> sps->log2_min_cb_size;sps->min_cb_height = sps->height >> sps->log2_min_cb_size;sps->min_tb_width  = sps->width  >> sps->log2_min_tb_size;sps->min_tb_height = sps->height >> sps->log2_min_tb_size;sps->min_pu_width  = sps->width  >> sps->log2_min_pu_size;sps->min_pu_height = sps->height >> sps->log2_min_pu_size;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");goto err;}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);goto err;}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);goto err;}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);goto err;}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);goto err;}if (get_bits_left(gb) < 0) {av_log(s->avctx, AV_LOG_ERROR,"Overread SPS by %d bits\n", -get_bits_left(gb));goto err;}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);} else {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_buf;}return 0;err:av_buffer_unref(&sps_buf);return ret;
}

解析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->gb;HEVCSPS      *sps = NULL;int pic_area_in_ctbs;int log2_diff_ctb_min_tb_size;int i, j, x, y, ctb_addr_rs, tile_id;int ret = 0;unsigned int pps_id = 0;AVBufferRef *pps_buf;HEVCPPS *pps = av_mallocz(sizeof(*pps));if (!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                      = 1;pps->num_tile_rows                         = 1;pps->uniform_spacing_flag                  = 1;pps->disable_dbf                           = 0;pps->beta_offset                           = 0;pps->tc_offset                             = 0;pps->log2_max_transform_skip_block_size    = 2;// Coded parameters//当前PPS的IDpps_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;goto err;}//引用的SPS的IDpps->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;goto err;}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;goto err;}sps = (HEVCSPS *)s->sps_list[pps->sps_id]->data;//判断当前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   = 0;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;goto err;}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;goto err;}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;goto err;}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);//是否使用tilepps->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;goto err;}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;goto err;}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);goto err;}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;sum                 += pps->column_width[i];}if (sum >= sps->ctb_width) {av_log(s->avctx, AV_LOG_ERROR, "Invalid tile widths.\n");ret = AVERROR_INVALIDDATA;goto err;}pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;sum = 0;for (i = 0; i < pps->num_tile_rows - 1; i++) {pps->row_height[i] = get_ue_golomb_long(gb) + 1;sum               += pps->row_height[i];}if (sum >= sps->ctb_height) {av_log(s->avctx, AV_LOG_ERROR, "Invalid tile heights.\n");ret = AVERROR_INVALIDDATA;goto err;}pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;}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;goto err;}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;goto err;}}}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)goto err;}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;goto err;}pps->slice_header_extension_present_flag = get_bits1(gb);if (get_bits1(gb)) { // pps_extension_present_flagint 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)goto err;}}// Inferred parameterspps->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);goto err;}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);goto err;}for (i = 0; i < pps->num_tile_columns; i++) {pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -(i * sps->ctb_width) / pps->num_tile_columns;}for (i = 0; i < pps->num_tile_rows; i++) {pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -(i * sps->ctb_height) / pps->num_tile_rows;}}pps->col_bd[0] = 0;for (i = 0; i < pps->num_tile_columns; 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_rows; i++)pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];for (i = 0, j = 0; i < sps->ctb_width; i++) {if (i > pps->col_bd[j])j++;pps->col_idxX[i] = j;}/*** 6.5*/pic_area_in_ctbs     = sps->ctb_width    * sps->ctb_height;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);goto err;}for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {int tb_x   = ctb_addr_rs % sps->ctb_width;int tb_y   = ctb_addr_rs / sps->ctb_width;int tile_x = 0;int tile_y = 0;int val    = 0;for (i = 0; i < pps->num_tile_columns; i++) {if (tb_x < pps->col_bd[i + 1]) {tile_x = i;break;}}for (i = 0; i < pps->num_tile_rows; i++) {if (tb_y < pps->row_bd[i + 1]) {tile_y = i;break;}}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] = val;pps->ctb_addr_ts_to_rs[val]         = ctb_addr_rs;}for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)for (i = 0; i < pps->num_tile_columns; 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_id;pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));if (!pps->tile_pos_rs) {ret = AVERROR(ENOMEM);goto err;}for (j = 0; j < pps->num_tile_rows; j++)for (i = 0; i < pps->num_tile_columns; 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_size;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]    = -1;}for (y = 0; y < sps->tb_mask+1; y++) {for (x = 0; x < sps->tb_mask+1; x++) {int tb_x        = x >> log2_diff_ctb_min_tb_size;int tb_y        = y >> log2_diff_ctb_min_tb_size;int ctb_addr_rs = sps->ctb_width * tb_y + tb_x;int val         = 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_size; i++) {int m = 1 << i;val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);}pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;}}if (get_bits_left(gb) < 0) {av_log(s->avctx, AV_LOG_ERROR,"Overread PPS by %d bits\n", -get_bits_left(gb));goto err;}av_buffer_unref(&s->pps_list[pps_id]);s->pps_list[pps_id] = pps_buf;return 0;err:av_buffer_unref(&pps_buf);return ret;
}

与解析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)
{int ret;do {//解析SEI信息ret = decode_nal_sei_message(s);if (ret < 0)return(AVERROR(ENOMEM));} while (more_rbsp_data(&s->HEVClc->gb));return 1;
}

从源代码可以看出，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->gb;int payload_type = 0;int payload_size = 0;int byte = 0xFF;av_log(s->avctx, AV_LOG_DEBUG, "Decoding SEI\n");while (byte == 0xFF) {byte          = get_bits(gb, 8);payload_type += byte;}byte = 0xFF;while (byte == 0xFF) {byte          = get_bits(gb, 8);payload_size += byte;}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);return ret;} else if (payload_type == 129){active_parameter_sets(s);av_log(s->avctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", payload_type);} else {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);else {av_log(s->avctx, AV_LOG_DEBUG, "Skipped SUFFIX SEI %d\n", payload_type);skip_bits(gb, 8 * payload_size);}}return 1;
}

从源代码可以看出，decode_nal_sei_message()根据不同的payload_type调用不同的函数进行处理，例如调用decode_nal_sei_decoded_picture_hash()，decode_nal_sei_frame_packing_arrangement()，decode_nal_sei_display_orientation()等等。

雷霄骅
leixiaohua1020@126.com
http://blog.csdn.net/leixiaohua1020