从Slice_Header学习H.264(一)--片头语法元素介绍

本文深入剖析H.264标准中的Slice_Header语法元素,涵盖slice_type、pic_parameter_set_id等关键元素,并详细解读与图像顺序、参考帧管理及量化参数相关的复杂机制。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

转: http://blog.youkuaiyun.com/newthinker_wei/article/details/8784685


从Slice_Header学习H.264

 

写在前面

$     H.264我是结合标准和毕厚杰的书一块学的。看句法语义时最是头疼,一大堆的元素,很需要耐心。标准中在介绍某个元素的语义时,经常会突然冒出与之相关的另一个变量,这个变量一般都在前文中讲过,但那么多变量怎么可能看一遍就记住?这时我只能去前面重新找这个变量再看一遍。没办法,H.264这个庞大的结构内部肯定是环环相扣的,各个部分联系紧密,所以刚开始看时要搞明白H.264的主要细节以及相互间的关系不是特别容易,尤其看到一大堆不认识的变量时,头大是难免的。所以做这个笔记时,介绍语法元素的过程中我特意将所有被牵扯到的其他变量都顺带解释一下,并记录下来他们是在哪个结构中出现的,这样方便大家也方便以后我自己翻阅。

 

$     对于序列参数集和图像参数集,初看时会发现这两个参数集中的很多元素不能立刻搞明白,这是因为很多细节性的东西你还没有了解,这些搞不明白的元素大都会在下面介绍片头语法元素的过程中被提到并解释,我们逐渐进入细节。不过在这之前,也要简单看一下两个参数集,最起码要了解他们的作用,以及把其中不涉及细节的那部分元素尽可能搞明白。

 

$     要了解H.264的全局结构以及一些重要细节,个人感觉slice_header是一个很好的切入点。这一系列笔记都是结合片头结构叙述的,前后会逐渐涉及到很多内容。标准中在介绍一些细节操作时,通常是只把计算方法用一大堆伪代码写出来,却没有直白的描述,要看明白很费劲;毕厚杰书中的插图可以帮大忙,结合图来看会容易一下,但毕厚杰的书中有些细节内容没有出现(估计是让读者自己看标准),而且有些不易搞懂的地方毕书中也是直接照搬的标准。本系列笔记中,我把我刚开始看时容易疑惑的部分按照我现在的理解重新描述了一遍,有些必要的地方也会照搬标准的伪代码,不过在照搬之前我会先做尽可能直白的描述,说明伪代码要干什么。我尽可能地将涉及到的所有细节都叙述到。

 

$     个人感觉初学时可以先不深究冗余片、滤波等,大概有个概念就行,否则由于搞不懂可能会越看越烦躁,降低学习效率,数据分割如果暂时不是特别清楚也可以先隔过去,这些都可以等对h.264比较熟悉后再回来看,那时也许就感觉容易多了。多片组将在本系列笔记的最后说到,所以中间遇到多片组时可以先把疑惑放一边。

 

 

一、slice头的主要元素介绍

 

       首先做一下说明,slice_header()如果存在,那片头中的语法元素 pic_parameter_set_id 、 frame_num、 field_pic_flag、bottom_field_flag、 idr_pic_id、 pic_order_cnt_lsb 、 delta_pic_order_cnt_bottom 、delta_pic_order_cnt[ 0 ] 、delta_pic_order_cnt[ 1 ] 、 sp_for_switch_flag 和 slice_group_change_cycle在同一个图像的所有条带头(条带=片=slice,条带头=片头=slice_header)中都应有相同的值。下面开始介绍各个元素。


$     slice_type           so easy,略过

$     pic_parameter_set_id          so easy,略过

 

$     片头的field_pic_flag  ,指定当前图像是帧编码(0)还是场编码(1)。这个元素在同一图像的所有片中应具有相同值。仅当序列参数集中的frame_mbs_only_flag为0时,这个元素才会存在在码流中。

       序列参数集中的句法元素frame_mbs_only_flag 和mb_adaptive_frame_field_flag再加上本句法元素共同决定图像的编码模式。

frame_mbs_only_flag

mb_adaptive_frame_field_flag

field_pic_flag

模式

1

不存在于码流中

不存在于码流中

帧编码

0

0

0

帧编码

0

0

1

场编码

0

1

0

帧场自适应(仅在此情形下,MbaffFrameFlag=1,

其他几种情况下MbaffFrameFlag都为0)

0

1

1

场编码

 

$     first_mb_in_slice   表示本片中第一个宏块的地址。

 (MbaffFrameFlag的取值参考上面的表格)

如果 MbaffFrameFlag 等于0,first_mb_in_slice就是该条带中第一个宏块的地址,并且first_mb_in_slice 的值应在0到 PicSizeInMbs– 1 的范围内(包括边界值)。

否则,first_mb_in_slice * 2  就是该条带中的第一个宏块地址,该宏块是该条带中第一个宏块对中的顶宏块,并且first_mb_in_slice 的值应该在 0 到 PicSizeInMbs/ 2 – 1 的范围内(包括边界值)。

其中,MbaffFrameFlag由序列参数集中的mb_adaptive_frame_field_flag指定,它等于1时表示使用帧场自适应模式,否则不使用;PicSizeInMbs表示图像的大小(以宏块为单位),由序列参数集中的pic_width_in_mbs_minus1、pic_height_in_map_units_minus1以及其他一些元素指定(这里就不详细说明了,因为这涉及到映射单元与宏块的对应关系,这到后面会说到)。


$     bottom_field_flag    指定当前的场是顶场还是底场。等于1 时表示当前图像是属于底场;等于 0 时表示当前图像是属于顶场。这个元素仅当field_pic_flag存在且为1时(说明当前片属于一个场图像),才会出现在码流中。

 

$     frame_num和PicNum(picnum不是slice头的元素)

对于非参考帧来说,它的frame_num 值在解码过程中是没有意义的,因为frame_num 值是参考帧特有的,它的主要作用是在该图像被其他图像引用作运动补偿的参考时提供一个标识。但 H.264 并没有在非参考帧图像中取消这一句法元素,原因是在 POC 的第二种和第三种解码方法中可以通过非参考帧的frame_num 值计算出他们的POC 值。

       frame_num是对帧编号的,也就是说如果在场模式下,同属一个场对的顶场和底场两个图像的frame_num 的值是相同的。

frame_num 是参考帧的标识,但是在解码器中,并不是直接引用的 frame_num 值,

而是由frame_num  进一步计算出来的变量 PicNum。MaxPicNum表征PicNum的最大值,

在场模式下MaxPicNum=2*MaxFrameNum,否则MaxPicNum =MaxFrameNum。其中,MaxFrameNum 由序列参数集中的log2_max_frame_num_minus4 确定。PicNum 和frame_num 一样,也是嵌在循环中,当达到这个最大值时,PicNum将从0 开始重新计数。

       CurrPicNum是当前图像的PicNum 值,在计算PicNum的过程中,当前图像的 PicNum 值是由frame_num 直接算出:

              -  如果field_pic_flag= 0 ,  CurrPicNum = frame_num.

-  否则, CurrPicNum= 2 * frame_num + 1.

 

$     序列参数集中的gaps_in_frame_num_value_allowed_flag等于0时,参考帧的frame_num都是连续的;如果等于1,这时若网络阻塞,编码器可以将编码后的若干图像丢弃,而不用另行通知解码器。在这种情况下,解码器必须有机制将缺失的frame_num 及所对应的图像填补,否则后续图像若将运动矢量指向缺失的图像将会产生解码错误。

 

$     idr_pic_id    IDR  图像的标识。不同的 IDR 图像有不同的idr_pic_id 值.在场模式下,IDR帧的两个场有相同的idr_pic_id值。idr_pic_id 的取值范围是 [0,65535],超出此范围时,以循环的方式重新开始计数。

 

$     POC相关:

       POC是指pic_order_cnt ,表示图像的播放顺序。POC的有三种计算方法,具体使用哪一种算法来计算POC,是由序列参数集中的pic_order_cnt_type指定的。在 POC 的第一种算法中是显式地传递POC 的值,而其他两种算法是通过frame_num 来映射POC 的值。三种算法下POC具体如何计算是在 标准2005/03的“8.2.1  图像顺序号的解码过程”章节中讲述的。

       pic_order_cnt_lsb:当序列参数集中的pic_order_cnt_type等于0时,本元素将出现在码流中。在POC 的第一种算法中,本元素“显式地传递了POC值”,准确的说,是POC值的lsb(具体参见标准8.2.1.1)。序列参数集中的log2_max_pic_order_cnt_lsb_minus4元素指定了编码pic_order_cnt_lsb的最大比特数。

       delta_pic_order_cnt_bottom:此元素用于POC的第一种算法。当序列参数集中的frame_mb_only_flag  不为 1时(图像序列中既可以有场图像又可以有帧图像),帧或帧场自适应图像中包含的两个场也必须有各自的 POC 值(供后续场图像作为参考图像)。通过此元素可在已解码的帧或帧场自适应图像的 POC 基础上新映射一个POC 值,并把它赋给底场。本元素存在条件:序列参数集中的pic_order_cnt_type等于0(使用第一种算法计算POC)、图像参数集中的pic_order_present_flag等于1(表示与图像顺序数有关的语法元素将出现于条带头中)、 片头的field_pic_flag存在且为0。

       delta_pic_order_cnt[  0 ], delta_pic_order_cnt[ 1 ]:这两个语法元素功能与delta_pic_order_cnt_bottom类似,只不过这两个元素用于POC的第二、三中算法(这里有点疑问,因为标准的语法表中,这两个元素仅在pic_order_cnt_type=1,即使用第二种POC算法时才出现,这意味着使用第三种POC算法的话,这俩元素就不存在了,既然不存在,还怎么用于第三种算法呢)。POC 的第二和第三种算法是从frame_num映射得来。delta_pic_order_cnt[0 ]的存在条件:序列参数集中的delta_pic_order_always_zero_flag等于0(等于1表示视频序列的条带头中没有delta_pic_order_cnt[0 ]  和delta_pic_order_cnt[ 1 ]  两个字段,它们的值都默认为0)、且pic_order_cnt_type  = 1(使用第二种POC算法);delta_pic_order_cnt[1 ]的存在条件:在delta_pic_order_cnt[  0 ]存在条件的基础上,图像参数集中的pic_order_present_flag等于1(表示与图像顺序数有关的语法元素将出现于条带头中)、 片头的field_pic_flag存在且为0。

       强调:上面提到图像参数集中的pic_order_present_flag等于1表示“与图像顺序数有关的语法元素将出现于条带头中”,但这个pic_order_present_flag并不是对所有与图像顺序相关的语法元素起作用,他只对条带(片)头中的delta_pic_order_cnt_bottom和delta_pic_order_cnt[ 1 ]起作用,而pic_order_cnt_lsb和delta_pic_order_cnt[ 0]则不受其制约。

 

$     redundant_pic_cnt         对于属于基本编码图像的条带和条带数据隔离带应等于0。对于一个冗余编码图像的编码条带或编码条带数据隔离带的redundant_pic_cnt  的值应大于0。当redundant_pic_cnt  在比特流中不存在时,应推定其值为0。redundant_pic_cnt  的值应该在0 到127 范围内;每个冗余编码图像都有一个对应的基本编码图像;对于冗余编码图像的编码条带(或数据分割),其通过pic_parameter_set_id指定的图像参数集,必须与对应的基本编码图像的编码条带指定的图像参数集具有相同的pic_order_present_flag值;标准里在介绍这个元素时用了将近一页的篇幅,内容还挺多,不想过现在关于冗余图像的部分,还是先不要看了,越看脑子越乱,先大概知道有这么回事儿,等以后对H.264熟悉了再回来看也许就容易多了。

元素存在条件:图像参数集中的redundant_pic_cnt_present_flag等于1(表示redundant_pic_cnt  语法元素将出现在条带头、图像参数集中指明(直接或与相应的数据分割块 A 关联)的数据分割块B 和数据分割块C 中)。对于数据分割,当这个条件符合时,不仅在A分割的码流中会出现redundant_pic_cnt(并不是直接出现,而是包含在分割A的片头结构中),还会在与之对应的B、C分割中也出现(直接出现)。

 

$     direct_spatial_mv_pred_flag  指出在B 图像的直接预测的模式下,用时间预测还是用空间预测。1 :空间预测(标准8.4.1.2节给出的亮度运动矢量B_Skip、B_Direct_16x16 和

B_Direct_8x8  将使用空间指引的模式来预期);0:时间预测(亮度运动矢量B_Skip、B_Direct_16x16 和 B_Direct_8x8  将使用临时指引的模式来预期)。

       存在条件:  片头的slice_type =B ,即当前片是B片。

 

$     关于List0和List1中的参考帧数目。

       在图像参数集中,已经通过num_ref_idx_l0_active_minus1和num_ref_idx_l1_active_minus1这两个元素指明了参考帧数目,num_ref_idx_l0_active_minus1  表示参考图像列表0 的最大参考索引号,该索引号将用来在一幅图像中num_ref_idx_active_override_flag 等于0 的条带使用列表0 预测时,解码该图像的这些条带。当MbaffFrameFlag 等于1 时(帧场自适应),num_ref_idx_l0_active_minus1 是帧宏块解码的最大索引号值,而2 * num_ref_idx_l0_active_minus1 + 1 是场宏块解码的最大索引号值。(帧场自适应模式下,一个宏块是帧宏块还是场宏块由slice_data语法中的mb_field_decoding_flag元素指定,每个宏块都可以单独指定自己的帧/场模式)。num_ref_idx_l0_active_minus1 的值应该在0 到31的范围内。num_ref_idx_l1_active_minus1具有类似的含义及规则,它表示的是List1中的最大参考索引号。

       为给某些特定图像更大的灵活度,在条带头中,可以重载这两个元素。

       num_ref_idx_active_override_flag:条带头中的这个元素用来决定是否对这两个元素进行重载,如果重载,那么条带头中将再次出现num_ref_idx_l0_active_minus1和num_ref_idx_l1_active_minus1这两个元素,它们将覆盖在图像参数集中的值。

 

 

$     ref_pic_list_reordering()  参考帧重排序。这个语法项目嵌套在条带头中,是条带头的一个子项目。

 

$     pred_weight_table() 预测加权表格。这个语法项目嵌套在条带头中,是条带头的一个子项目。此项目存在条件:

1. 如果当前片是P片或SP片,即slice_type = P  | | slice_type = SP:

如果图像参数集中的weighted_pred_flag为1(表示在P 和SP条带中应使用加权的预测),则pred_weight_table( )存在。

2. 如果当前片是B片,即slice_type= B:

如果图像参数集中的weighted_bipred_idc == 1,则pred_weight_table( )存在。关于weighted_bipred_idc ,它等于 0 时表示B 条带应该采用默认的加权预测;等于1 表示 B 条带应该采用具体指明的加权预测,只有这个情况下pred_weight_table( )才存在;等于2 表示B 条带应该采用隐含的加权预测。(疑问:“默认的”和“隐含的”,怎么感觉一个意思呢?)。weighted_bipred_idc的值应该在0 到2 之间(包括0 和2)。

 

$     dec_ref_pic_marking() 解码的参考图像标识。这个语法项目嵌套在条带头中,是条带头的一个子项目。此项目存在条件:NAL单元中的nal_ref_idc不为0。nal_ref_idc不为0时,表示NAL单元中包含一个序列参数集,或一个图像参数集,或一个参考图像条带,或一个参考图像的条带数据分割。由于本语法项包含在片头中,因此当前的NAL肯定是片或片的数据分割,也就是说,这个语法项存在的条件是:当前的NAL包含的是一个参考图像的条带或条带数据分割。

 

$     上面提到的这三个子语法项目将在后面详细介绍。

 

$     cabac_init_idc  代表一个表格序号,用于CABAC计算过程,表示用于决定关联变量的初始化过程中使用的初始化表格的序号,范围0 到2。(不太懂没关系,知道有这么个东西即可,等学CABAC时自然会明白)。

元素存在条件:图像参数集中的entropy_coding_mode_flag等于1 (表示采用cabac编码)、并且slice_type  != I  &&  slice_type !=  SI(表示当前片不是I片或SI片)。

 

$     slice_qp_delta  指出在用于当前片的所有宏块的量化参数的初始值,这个元素用于普通帧(非SI和SP的帧),他们量化时都是对预测残差变换后的系数进行量化。QPY。

             SliceQPY = 26 + pic_init_qp_minus26 +slice_qp_delta  

QPY的范围是  0 to 51 。代表的意义是量化间距。

H.264 中的量化参数是分图像参数集、片头、宏块头三层给出的,前两层各自给出一个偏移值,这个句法元素就是片层的偏移。

其中,pic_init_qp_minus26位于图像参数集中。

 

$     slice_qs_delta   与slice_qp_delta 的与语义相似,用在 SI 和SP中 (这两种片都是直接对预测值和实际值进行变换后对系数进行量化,而不是对残差值变换后的系数进行量化)。

QSY = 26 + pic_init_qs_minus26 + slice_qs_delta

QSY 值的范围是0  到51 。

              其中,pic_init_qs_minus26位于图像参数集中。

       与普通帧不同的是,在对SI和SP帧进行编解码时,需要两组量化系数(当然这两组系数可以一样):对预测重构块系数进行量化的量化参数 SPQP 与对预测残差系数进行量化的量化参数 PQP。当当前片是SI或SP片时,本元素对应的就是SPQP,而PQP对应的是slice_qp_delta。

       本元素存在条件:slice_type  = = SP  | |  slice_type = =  SI(当前片是SP片或SI片)。

 

$     sp_for_switch_flag  指出SP帧中的p 宏块的解码方式是否是switching 模式。什么是switching 模式?好吧,我也不懂,先记录一下,等具体学习SP帧的时候再考虑这个问题,现在没有必要为这个纠结太多。

       存在条件:slice_type  = =  SP(当前片是SP片)。

 

$     slice_group_change_cycle  这个用于多片组。当片组的类型是3, 4, 5(这三种类型的情况下,每个图像都只包含两个片组),由此句法元素和图像参数集中的slice_group_change_rate_minus1,可获得片组0中映射单元的数目。

关于映射单元,其具体涵义将在后面将FMO时提到,现在也可以先跳到该处浏览一下映射单元的定义。

片组0中映射单元的数目由下式得到。

MapUnitsInSliceGroup0 =  Min( slice_group_change_cycle *SliceGroupChangeRate, PicSizeInMapUnits )    

slice_group_change_cycle 由Ceil( Log2( PicSizeInMapUnits ÷ SliceGroupChangeRate + 1 ) ) 位比特表示。slice_group_change_cycle 值的范围是0  到Ceil( PicSizeInMapUnits÷ SliceGroupChangeRate )。

其中,SliceGroupChangeRate可由slice_group_change_rate_minus1得到;

而PicSizeInMapUnits = PicWidthInMbs * PicHeightInMapUnits ,等号右边的两个数都由序列参数集中的pic_width_in_mbs_minus1和pic_height_in_map_units_minus1得到,具体参见标准的7.4中关于序列参数集语意的讲解;Ceil(x)函数表示返回大于或者等于x的最小整数。

       元素存在条件:图像参数集中的num_slice_groups_minus1> 0、图像参数集中的slice_group_map_type是3、4或5。

 

$     滤波相关:

       H.264指定了一套算法可以在解码器端独立地计算图像中各边界的滤波强度进行滤波。除了解码器独立计算之外,编码器也可以传递句法元素来干涉滤波强度。

       disable_deblocking_filter_idc:表示去块效应滤波器的操作在经过条带的一些块边缘时是否会被废弃,并指定该滤波器针对哪个边缘被废弃。当条带头中不存在disable_deblocking_filter_idc 时,其值默认为0。disable_deblocking_filter_idc 的值应该在0 到2 范围内(包括0 和2)。元素存在条件:图像参数集中的deblocking_filter_control_present_flag等于1(deblocking_filter_control_present_flag  equal to 1 specifies that a set of synt axelements controlling the characteristics of the deblocking filter is present inthe slice header.)。

 

       slice_alpha_c0_offset_div2: 给出用于增强  α 和 tC0的偏移值

FilterOffsetA = slice_alpha_c0_offset_div2 << 1   

slice_alpha_c0_offset_div2  值的范围是 -6  到+6。

slice_beta_offset_div2: 给出用于增强 β和 tC0的偏移值

FilterOffsetB = slice_beta_offset_div2 << 1

slice_beta_offset_div2值的范围是 -6  到+6。

       这两个元素的存在条件:   disable_deblocking_filter_idc  !=  1。对于这几个元素,知道他们是跟方块滤波相关的就行了,等学习了方块滤波,这些元素的含义自然会明白。


int dec_cnk(DEC_CTX * ctx, COM_BITB * bitb, DEC_STAT * stat) { COM_BSR *bs; COM_PIC_HEADER *pic_header; COM_SQH * sqh; #if SVAC_SECURITY_PARAM_SET COM_SEC_PARA_SET* sec_para_set; #endif #if SVAC_AUTHENTICATION COM_AUTH_DATA* auth_data; #endif #if HLS_OPT_PPS COM_PIC_PARA_SET * pps; #endif COM_SH_EXT *shext; COM_CNKH *cnkh; int ret = COM_OK; if (stat) { com_mset(stat, 0, sizeof(DEC_STAT)); } bs = &ctx->bs; sqh = &ctx->info.sqh; #if HLS_OPT_PPS pps = &ctx->info.pps[ctx->info.pps_count]; #endif pic_header = &ctx->info.pic_header; shext = &ctx->info.shext; cnkh = &ctx->info.cnkh; #if SVAC_SECURITY_PARAM_SET sec_para_set = &ctx->info.sec_para_set; #endif #if SVAC_AUTHENTICATION auth_data = &ctx->info.auth_data; #endif /* set error status */ ctx->bs_err = (u8)bitb->err; #if TRACE_RDO_EXCLUDE_I if (pic_header->slice_type != SLICE_I) { #endif COM_TRACE_SET(1); #if TRACE_RDO_EXCLUDE_I } else { COM_TRACE_SET(0); } #endif /* bitstream reader initialization */ com_bsr_init(bs, bitb->addr, bitb->ssize, NULL); SET_SBAC_DEC(bs, &ctx->sbac_dec); #if SVAC_NAL if (bs->cur[3] == SVAC_SPS) #else if (bs->cur[3] == 0xB0) #endif { #if LIB_PIC_MIXBIN int need_update = COM_CT_CRR_SLICE == cnkh->ctype || COM_CT_CRR_SLICE_IMCOPLETE == cnkh->ctype #if SVAC_SECURITY_PARAM_SET || cnkh->ctype == COM_CT_SEC_PARA_SET #endif ; #endif #if HLS_OPT_PPS ctx->info.pps_count = 0; memset(ctx->info.pps, 0, sizeof(ctx->info.pps)); #endif cnkh->ctype = COM_CT_SQH; ret = dec_eco_sqh(bs, sqh); com_assert_rv(COM_SUCCEEDED(ret), ret); #if LIBVC_ON ctx->dpm.libvc_data->is_libpic_processing = sqh->library_stream_flag; ctx->dpm.libvc_data->library_picture_enable_flag = sqh->library_picture_enable_flag; #if LIBPIC_DISPLAY ctx->dpm.libvc_data->libpic_mode_index = sqh->library_picture_mode_index; #endif #endif #if EXTENSION_USER_DATA extension_and_user_data(ctx, bs, 0, sqh, pic_header); #endif #if LIB_PIC_MIXBIN if (sqh->library_stream_flag) { if (!ctx->libpic_init_flag) { ret = sequence_init(ctx, sqh); com_assert_rv(COM_SUCCEEDED(ret), ret); #if MULTI_LAYER_FRAMEWORK g_DOIPrev[ctx->layer_id] = g_CountDOICyCleTime[ctx->layer_id] = 0; #else g_DOIPrev = g_CountDOICyCleTime = 0; #endif ctx->libpic_init_flag = 1; ctx->init_flag = 1; } } else #endif if( !ctx->init_flag ) { ret = sequence_init(ctx, sqh); com_assert_rv(COM_SUCCEEDED(ret), ret); #if MULTI_LAYER_FRAMEWORK g_DOIPrev[ctx->layer_id] = g_CountDOICyCleTime[ctx->layer_id] = 0; #else g_DOIPrev = g_CountDOICyCleTime = 0; #endif ctx->init_flag = 1; } #if LIB_PIC_MIXBIN if (sqh->library_stream_flag && sqh->library_picture_mixbin_flag) { memcpy(&ctx->info.libpic_sqh, sqh, sizeof(COM_SQH)); ret = sequence_init(ctx, sqh); com_assert_rv(COM_SUCCEEDED(ret), ret); } else { memcpy(&ctx->info.normal_sqh, sqh, sizeof(COM_SQH)); if (need_update) { ret = sequence_init(ctx, sqh); com_assert_rv(COM_SUCCEEDED(ret), ret); } } #endif } #if !SVAC_NAL else if( bs->cur[3] == 0xB1 ) { ctx->init_flag = 0; cnkh->ctype = COM_CT_SEQ_END; } #endif #if HLS_OPT_PPS else if (bs->cur[3] == SVAC_PPS) { cnkh->ctype = COM_CT_PPS; ret = dec_eco_pps(bs, sqh, pps); ctx->info.pps_count++; assert(ctx->info.pps_count <= MAX_PPS_NUM); com_assert_rv(COM_SUCCEEDED(ret), ret); #if LIB_PIC_MIXBIN if (sqh->library_stream_flag) ctx->info.libpic_pps_idx = ctx->info.pps_count - 1; else ctx->info.normal_pps_idx = ctx->info.pps_count - 1; #endif } #endif #if SVAC_NAL #if HLS_OPT_PPS else if (bs->cur[3] == SVAC_PH) #else else if (bs->cur[3] == SVAC_PPS) #endif #else else if (bs->cur[3] == 0xB3 || bs->cur[3] == 0xB6) #endif { #if MULTI_LAYER_FRAMEWORK if (ctx->layer_id) { if (!ctx->init_flag) { ret = sequence_init(ctx, sqh); com_assert_rv(COM_SUCCEEDED(ret), ret); g_DOIPrev[ctx->layer_id] = g_CountDOICyCleTime[ctx->layer_id] = 0; ctx->init_flag = 1; if (ctx->layer_id && !sqh->sps_independent_layer_flag[ctx->layer_id]) { COM_PM* pm = &(ctx->dpm); int size; pm->pic_tmp[0] = com_pic_alloc(&pm->pa, &ret); pm->pic_tmp[1] = com_pic_alloc(&pm->pa, &ret); size = sizeof(s8) * ctx->info.f_scu * REFP_NUM; memset(pm->pic_tmp[0]->map_refi, -1, size); size = sizeof(s16) * ctx->info.f_scu * REFP_NUM * MV_D; memset(pm->pic_tmp[0]->map_mv, 0, size); #if CU_LEVEL_PRIVACY size = sizeof(u8) * ctx->info.f_scu; memset(pm->pic_tmp[0]->map_privacy, 0, size); #endif } } } #endif #if LIB_PIC_MIXBIN if (COM_CT_CRR_SLICE == cnkh->ctype || COM_CT_CRR_SLICE_IMCOPLETE == cnkh->ctype) { assert(sqh->library_picture_mixbin_flag == 1); memcpy(sqh, &ctx->info.normal_sqh, sizeof(COM_SQH)); ret = sequence_init(ctx, sqh); com_assert_rv(COM_SUCCEEDED(ret), ret); #if HLS_OPT_PPS pps = &ctx->info.pps[ctx->info.normal_pps_idx]; #endif ctx->dpm.libvc_data->is_libpic_processing = sqh->library_stream_flag; ctx->dpm.libvc_data->library_picture_enable_flag = sqh->library_picture_enable_flag; } #endif cnkh->ctype = COM_CT_PICTURE; /* decode slice header */ pic_header->low_delay = sqh->low_delay; int need_minus_256 = 0; #if HLS_OPT_PPS ret = dec_eco_pic_header(bs, ctx, &need_minus_256); #if MULTI_LAYER_FRAMEWORK assert(ctx->layer_id == pic_header->layer_id); if (ctx->layer_id && !sqh->sps_independent_layer_flag[ctx->layer_id] ) { DEC_CTX* ctx_b = (DEC_CTX*)ctx->ctx_b; upsample_base_pic(&ctx->dpm, ctx_b->pic, &ctx_b->info, &ctx->info, ctx_b->layer_id, ctx->layer_id); add_pic(&ctx_b->dpm, &ctx->dpm, ctx_b->pic, ctx_b->layer_id, &ctx_b->info, &ctx->info, ctx_b->info.pic_header.decode_order_index, ctx_b->ptr, ctx->refp, ctx->info.sqh.ref_layer_id[ctx->layer_id], ctx_b->info.poc); } #endif #else ret = dec_eco_pic_header(bs, pic_header, sqh, &need_minus_256); #endif if (need_minus_256) { com_picman_dpbpic_doi_minus_cycle_length( &ctx->dpm ); } #if HLS_OPT_PPS ctx->wq[0] = ctx->info.pps[pic_header->pic_pps_id].wq_4x4_matrix; ctx->wq[1] = ctx->info.pps[pic_header->pic_pps_id].wq_8x8_matrix; #else ctx->wq[0] = pic_header->wq_4x4_matrix; ctx->wq[1] = pic_header->wq_8x8_matrix; #endif if (!sqh->library_stream_flag) { com_picman_check_repeat_doi(&ctx->dpm, pic_header); } #if LIB_PIC_MIXBIN if (sqh->library_stream_flag && sqh->library_picture_mixbin_flag) { memcpy(&ctx->info.libpic_pic_header, pic_header, sizeof(COM_PIC_HEADER)); memcpy(ctx->libpic_pic_esao_params, ctx->info.pic_header.pic_esao_params, N_C * sizeof(ESAO_BLK_PARAM)); memcpy(ctx->libpic_pic_ccsao_params, ctx->info.pic_header.pic_ccsao_params, (N_C - 1) * sizeof(CCSAO_BLK_PARAM)); for (int comp_idx = 0; comp_idx < N_C; comp_idx++) { #if ALF_SHAPE int num_coef = (ctx->info.sqh.adaptive_leveling_filter_enhance_flag) ? ALF_MAX_NUM_COEF_SHAPE2 : ALF_MAX_NUM_COEF; #endif copy_alf_param(ctx->dec_alf->libpic_alf_picture_param[comp_idx], ctx->dec_alf->alf_picture_param[comp_idx] #if ALF_SHAPE , num_coef #if ALF_SHIFT + (int)ctx->info.sqh.adaptive_leveling_filter_enhance_flag #endif #endif ); } } #endif #if LIBPIC_DISPLAY ctx->dpm.libvc_data->libpic_index = pic_header->library_picture_index; #endif #if HIGH_LEVEL_PRIVACY memset(ctx->ctx_privacy_data.region_max_num, 0, sizeof(int) * 10); #endif #if EXTENSION_USER_DATA && WRITE_MD5_IN_USER_DATA extension_and_user_data(ctx, bs, 1, sqh, pic_header); #endif com_constrcut_ref_list_doi(pic_header); //add by Yuqun Fan, init rpl list at ph instead of sh #if HLS_RPL #if LIBVC_ON if (!sqh->library_stream_flag) #endif { ret = com_picman_refpic_marking_decoder(&ctx->dpm, pic_header); com_assert_rv(ret == COM_OK, ret); } com_cleanup_useless_pic_buffer_in_pm(&ctx->dpm); /* reference picture lists construction */ ret = com_picman_refp_rpl_based_init_decoder(&ctx->dpm, pic_header, ctx->refp); #if AWP if (ctx->info.pic_header.slice_type == SLICE_P || ctx->info.pic_header.slice_type == SLICE_B) { for (int i = 0; i < ctx->dpm.num_refp[REFP_0]; i++) { ctx->info.pic_header.ph_poc[REFP_0][i] = ctx->refp[i][REFP_0].ptr; } } if (ctx->info.pic_header.slice_type == SLICE_B) { for (int i = 0; i < ctx->dpm.num_refp[REFP_1]; i++) { ctx->info.pic_header.ph_poc[REFP_1][i] = ctx->refp[i][REFP_1].ptr; } } #endif #endif com_assert_rv(COM_SUCCEEDED(ret), ret); } #if SVAC_NAL else if ((bs->cur[3] == SVAC_IDR || bs->cur[3] == SVAC_NON_RAP || bs->cur[3] == SVAC_RAP_I #if LIB_PIC_MIXBIN || bs->cur[3] == SVAC_CRR_L || bs->cur[3] == SVAC_CRR_RL #if DISPLAY_L_NAL_TYPE || bs->cur[3] == SVAC_CRR_DP #endif #if LIB_PIC_ERR_TOL || bs->cur[3] == SVAC_CRR_DL #endif #endif ) && bs->cur[4] <= 0x8E) #else else if (bs->cur[3] >= 0x00 && bs->cur[3] <= 0x8E) #endif { #if LIB_PIC_MIXBIN #if DISPLAY_L_NAL_TYPE if (!sqh->library_stream_flag && (bs->cur[3] == SVAC_CRR_L || bs->cur[3] == SVAC_CRR_DP #if LIB_PIC_ERR_TOL || bs->cur[3] == SVAC_CRR_DL #endif )) #else if (!sqh->library_stream_flag && bs->cur[3] == SVAC_CRR_L) #endif { assert(sqh->library_picture_mixbin_flag == 1); memcpy(sqh, &ctx->info.libpic_sqh, sizeof(COM_SQH)); ret = sequence_init(ctx, sqh); com_assert_rv(COM_SUCCEEDED(ret), ret); #if HLS_OPT_PPS pps = &ctx->info.pps[ctx->info.libpic_pps_idx]; #endif ctx->dpm.libvc_data->is_libpic_processing = sqh->library_stream_flag; ctx->dpm.libvc_data->library_picture_enable_flag = sqh->library_picture_enable_flag; memcpy(pic_header, &ctx->info.libpic_pic_header, sizeof(COM_PIC_HEADER)); memcpy(pic_header->pic_esao_params, ctx->libpic_pic_esao_params, N_C * sizeof(ESAO_BLK_PARAM)); memcpy(pic_header->pic_ccsao_params, ctx->libpic_pic_ccsao_params, (N_C - 1) * sizeof(CCSAO_BLK_PARAM)); memcpy(ctx->pic_alf_on, ctx->libpic_pic_alf_on, N_C * sizeof(int)); for (int comp_idx = 0; comp_idx < N_C; comp_idx++) { #if ALF_SHAPE int num_coef = (ctx->info.sqh.adaptive_leveling_filter_enhance_flag) ? ALF_MAX_NUM_COEF_SHAPE2 : ALF_MAX_NUM_COEF; #endif copy_alf_param(ctx->dec_alf->alf_picture_param[comp_idx], ctx->dec_alf->libpic_alf_picture_param[comp_idx] #if ALF_SHAPE , num_coef #if ALF_SHIFT + (int)ctx->info.sqh.adaptive_leveling_filter_enhance_flag #endif #endif ); memcpy(ctx->info.pic_header.pic_esao_params[comp_idx].lcu_flag, ctx->libpic_esao_lcu_flag[comp_idx], ctx->info.f_lcu * sizeof(int)); if (comp_idx) memcpy(ctx->info.pic_header.pic_ccsao_params[comp_idx - 1].lcu_flag, ctx->libpic_ccsao_lcu_flag[comp_idx - 1], ctx->info.f_lcu * sizeof(int)); } for (int lcu_idx = 0; lcu_idx < ctx->info.f_lcu; lcu_idx++) { copy_sao_param_for_blk(ctx->sao_blk_params[lcu_idx], ctx->libpic_sao_blk_params[lcu_idx]); copy_sao_param_for_blk(ctx->rec_sao_blk_params[lcu_idx], ctx->libpic_rec_sao_blk_params[lcu_idx]); memcpy(ctx->dec_alf->alf_lcu_enabled[lcu_idx], ctx->dec_alf->libpic_alf_lcu_enabled[lcu_idx], N_C * sizeof(int)); } memcpy(ctx->map.map_pb_tb_part, ctx->map.libpic_map_pb_tb_part, ctx->info.f_scu * sizeof(u32)); memcpy(ctx->map.map_patch_idx, ctx->map.libpic_map_patch_idx, ctx->info.f_scu * sizeof(s8)); memcpy(ctx->map.map_split, ctx->map.libpic_map_split, ctx->info.f_lcu * sizeof(s8)* MAX_CU_DEPTH* NUM_BLOCK_SHAPE* MAX_CU_CNT_IN_LCU); mCabac_ws = MCABAC_SHIFT_I; mCabac_offset = (1 << (mCabac_ws - 1)); counter_thr1 = 0; counter_thr2 = COUNTER_THR_I; #if HLS_OPT_PPS ctx->wq[0] = ctx->info.pps[pic_header->pic_pps_id].wq_4x4_matrix; ctx->wq[1] = ctx->info.pps[pic_header->pic_pps_id].wq_8x8_matrix; #else ctx->wq[0] = pic_header->wq_4x4_matrix; ctx->wq[1] = pic_header->wq_8x8_matrix; #endif } #if DISPLAY_L_NAL_TYPE if (sqh->library_stream_flag && (bs->cur[3] != SVAC_CRR_L && bs->cur[3] != SVAC_CRR_DP #if LIB_PIC_ERR_TOL && bs->cur[3] != SVAC_CRR_DL #endif )) #else if (sqh->library_stream_flag && bs->cur[3] != SVAC_CRR_L) #endif { assert(sqh->library_picture_mixbin_flag == 1); memcpy(sqh, &ctx->info.normal_sqh, sizeof(COM_SQH)); ret = sequence_init(ctx, sqh); com_assert_rv(COM_SUCCEEDED(ret), ret); #if HLS_OPT_PPS pps = &ctx->info.pps[ctx->info.normal_pps_idx ]; #endif ctx->dpm.libvc_data->is_libpic_processing = sqh->library_stream_flag; ctx->dpm.libvc_data->library_picture_enable_flag = sqh->library_picture_enable_flag; } #if LIBPIC_DISPLAY int is_patch_l = sqh->library_stream_flag && sqh->library_picture_mixbin_flag && ctx->info.sqh.library_picture_mode_index != 1; #else int is_patch_l = sqh->library_stream_flag && sqh->library_picture_mixbin_flag; #endif #endif cnkh->ctype = COM_CT_SLICE; #if SVAC_NAL if (bs->cur[3] == SVAC_IDR) picman_reset_dpb(&ctx->dpm); #endif #if CU_LEVEL_PRIVACY COM_BSR *bs_privacy = &ctx->bs_privacy; com_bsr_init(bs_privacy, bitb->addr2, bitb->ssize2, NULL); SET_SBAC_DEC(bs_privacy, &ctx->sbac_dec_privacy); if (ctx->user_permission && ctx->info.pic_header.ph_privacy_on) { while (com_bsr_next(bs_privacy, 24) != 0x1) { ret = com_bsr_read(bs_privacy, 8); }; unsigned int nalu_type = 0, temporal_id = 0, layer_id = 0; dec_eco_nalu_header(bs_privacy, &nalu_type, &temporal_id, &layer_id); assert(nalu_type == SVAC_PRIVACY); #if TSVC_OPT assert(temporal_id == ctx->info.pic_header.temporal_id); #endif #if MULTI_LAYER_FRAMEWORK assert(layer_id == ctx->info.pic_header.layer_id); #endif } #endif #if HLS_OPT_PPS ret = dec_eco_patch_header(bs, sqh, &ctx->info.pps[pic_header->pic_pps_id], pic_header, shext, ctx->patch); #else ret = dec_eco_patch_header(bs, sqh, pic_header, shext, ctx->patch); #endif #if LIB_PIC_MIXBIN if (is_patch_l && ctx->patch->idx + 1 < ctx->patch->rows * ctx->patch->columns) cnkh->ctype = COM_CT_CRR_SLICE_IMCOPLETE; #if LIBPIC_DISPLAY else if (is_patch_l || (sqh->library_stream_flag && ctx->info.sqh.library_picture_mode_index == 1)) #else else if (is_patch_l) #endif cnkh->ctype = COM_CT_CRR_SLICE; #endif /* initialize slice */ ret = slice_init(ctx, ctx->core, pic_header); com_assert_rv(COM_SUCCEEDED(ret), ret); #if LIB_PIC_MIXBIN if (is_patch_l && ctx->patch->idx != 0) { ctx->pic = ctx->libpic_pic; } else { #endif /* get available frame buffer for decoded image */ ctx->pic = com_picman_get_empty_pic(&ctx->dpm, &ret); com_assert_rv(ctx->pic, ret); #if LIB_PIC_MIXBIN if (is_patch_l && ctx->patch->idx == 0) ctx->libpic_pic = ctx->pic; } #endif /* get available frame buffer for decoded image */ ctx->map.map_refi = ctx->pic->map_refi; ctx->map.map_mv = ctx->pic->map_mv; #if CU_LEVEL_PRIVACY ctx->map.map_privacy = ctx->pic->map_privacy; #endif #if CU_LEVEL_PRIVACY com_mset_x64a(ctx->map.map_privacy_pic_filter[0], 0, sizeof(COM_FILTER_SKIP)* ctx->info.pic_width* ctx->info.pic_height); com_mset_x64a(ctx->map.map_privacy_pic_filter[1], 0, sizeof(COM_FILTER_SKIP)* ctx->info.pic_width* ctx->info.pic_height); #endif /* decode slice layer */ #if HLS_OPT_PPS ret = dec_pic(ctx, ctx->core, sqh, &ctx->info.pps[pic_header->pic_pps_id], pic_header, shext); #else ret = dec_pic(ctx, ctx->core, sqh, pic_header, shext); #endif com_assert_rv(COM_SUCCEEDED(ret), ret); #if LIB_PIC_MIXBIN if (!is_patch_l || (is_patch_l && ctx->patch->idx + 1 == ctx->patch->rows * ctx->patch->columns)) { #endif /* deblocking filter */ #if HLS_OPT_PPS if (ctx->info.pps[ctx->info.pic_header.pic_pps_id].loop_filter_disable_flag == 0) #else if (ctx->info.pic_header.loop_filter_disable_flag == 0) #endif { ret = dec_deblock_avs2(ctx); com_assert_rv(COM_SUCCEEDED(ret), ret); } #if CCSAO if (ctx->info.pic_header.pic_ccsao_on[U_C-1] || ctx->info.pic_header.pic_ccsao_on[V_C-1]) { #if CCSAO_ENHANCEMENT copy_frame_for_ccsao(ctx->pic_ccsao[0], ctx->pic, Y_C); copy_frame_for_ccsao(ctx->pic_ccsao[0], ctx->pic, U_C); copy_frame_for_ccsao(ctx->pic_ccsao[0], ctx->pic, V_C); #else copy_frame_for_ccsao(ctx->pic_ccsao, ctx->pic, Y_C); #endif } #endif /* sao filter */ if (ctx->info.sqh.sample_adaptive_offset_enable_flag) { ret = dec_sao_avs2(ctx); com_assert_rv(ret == COM_OK, ret); } /* esao filter */ #if ESAO if (ctx->info.sqh.esao_enable_flag) { ret = dec_esao(ctx); com_assert_rv(ret == COM_OK, ret); } #endif #if CCSAO /* ccsao filter */ if (ctx->info.sqh.ccsao_enable_flag) { ret = dec_ccsao(ctx); com_assert_rv(ret == COM_OK, ret); } #endif /* ALF */ if (ctx->info.sqh.adaptive_leveling_filter_enable_flag) { ret = dec_alf_avs2(ctx, ctx->pic); com_assert_rv(COM_SUCCEEDED(ret), ret); } /* MD5 check for testing encoder-decoder match*/ if (ctx->use_pic_sign && ctx->pic_sign_exist) { ret = dec_picbuf_check_signature(ctx->pic, ctx->pic_sign #if CU_LEVEL_PRIVACY , ctx->user_permission || !ctx->info.pic_header.ph_privacy_on #endif ); com_assert_rv(COM_SUCCEEDED(ret), ret); ctx->pic_sign_exist = 0; /* reset flag */ } #if SVAC_UD_MD5_STREAM extension_and_user_data(ctx, bs, 1, sqh, pic_header); if (ctx->use_pic_sign && ctx->stream_sign_exist) { ctx->stream_sign_check_flag = 1; unsigned char * concat_buf = malloc((1024 * 1024 * 32)); com_assert_rv(concat_buf != NULL, -1); unsigned int stream_size = (unsigned int)((u8 *)bitb->addr3 - (u8 *)bitb->addr3_beg); u8 * stream_p = bitb->addr3_beg; unsigned char * buffer_p = concat_buf; while ((stream_p - (u8 *)bitb->addr3_beg) < stream_size) { unsigned int nal_size = 1; while (!(stream_p[nal_size + 0] == 0x00 && stream_p[nal_size + 1] == 0x00 && stream_p[nal_size + 2] == 0x00 && stream_p[nal_size + 3] == 0x01) && !(stream_p[nal_size + 0] == 0x00 && stream_p[nal_size + 1] == 0x00 && stream_p[nal_size + 2] == 0x01 && stream_p[nal_size - 1] != 0)) { if (!((stream_p - (u8 *)bitb->addr3_beg) < stream_size - nal_size - 4)) { nal_size += 4; break; } nal_size++; } if (stream_p[4] != (0x0c) && stream_p[3] != (0x0c) //sei && stream_p[4] != (0x20) && stream_p[3] != (0x20) //eocvs && stream_p[4] != (0x16) && stream_p[3] != (0x16) //eos #if SVAC_SECURITY_PARAM_SET && stream_p[4] != (0x52) && stream_p[3] != (0x52) //sec #endif #if SVAC_AUTHENTICATION && stream_p[4] != (0x14) && stream_p[3] != (0x14) //auth #endif ) { int start_code_len = 4; if (stream_p[0] == 0x00 && stream_p[1] == 0x00 && stream_p[2] == 0x01) { start_code_len = 3; } unsigned int raw_nal_size = nal_size - start_code_len; memcpy(buffer_p, stream_p + start_code_len, raw_nal_size); buffer_p += raw_nal_size; } stream_p += nal_size; } int stream_total_size = (int)(buffer_p - concat_buf); u8 stream_sign[16]; int ret = com_md5_stream(concat_buf, stream_total_size, stream_sign); com_assert_rv(COM_SUCCEEDED(ret), ret); if (com_mcmp(ctx->stream_sign, stream_sign, 16) != 0) { printf("\n stream signature check failed \n"); } com_assert_rv(com_mcmp(ctx->stream_sign, stream_sign, 16) == 0, COM_ERR_BAD_CRC); ctx->stream_sign_exist = 0; /* reset flag */ if (concat_buf) free(concat_buf); } bitb->addr3 = bitb->addr3_beg; #endif #if PIC_PAD_SIZE_L > 0 /* expand pixels to padding area */ dec_picbuf_expand(ctx, ctx->pic); #endif #if LIB_PIC_MIXBIN } if (is_patch_l) { memcpy(ctx->libpic_pic_alf_on, ctx->pic_alf_on, N_C * sizeof(int)); for (int lcu_idx = 0; lcu_idx < ctx->info.f_lcu; lcu_idx++) { copy_sao_param_for_blk(ctx->libpic_sao_blk_params[lcu_idx], ctx->sao_blk_params[lcu_idx]); copy_sao_param_for_blk(ctx->libpic_rec_sao_blk_params[lcu_idx], ctx->rec_sao_blk_params[lcu_idx]); memcpy(ctx->dec_alf->libpic_alf_lcu_enabled[lcu_idx], ctx->dec_alf->alf_lcu_enabled[lcu_idx], N_C * sizeof(int)); } for (int comp_idx = 0; comp_idx < N_C; comp_idx++) { memcpy(ctx->libpic_esao_lcu_flag[comp_idx], ctx->info.pic_header.pic_esao_params[comp_idx].lcu_flag, ctx->info.f_lcu * sizeof(int)); if (comp_idx) memcpy(ctx->libpic_ccsao_lcu_flag[comp_idx - 1], ctx->info.pic_header.pic_ccsao_params[comp_idx - 1].lcu_flag, ctx->info.f_lcu * sizeof(int)); } } #endif /* put decoded picture to DPB */ #if LIBVC_ON if (sqh->library_stream_flag #if LIB_PIC_MIXBIN && (!is_patch_l || (is_patch_l && (ctx->patch->idx + 1) == ctx->patch->rows * ctx->patch->columns)) #endif ) { ret = com_picman_put_libpic(&ctx->dpm, ctx->pic, ctx->info.pic_header.slice_type, ctx->ptr, pic_header->decode_order_index, ctx->info.pic_header.temporal_id, 1, ctx->refp, pic_header #if HLS_OPT_PPS , pps #endif ); } else #if LIB_PIC_MIXBIN if (!sqh->library_stream_flag) #endif #endif { ret = com_picman_put_pic(&ctx->dpm, ctx->pic, ctx->info.pic_header.slice_type, ctx->ptr, pic_header->decode_order_index , pic_header->picture_output_delay, ctx->info.pic_header.temporal_id, 1, ctx->refp #if OBMC #if CUDQP , pic_header #else , pic_header->picture_qp #endif #if HLS_OPT_PPS , pps #endif #endif ); #if LIBVC_ON assert((&ctx->dpm)->cur_pb_size + (&ctx->dpm)->cur_libpb_size <= sqh->max_dpb_size); #else assert((&ctx->dpm)->cur_pb_size <= sqh->max_dpb_size); #endif } com_assert_rv(COM_SUCCEEDED(ret), ret); } #if SVAC_NAL else if (bs->cur[3] == SVAC_EOS) { ctx->init_flag = 0; ctx->libpic_init_flag = 0; cnkh->ctype = COM_CT_SEQ_END; } else if (bs->cur[3] == SVAC_EOCVS) { ctx->init_flag = 0; ctx->libpic_init_flag = 0; cnkh->ctype = COM_CT_CVS_END; } #endif #if SVAC_SECURITY_PARAM_SET else if (bs->cur[3] == SVAC_SEC_PS) { dec_eco_sec_parameter_set_init(ctx, bs, pic_header, sec_para_set); ret = dec_eco_sec_parameter_set(ctx, bs, pic_header, sec_para_set); com_assert_rv(COM_SUCCEEDED(ret), ret); cnkh->ctype = COM_CT_SEC_PARA_SET; } #endif #if SVAC_AUTHENTICATION else if (bs->cur[3] == SVAC_AUTH_DATA) { dec_eco_auth_data_init(ctx, bs, pic_header, auth_data); ret = dec_eco_auth_data(ctx, bs, pic_header, auth_data); com_assert_rv(COM_SUCCEEDED(ret), ret); cnkh->ctype = COM_CT_AUTH; } #endif else { return COM_ERR_MALFORMED_BITSTREAM; } make_stat(ctx, cnkh->ctype, stat); return ret; }
最新发布
07-16
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值