h264: move the slice type variables into the per-slice context

libavcodec/dxva2_h264.c

@@ -223,8 +223,8 @@ static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice,
     slice->first_mb_in_slice     = (h->mb_y >> FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + h->mb_x;
     slice->NumMbsForSlice        = 0; /* XXX it is set once we have all slices */
     slice->BitOffsetToSliceData  = get_bits_count(&h->gb);
-    slice->slice_type            = ff_h264_get_slice_type(h);
-    if (h->slice_type_fixed)
+    slice->slice_type            = ff_h264_get_slice_type(sl);
+    if (sl->slice_type_fixed)
         slice->slice_type += 5;
     slice->luma_log2_weight_denom       = sl->luma_log2_weight_denom;
     slice->chroma_log2_weight_denom     = sl->chroma_log2_weight_denom;
@@ -278,7 +278,7 @@ static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice,
     slice->slice_qs_delta    = 0; /* XXX not implemented by Libav */
     slice->slice_qp_delta    = sl->qscale - h->pps.init_qp;
     slice->redundant_pic_cnt = h->redundant_pic_count;
-    if (h->slice_type == AV_PICTURE_TYPE_B)
+    if (sl->slice_type == AV_PICTURE_TYPE_B)
         slice->direct_spatial_mv_pred_flag = h->direct_spatial_mv_pred;
     slice->cabac_init_idc = h->pps.cabac ? h->cabac_init_idc : 0;
     if (h->deblocking_filter < 2)
@@ -417,6 +417,7 @@ static int dxva2_h264_decode_slice(AVCodecContext *avctx,
                                    uint32_t size)
 {
     const H264Context *h = avctx->priv_data;
+    const H264SliceContext *sl = &h->slice_ctx[0];
     struct dxva_context *ctx = avctx->hwaccel_context;
     const H264Picture *current_picture = h->cur_pic_ptr;
     struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
@@ -438,7 +439,7 @@ static int dxva2_h264_decode_slice(AVCodecContext *avctx,
                         &ctx_pic->pp, position, size);
     ctx_pic->slice_count++;
 
-    if (h->slice_type != AV_PICTURE_TYPE_I && h->slice_type != AV_PICTURE_TYPE_SI)
+    if (sl->slice_type != AV_PICTURE_TYPE_I && sl->slice_type != AV_PICTURE_TYPE_SI)
         ctx_pic->pp.wBitFields &= ~(1 << 15); /* Set IntraPicFlag to 0 */
     return 0;
 }

libavcodec/h264.c

@@ -1058,7 +1058,7 @@ int ff_pred_weight_table(H264Context *h, H264SliceContext *sl)
                 }
             }
         }
-        if (h->slice_type_nos != AV_PICTURE_TYPE_B)
+        if (sl->slice_type_nos != AV_PICTURE_TYPE_B)
             break;
     }
     sl->use_weight = sl->use_weight || sl->use_weight_chroma;
@@ -1259,7 +1259,7 @@ int ff_h264_set_parameter_from_sps(H264Context *h)
     return 0;
 }
 
-int ff_set_ref_count(H264Context *h)
+int ff_set_ref_count(H264Context *h, H264SliceContext *sl)
 {
     int ref_count[2], list_count;
     int num_ref_idx_active_override_flag, max_refs;
@@ -1268,8 +1268,8 @@ int ff_set_ref_count(H264Context *h)
     ref_count[0] = h->pps.ref_count[0];
     ref_count[1] = h->pps.ref_count[1];
 
-    if (h->slice_type_nos != AV_PICTURE_TYPE_I) {
-        if (h->slice_type_nos == AV_PICTURE_TYPE_B)
+    if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
+        if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
             h->direct_spatial_mv_pred = get_bits1(&h->gb);
         num_ref_idx_active_override_flag = get_bits1(&h->gb);
 
@@ -1277,14 +1277,14 @@ int ff_set_ref_count(H264Context *h)
             ref_count[0] = get_ue_golomb(&h->gb) + 1;
             if (ref_count[0] < 1)
                 return AVERROR_INVALIDDATA;
-            if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
+            if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
                 ref_count[1] = get_ue_golomb(&h->gb) + 1;
                 if (ref_count[1] < 1)
                     return AVERROR_INVALIDDATA;
             }
         }
 
-        if (h->slice_type_nos == AV_PICTURE_TYPE_B)
+        if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
             list_count = 2;
         else
             list_count = 1;
@@ -1570,9 +1570,9 @@ again:
                     (avctx->skip_frame < AVDISCARD_NONREF ||
                      hx->nal_ref_idc) &&
                     (avctx->skip_frame < AVDISCARD_BIDIR  ||
-                     hx->slice_type_nos != AV_PICTURE_TYPE_B) &&
+                     sl->slice_type_nos != AV_PICTURE_TYPE_B) &&
                     (avctx->skip_frame < AVDISCARD_NONKEY ||
-                     hx->slice_type_nos == AV_PICTURE_TYPE_I) &&
+                     sl->slice_type_nos == AV_PICTURE_TYPE_I) &&
                     avctx->skip_frame < AVDISCARD_ALL) {
                     if (avctx->hwaccel) {
                         ret = avctx->hwaccel->decode_slice(avctx,

libavcodec/h264.h

@@ -299,6 +299,11 @@ typedef struct H264Picture {
 typedef struct H264SliceContext {
     struct H264Context *h264;
 
+    int slice_num;
+    int slice_type;
+    int slice_type_nos;         ///< S free slice type (SI/SP are remapped to I/P)
+    int slice_type_fixed;
+
     int qscale;
     int chroma_qp[2];   // QPc
     int qp_thresh;      ///< QP threshold to skip loopfilter
@@ -424,11 +429,7 @@ typedef struct H264Context {
     uint32_t(*dequant4_coeff[6])[16];
     uint32_t(*dequant8_coeff[6])[64];
 
-    int slice_num;
     uint16_t *slice_table;      ///< slice_table_base + 2*mb_stride + 1
-    int slice_type;
-    int slice_type_nos;         ///< S free slice type (SI/SP are remapped to I/P)
-    int slice_type_fixed;
 
     // interlacing specific flags
     int mb_aff_frame;
@@ -759,7 +760,7 @@ void ff_h264_free_context(H264Context *h);
 /**
  * Reconstruct bitstream slice_type.
  */
-int ff_h264_get_slice_type(const H264Context *h);
+int ff_h264_get_slice_type(const H264SliceContext *sl);
 
 /**
  * Allocate tables.
@@ -770,7 +771,7 @@ int ff_h264_alloc_tables(H264Context *h);
 /**
  * Fill the default_ref_list.
  */
-int ff_h264_fill_default_ref_list(H264Context *h);
+int ff_h264_fill_default_ref_list(H264Context *h, H264SliceContext *sl);
 
 int ff_h264_decode_ref_pic_list_reordering(H264Context *h);
 void ff_h264_fill_mbaff_ref_list(H264Context *h, H264SliceContext *sl);
@@ -821,7 +822,7 @@ void ff_h264_init_cabac_states(H264Context *h, H264SliceContext *sl);
 void h264_init_dequant_tables(H264Context *h);
 
 void ff_h264_direct_dist_scale_factor(H264Context *const h);
-void ff_h264_direct_ref_list_init(H264Context *const h);
+void ff_h264_direct_ref_list_init(H264Context *const h, H264SliceContext *sl);
 void ff_h264_pred_direct_motion(H264Context *const h, H264SliceContext *sl,
                                 int *mb_type);
 
@@ -1023,7 +1024,7 @@ static av_always_inline void write_back_motion(H264Context *h,
     if (USES_LIST(mb_type, 1))
         write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 1);
 
-    if (h->slice_type_nos == AV_PICTURE_TYPE_B && CABAC(h)) {
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_B && CABAC(h)) {
         if (IS_8X8(mb_type)) {
             uint8_t *direct_table = &h->direct_table[4 * h->mb_xy];
             direct_table[1] = h->sub_mb_type[1] >> 1;
@@ -1056,7 +1057,7 @@ int ff_h264_set_parameter_from_sps(H264Context *h);
 void ff_h264_draw_horiz_band(H264Context *h, int y, int height);
 int ff_init_poc(H264Context *h, int pic_field_poc[2], int *pic_poc);
 int ff_pred_weight_table(H264Context *h, H264SliceContext *sl);
-int ff_set_ref_count(H264Context *h);
+int ff_set_ref_count(H264Context *h, H264SliceContext *sl);
 
 int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Context *h0);
 int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count);

libavcodec/h264_cabac.c

@@ -1267,7 +1267,7 @@ void ff_h264_init_cabac_states(H264Context *h, H264SliceContext *sl)
     const int8_t (*tab)[2];
     const int slice_qp = av_clip(sl->qscale - 6*(h->sps.bit_depth_luma-8), 0, 51);
 
-    if( h->slice_type_nos == AV_PICTURE_TYPE_I ) tab = cabac_context_init_I;
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_I) tab = cabac_context_init_I;
     else                                 tab = cabac_context_init_PB[h->cabac_init_idc];
 
     /* calculate pre-state */
@@ -1282,13 +1282,14 @@ void ff_h264_init_cabac_states(H264Context *h, H264SliceContext *sl)
     }
 }
 
-static int decode_cabac_field_decoding_flag(H264Context *h) {
+static int decode_cabac_field_decoding_flag(H264Context *h, H264SliceContext *sl)
+{
     const long mbb_xy = h->mb_xy - 2L*h->mb_stride;
 
     unsigned long ctx = 0;
 
     ctx += h->mb_field_decoding_flag & !!h->mb_x; //for FMO:(s->current_picture.mb_type[mba_xy] >> 7) & (h->slice_table[mba_xy] == h->slice_num);
-    ctx += (h->cur_pic.mb_type[mbb_xy] >> 7) & (h->slice_table[mbb_xy] == h->slice_num);
+    ctx += (h->cur_pic.mb_type[mbb_xy] >> 7) & (h->slice_table[mbb_xy] == sl->slice_num);
 
     return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
 }
@@ -1325,7 +1326,9 @@ static int decode_cabac_intra_mb_type(H264Context *h, H264SliceContext *sl,
     return mb_type;
 }
 
-static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
+static int decode_cabac_mb_skip(H264Context *h, H264SliceContext *sl,
+                                int mb_x, int mb_y)
+{
     int mba_xy, mbb_xy;
     int ctx = 0;
 
@@ -1333,13 +1336,13 @@ static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
         int mb_xy = mb_x + (mb_y&~1)*h->mb_stride;
         mba_xy = mb_xy - 1;
         if( (mb_y&1)
-            && h->slice_table[mba_xy] == h->slice_num
+            && h->slice_table[mba_xy] == sl->slice_num
             && MB_FIELD(h) == !!IS_INTERLACED( h->cur_pic.mb_type[mba_xy] ) )
             mba_xy += h->mb_stride;
         if (MB_FIELD(h)) {
             mbb_xy = mb_xy - h->mb_stride;
             if( !(mb_y&1)
-                && h->slice_table[mbb_xy] == h->slice_num
+                && h->slice_table[mbb_xy] == sl->slice_num
                 && IS_INTERLACED( h->cur_pic.mb_type[mbb_xy] ) )
                 mbb_xy -= h->mb_stride;
         }else
@@ -1350,12 +1353,12 @@ static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
         mbb_xy = mb_xy - (h->mb_stride << FIELD_PICTURE(h));
     }
 
-    if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP(h->cur_pic.mb_type[mba_xy] ))
+    if( h->slice_table[mba_xy] == sl->slice_num && !IS_SKIP(h->cur_pic.mb_type[mba_xy] ))
         ctx++;
-    if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP(h->cur_pic.mb_type[mbb_xy] ))
+    if( h->slice_table[mbb_xy] == sl->slice_num && !IS_SKIP(h->cur_pic.mb_type[mbb_xy] ))
         ctx++;
 
-    if( h->slice_type_nos == AV_PICTURE_TYPE_B )
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
         ctx += 13;
     return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
 }
@@ -1466,7 +1469,7 @@ static int decode_cabac_mb_ref(H264Context *h, H264SliceContext *sl, int list, i
     int ref  = 0;
     int ctx  = 0;
 
-    if( h->slice_type_nos == AV_PICTURE_TYPE_B) {
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
         if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
             ctx++;
         if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
@@ -1908,20 +1911,20 @@ int ff_h264_decode_mb_cabac(H264Context *h, H264SliceContext *sl)
     mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
 
     tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, h->mb_x, h->mb_y);
-    if( h->slice_type_nos != AV_PICTURE_TYPE_I ) {
+    if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
         int skip;
         /* a skipped mb needs the aff flag from the following mb */
         if (FRAME_MBAFF(h) && (h->mb_y & 1) == 1 && sl->prev_mb_skipped)
             skip = sl->next_mb_skipped;
         else
-            skip = decode_cabac_mb_skip( h, h->mb_x, h->mb_y );
+            skip = decode_cabac_mb_skip(h, sl, h->mb_x, h->mb_y );
         /* read skip flags */
         if( skip ) {
             if (FRAME_MBAFF(h) && (h->mb_y & 1) == 0) {
                 h->cur_pic.mb_type[mb_xy] = MB_TYPE_SKIP;
-                sl->next_mb_skipped = decode_cabac_mb_skip( h, h->mb_x, h->mb_y+1 );
+                sl->next_mb_skipped = decode_cabac_mb_skip(h, sl, h->mb_x, h->mb_y+1 );
                 if(!sl->next_mb_skipped)
-                    h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
+                    h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h, sl);
             }
 
             decode_mb_skip(h, sl);
@@ -1937,16 +1940,16 @@ int ff_h264_decode_mb_cabac(H264Context *h, H264SliceContext *sl)
     if (FRAME_MBAFF(h)) {
         if( (h->mb_y&1) == 0 )
             h->mb_mbaff =
-            h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
+            h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h, sl);
     }
 
     sl->prev_mb_skipped = 0;
 
     fill_decode_neighbors(h, sl, -(MB_FIELD(h)));
 
-    if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
         int ctx = 0;
-        assert(h->slice_type_nos == AV_PICTURE_TYPE_B);
+        assert(sl->slice_type_nos == AV_PICTURE_TYPE_B);
 
         if (!IS_DIRECT(sl->left_type[LTOP] - 1))
             ctx++;
@@ -1979,7 +1982,7 @@ int ff_h264_decode_mb_cabac(H264Context *h, H264SliceContext *sl)
         }
             partition_count= b_mb_type_info[mb_type].partition_count;
             mb_type=         b_mb_type_info[mb_type].type;
-    } else if( h->slice_type_nos == AV_PICTURE_TYPE_P ) {
+    } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
             /* P-type */
             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
@@ -1997,9 +2000,9 @@ int ff_h264_decode_mb_cabac(H264Context *h, H264SliceContext *sl)
         }
     } else {
         mb_type = decode_cabac_intra_mb_type(h, sl, 3, 1);
-        if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
+        if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
             mb_type--;
-        assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
+        assert(sl->slice_type_nos == AV_PICTURE_TYPE_I);
 decode_intra_mb:
         partition_count = 0;
         cbp= i_mb_type_info[mb_type].cbp;
@@ -2009,7 +2012,7 @@ decode_intra_mb:
     if(MB_FIELD(h))
         mb_type |= MB_TYPE_INTERLACED;
 
-    h->slice_table[ mb_xy ]= h->slice_num;
+    h->slice_table[mb_xy] = sl->slice_num;
 
     if(IS_INTRA_PCM(mb_type)) {
         const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
@@ -2085,7 +2088,7 @@ decode_intra_mb:
     } else if( partition_count == 4 ) {
         int i, j, sub_partition_count[4], list, ref[2][4];
 
-        if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
+        if (sl->slice_type_nos == AV_PICTURE_TYPE_B ) {
             for( i = 0; i < 4; i++ ) {
                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;

libavcodec/h264_cavlc.c

@@ -708,7 +708,7 @@ int ff_h264_decode_mb_cavlc(H264Context *h, H264SliceContext *sl)
     tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, h->mb_x, h->mb_y);
     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
                 down the code */
-    if(h->slice_type_nos != AV_PICTURE_TYPE_I){
+    if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
         if(h->mb_skip_run==-1)
             h->mb_skip_run= get_ue_golomb(&h->gb);
 
@@ -729,7 +729,7 @@ int ff_h264_decode_mb_cavlc(H264Context *h, H264SliceContext *sl)
     sl->prev_mb_skipped = 0;
 
     mb_type= get_ue_golomb(&h->gb);
-    if(h->slice_type_nos == AV_PICTURE_TYPE_B){
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
         if(mb_type < 23){
             partition_count= b_mb_type_info[mb_type].partition_count;
             mb_type=         b_mb_type_info[mb_type].type;
@@ -737,7 +737,7 @@ int ff_h264_decode_mb_cavlc(H264Context *h, H264SliceContext *sl)
             mb_type -= 23;
             goto decode_intra_mb;
         }
-    }else if(h->slice_type_nos == AV_PICTURE_TYPE_P){
+    } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
         if(mb_type < 5){
             partition_count= p_mb_type_info[mb_type].partition_count;
             mb_type=         p_mb_type_info[mb_type].type;
@@ -746,12 +746,12 @@ int ff_h264_decode_mb_cavlc(H264Context *h, H264SliceContext *sl)
             goto decode_intra_mb;
         }
     }else{
-       assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
-        if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
+       assert(sl->slice_type_nos == AV_PICTURE_TYPE_I);
+        if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
             mb_type--;
 decode_intra_mb:
         if(mb_type > 25){
-            av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_picture_type_char(h->slice_type), h->mb_x, h->mb_y);
+            av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_picture_type_char(sl->slice_type), h->mb_x, h->mb_y);
             return -1;
         }
         partition_count=0;
@@ -763,7 +763,7 @@ decode_intra_mb:
     if(MB_FIELD(h))
         mb_type |= MB_TYPE_INTERLACED;
 
-    h->slice_table[ mb_xy ]= h->slice_num;
+    h->slice_table[mb_xy] = sl->slice_num;
 
     if(IS_INTRA_PCM(mb_type)){
         const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
@@ -834,7 +834,7 @@ decode_intra_mb:
     }else if(partition_count==4){
         int i, j, sub_partition_count[4], list, ref[2][4];
 
-        if(h->slice_type_nos == AV_PICTURE_TYPE_B){
+        if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
             for(i=0; i<4; i++){
                 h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
                 if(h->sub_mb_type[i] >=13){
@@ -852,7 +852,7 @@ decode_intra_mb:
                 sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
             }
         }else{
-            assert(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
+            assert(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
             for(i=0; i<4; i++){
                 h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
                 if(h->sub_mb_type[i] >=4){

libavcodec/h264_direct.c

@@ -104,7 +104,7 @@ static void fill_colmap(H264Context *h, int map[2][16 + 32], int list,
     }
 }
 
-void ff_h264_direct_ref_list_init(H264Context *const h)
+void ff_h264_direct_ref_list_init(H264Context *const h, H264SliceContext *sl)
 {
     H264Picture *const ref1 = &h->ref_list[1][0];
     H264Picture *const cur = h->cur_pic_ptr;
@@ -140,7 +140,7 @@ void ff_h264_direct_ref_list_init(H264Context *const h)
         h->col_fieldoff = 2 * h->ref_list[1][0].reference - 3;
     }
 
-    if (h->slice_type_nos != AV_PICTURE_TYPE_B || h->direct_spatial_mv_pred)
+    if (sl->slice_type_nos != AV_PICTURE_TYPE_B || h->direct_spatial_mv_pred)
         return;
 
     for (list = 0; list < 2; list++) {

libavcodec/h264_mb.c

@@ -524,7 +524,7 @@ static av_always_inline void xchg_mb_border(H264Context *h, H264SliceContext *sl
     }
 
     if (h->deblocking_filter == 2) {
-        deblock_topleft = h->slice_table[h->mb_xy - 1 - h->mb_stride] == h->slice_num;
+        deblock_topleft = h->slice_table[h->mb_xy - 1 - h->mb_stride] == sl->slice_num;
         deblock_top     = sl->top_type;
     } else {
         deblock_topleft = (h->mb_x > 0);

libavcodec/h264_mvpred.h

@@ -423,22 +423,22 @@ static void fill_decode_neighbors(H264Context *h, H264SliceContext *sl, int mb_t
     sl->left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];
 
     if (FMO) {
-        if (h->slice_table[topleft_xy] != h->slice_num)
+        if (h->slice_table[topleft_xy] != sl->slice_num)
             sl->topleft_type = 0;
-        if (h->slice_table[top_xy] != h->slice_num)
+        if (h->slice_table[top_xy] != sl->slice_num)
             sl->top_type = 0;
-        if (h->slice_table[left_xy[LTOP]] != h->slice_num)
+        if (h->slice_table[left_xy[LTOP]] != sl->slice_num)
             sl->left_type[LTOP] = sl->left_type[LBOT] = 0;
     } else {
-        if (h->slice_table[topleft_xy] != h->slice_num) {
+        if (h->slice_table[topleft_xy] != sl->slice_num) {
             sl->topleft_type = 0;
-            if (h->slice_table[top_xy] != h->slice_num)
+            if (h->slice_table[top_xy] != sl->slice_num)
                 sl->top_type = 0;
-            if (h->slice_table[left_xy[LTOP]] != h->slice_num)
+            if (h->slice_table[left_xy[LTOP]] != sl->slice_num)
                 sl->left_type[LTOP] = sl->left_type[LBOT] = 0;
         }
     }
-    if (h->slice_table[topright_xy] != h->slice_num)
+    if (h->slice_table[topright_xy] != sl->slice_num)
         sl->topright_type = 0;
 }
 
@@ -720,7 +720,7 @@ static void fill_decode_caches(H264Context *h, H264SliceContext *sl, int mb_type
                     }
                     AV_ZERO16(mvd_cache[2 + 8 * 0]);
                     AV_ZERO16(mvd_cache[2 + 8 * 2]);
-                    if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
+                    if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
                         uint8_t *direct_cache = &h->direct_cache[scan8[0]];
                         uint8_t *direct_table = h->direct_table;
                         fill_rectangle(direct_cache, 4, 4, 8, MB_TYPE_16x16 >> 1, 1);
@@ -810,7 +810,7 @@ static void av_unused decode_mb_skip(H264Context *h, H264SliceContext *sl)
     if (MB_FIELD(h))
         mb_type |= MB_TYPE_INTERLACED;
 
-    if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
         // just for fill_caches. pred_direct_motion will set the real mb_type
         mb_type |= MB_TYPE_L0L1 | MB_TYPE_DIRECT2 | MB_TYPE_SKIP;
         if (h->direct_spatial_mv_pred) {
@@ -829,7 +829,7 @@ static void av_unused decode_mb_skip(H264Context *h, H264SliceContext *sl)
     write_back_motion(h, sl, mb_type);
     h->cur_pic.mb_type[mb_xy]      = mb_type;
     h->cur_pic.qscale_table[mb_xy] = sl->qscale;
-    h->slice_table[mb_xy]            = h->slice_num;
+    h->slice_table[mb_xy]          = sl->slice_num;
     sl->prev_mb_skipped            = 1;
 }
 

libavcodec/h264_parser.c

@@ -104,15 +104,15 @@ static int scan_mmco_reset(AVCodecParserContext *s)
     H264Context      *h = &p->h;
     H264SliceContext *sl = &h->slice_ctx[0];
 
-    h->slice_type_nos = s->pict_type & 3;
+    sl->slice_type_nos = s->pict_type & 3;
 
     if (h->pps.redundant_pic_cnt_present)
         get_ue_golomb(&h->gb); // redundant_pic_count
 
-    if (ff_set_ref_count(h) < 0)
+    if (ff_set_ref_count(h, sl) < 0)
         return AVERROR_INVALIDDATA;
 
-    if (h->slice_type_nos != AV_PICTURE_TYPE_I) {
+    if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
         int list;
         for (list = 0; list < h->list_count; list++) {
             if (get_bits1(&h->gb)) {
@@ -140,8 +140,8 @@ static int scan_mmco_reset(AVCodecParserContext *s)
         }
     }
 
-    if ((h->pps.weighted_pred && h->slice_type_nos == AV_PICTURE_TYPE_P) ||
-        (h->pps.weighted_bipred_idc == 1 && h->slice_type_nos == AV_PICTURE_TYPE_B))
+    if ((h->pps.weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
+        (h->pps.weighted_bipred_idc == 1 && sl->slice_type_nos == AV_PICTURE_TYPE_B))
         ff_pred_weight_table(h, sl);
 
     if (get_bits1(&h->gb)) { // adaptive_ref_pic_marking_mode_flag

libavcodec/h264_refs.c

@@ -116,11 +116,11 @@ static int add_sorted(H264Picture **sorted, H264Picture **src, int len, int limi
     return out_i;
 }
 
-int ff_h264_fill_default_ref_list(H264Context *h)
+int ff_h264_fill_default_ref_list(H264Context *h, H264SliceContext *sl)
 {
     int i, len;
 
-    if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
         H264Picture *sorted[32];
         int cur_poc, list;
         int lens[2];
@@ -174,7 +174,7 @@ int ff_h264_fill_default_ref_list(H264Context *h)
                 h->default_ref_list[0][i].pic_id,
                 h->default_ref_list[0][i].f.data[0]);
     }
-    if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
         for (i = 0; i < h->ref_count[1]; i++) {
             tprintf(h->avctx, "List1: %s fn:%d 0x%p\n",
                     (h->default_ref_list[1][i].long_ref ? "LT" : "ST"),

libavcodec/h264_slice.c

@@ -1212,26 +1212,26 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Contex
     }
     if (slice_type > 4) {
         slice_type -= 5;
-        h->slice_type_fixed = 1;
+        sl->slice_type_fixed = 1;
     } else
-        h->slice_type_fixed = 0;
+        sl->slice_type_fixed = 0;
 
     slice_type = golomb_to_pict_type[slice_type];
     if (slice_type == AV_PICTURE_TYPE_I ||
         (h0->current_slice != 0 && slice_type == h0->last_slice_type)) {
         default_ref_list_done = 1;
     }
-    h->slice_type     = slice_type;
-    h->slice_type_nos = slice_type & 3;
+    sl->slice_type     = slice_type;
+    sl->slice_type_nos = slice_type & 3;
 
     if (h->nal_unit_type  == NAL_IDR_SLICE &&
-        h->slice_type_nos != AV_PICTURE_TYPE_I) {
+        sl->slice_type_nos != AV_PICTURE_TYPE_I) {
         av_log(h->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");
         return AVERROR_INVALIDDATA;
     }
 
     // to make a few old functions happy, it's wrong though
-    h->pict_type = h->slice_type;
+    h->pict_type = sl->slice_type;
 
     pps_id = get_ue_golomb(&h->gb);
     if (pps_id >= MAX_PPS_COUNT) {
@@ -1592,16 +1592,16 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Contex
     if (h->pps.redundant_pic_cnt_present)
         h->redundant_pic_count = get_ue_golomb(&h->gb);
 
-    ret = ff_set_ref_count(h);
+    ret = ff_set_ref_count(h, sl);
     if (ret < 0)
         return ret;
     else if (ret == 1)
         default_ref_list_done = 0;
 
     if (!default_ref_list_done)
-        ff_h264_fill_default_ref_list(h);
+        ff_h264_fill_default_ref_list(h, sl);
 
-    if (h->slice_type_nos != AV_PICTURE_TYPE_I) {
+    if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
        ret = ff_h264_decode_ref_pic_list_reordering(h);
        if (ret < 0) {
            h->ref_count[1] = h->ref_count[0] = 0;
@@ -1609,12 +1609,12 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Contex
        }
     }
 
-    if ((h->pps.weighted_pred && h->slice_type_nos == AV_PICTURE_TYPE_P) ||
+    if ((h->pps.weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
         (h->pps.weighted_bipred_idc == 1 &&
-         h->slice_type_nos == AV_PICTURE_TYPE_B))
+         sl->slice_type_nos == AV_PICTURE_TYPE_B))
         ff_pred_weight_table(h, sl);
     else if (h->pps.weighted_bipred_idc == 2 &&
-             h->slice_type_nos == AV_PICTURE_TYPE_B) {
+             sl->slice_type_nos == AV_PICTURE_TYPE_B) {
         implicit_weight_table(h, sl, -1);
     } else {
         sl->use_weight = 0;
@@ -1640,17 +1640,17 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Contex
     if (FRAME_MBAFF(h)) {
         ff_h264_fill_mbaff_ref_list(h, sl);
 
-        if (h->pps.weighted_bipred_idc == 2 && h->slice_type_nos == AV_PICTURE_TYPE_B) {
+        if (h->pps.weighted_bipred_idc == 2 && sl->slice_type_nos == AV_PICTURE_TYPE_B) {
             implicit_weight_table(h, sl, 0);
             implicit_weight_table(h, sl, 1);
         }
     }
 
-    if (h->slice_type_nos == AV_PICTURE_TYPE_B && !h->direct_spatial_mv_pred)
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_B && !h->direct_spatial_mv_pred)
         ff_h264_direct_dist_scale_factor(h);
-    ff_h264_direct_ref_list_init(h);
+    ff_h264_direct_ref_list_init(h, sl);
 
-    if (h->slice_type_nos != AV_PICTURE_TYPE_I && h->pps.cabac) {
+    if (sl->slice_type_nos != AV_PICTURE_TYPE_I && h->pps.cabac) {
         tmp = get_ue_golomb_31(&h->gb);
         if (tmp > 2) {
             av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", tmp);
@@ -1669,10 +1669,10 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Contex
     sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
     sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
     // FIXME qscale / qp ... stuff
-    if (h->slice_type == AV_PICTURE_TYPE_SP)
+    if (sl->slice_type == AV_PICTURE_TYPE_SP)
         get_bits1(&h->gb); /* sp_for_switch_flag */
-    if (h->slice_type == AV_PICTURE_TYPE_SP ||
-        h->slice_type == AV_PICTURE_TYPE_SI)
+    if (sl->slice_type == AV_PICTURE_TYPE_SP ||
+        sl->slice_type == AV_PICTURE_TYPE_SI)
         get_se_golomb(&h->gb); /* slice_qs_delta */
 
     h->deblocking_filter     = 1;
@@ -1706,9 +1706,9 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Contex
 
     if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
         (h->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&
-         h->slice_type_nos != AV_PICTURE_TYPE_I) ||
+         sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
         (h->avctx->skip_loop_filter >= AVDISCARD_BIDIR  &&
-         h->slice_type_nos == AV_PICTURE_TYPE_B) ||
+         sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
         (h->avctx->skip_loop_filter >= AVDISCARD_NONREF &&
          h->nal_ref_idc == 0))
         h->deblocking_filter = 0;
@@ -1740,15 +1740,15 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Contex
                    6 * (h->sps.bit_depth_luma - 8);
 
     h0->last_slice_type = slice_type;
-    h->slice_num        = ++h0->current_slice;
-    if (h->slice_num >= MAX_SLICES) {
+    sl->slice_num       = ++h0->current_slice;
+    if (sl->slice_num >= MAX_SLICES) {
         av_log(h->avctx, AV_LOG_ERROR,
                "Too many slices, increase MAX_SLICES and recompile\n");
     }
 
     for (j = 0; j < 2; j++) {
         int id_list[16];
-        int *ref2frm = h->ref2frm[h->slice_num & (MAX_SLICES - 1)][j];
+        int *ref2frm = h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][j];
         for (i = 0; i < 16; i++) {
             id_list[i] = 60;
             if (j < h->list_count && i < h->ref_count[j] &&
@@ -1782,11 +1782,11 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Contex
     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
         av_log(h->avctx, AV_LOG_DEBUG,
                "slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
-               h->slice_num,
+               sl->slice_num,
                (h->picture_structure == PICT_FRAME ? "F" : h->picture_structure == PICT_TOP_FIELD ? "T" : "B"),
                first_mb_in_slice,
-               av_get_picture_type_char(h->slice_type),
-               h->slice_type_fixed ? " fix" : "",
+               av_get_picture_type_char(sl->slice_type),
+               sl->slice_type_fixed ? " fix" : "",
                h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "",
                pps_id, h->frame_num,
                h->cur_pic_ptr->field_poc[0],
@@ -1797,15 +1797,15 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Contex
                h->slice_alpha_c0_offset, h->slice_beta_offset,
                sl->use_weight,
                sl->use_weight == 1 && sl->use_weight_chroma ? "c" : "",
-               h->slice_type == AV_PICTURE_TYPE_B ? (h->direct_spatial_mv_pred ? "SPAT" : "TEMP") : "");
+               sl->slice_type == AV_PICTURE_TYPE_B ? (h->direct_spatial_mv_pred ? "SPAT" : "TEMP") : "");
     }
 
     return 0;
 }
 
-int ff_h264_get_slice_type(const H264Context *h)
+int ff_h264_get_slice_type(const H264SliceContext *sl)
 {
-    switch (h->slice_type) {
+    switch (sl->slice_type) {
     case AV_PICTURE_TYPE_P:
         return 0;
     case AV_PICTURE_TYPE_B:
@@ -1884,7 +1884,7 @@ static av_always_inline void fill_filter_caches_inter(H264Context *h,
 
     {
         int8_t *ref = &h->cur_pic.ref_index[list][4 * mb_xy];
-        int (*ref2frm)[64] = h->ref2frm[h->slice_num & (MAX_SLICES - 1)][0] + (MB_MBAFF(h) ? 20 : 2);
+        int (*ref2frm)[64] = h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][0] + (MB_MBAFF(h) ? 20 : 2);
         uint32_t ref01 = (pack16to32(ref2frm[list][ref[0]], ref2frm[list][ref[1]]) & 0x00FF00FF) * 0x0101;
         uint32_t ref23 = (pack16to32(ref2frm[list][ref[2]], ref2frm[list][ref[3]]) & 0x00FF00FF) * 0x0101;
         AV_WN32A(&ref_cache[0 * 8], ref01);
@@ -1963,9 +1963,9 @@ static int fill_filter_caches(H264Context *h, H264SliceContext *sl, int mb_type)
     left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]];
     left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];
     if (h->deblocking_filter == 2) {
-        if (h->slice_table[top_xy] != h->slice_num)
+        if (h->slice_table[top_xy] != sl->slice_num)
             top_type = 0;
-        if (h->slice_table[left_xy[LBOT]] != h->slice_num)
+        if (h->slice_table[left_xy[LBOT]] != sl->slice_num)
             left_type[LTOP] = left_type[LBOT] = 0;
     } else {
         if (h->slice_table[top_xy] == 0xFFFF)
@@ -2056,7 +2056,7 @@ static void loop_filter(H264Context *h, H264SliceContext *sl, int start_x, int e
     uint8_t *dest_y, *dest_cb, *dest_cr;
     int linesize, uvlinesize, mb_x, mb_y;
     const int end_mb_y       = h->mb_y + FRAME_MBAFF(h);
-    const int old_slice_type = h->slice_type;
+    const int old_slice_type = sl->slice_type;
     const int pixel_shift    = h->pixel_shift;
     const int block_h        = 16 >> h->chroma_y_shift;
 
@@ -2065,7 +2065,7 @@ static void loop_filter(H264Context *h, H264SliceContext *sl, int start_x, int e
             for (mb_y = end_mb_y - FRAME_MBAFF(h); mb_y <= end_mb_y; mb_y++) {
                 int mb_xy, mb_type;
                 mb_xy         = h->mb_xy = mb_x + mb_y * h->mb_stride;
-                h->slice_num  = h->slice_table[mb_xy];
+                sl->slice_num = h->slice_table[mb_xy];
                 mb_type       = h->cur_pic.mb_type[mb_xy];
                 h->list_count = h->list_counts[mb_xy];
 
@@ -2113,19 +2113,19 @@ static void loop_filter(H264Context *h, H264SliceContext *sl, int start_x, int e
                 }
             }
     }
-    h->slice_type   = old_slice_type;
+    sl->slice_type  = old_slice_type;
     h->mb_x         = end_x;
     h->mb_y         = end_mb_y - FRAME_MBAFF(h);
     sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
     sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
 }
 
-static void predict_field_decoding_flag(H264Context *h)
+static void predict_field_decoding_flag(H264Context *h, H264SliceContext *sl)
 {
     const int mb_xy = h->mb_x + h->mb_y * h->mb_stride;
-    int mb_type     = (h->slice_table[mb_xy - 1] == h->slice_num) ?
+    int mb_type     = (h->slice_table[mb_xy - 1] == sl->slice_num) ?
                       h->cur_pic.mb_type[mb_xy - 1] :
-                      (h->slice_table[mb_xy - h->mb_stride] == h->slice_num) ?
+                      (h->slice_table[mb_xy - h->mb_stride] == sl->slice_num) ?
                       h->cur_pic.mb_type[mb_xy - h->mb_stride] : 0;
     h->mb_mbaff     = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
 }
@@ -2245,7 +2245,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
                 if (FIELD_OR_MBAFF_PICTURE(h)) {
                     ++h->mb_y;
                     if (FRAME_MBAFF(h) && h->mb_y < h->mb_height)
-                        predict_field_decoding_flag(h);
+                        predict_field_decoding_flag(h, sl);
                 }
             }
 
@@ -2292,7 +2292,7 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
                 if (FIELD_OR_MBAFF_PICTURE(h)) {
                     ++h->mb_y;
                     if (FRAME_MBAFF(h) && h->mb_y < h->mb_height)
-                        predict_field_decoding_flag(h);
+                        predict_field_decoding_flag(h, sl);
                 }
                 if (h->mb_y >= h->mb_height) {
                     tprintf(h->avctx, "slice end %d %d\n",

libavcodec/svq3.c

@@ -817,7 +817,7 @@ static int svq3_decode_slice_header(AVCodecContext *avctx)
         return -1;
     }
 
-    h->slice_type = golomb_to_pict_type[slice_id];
+    sl->slice_type = golomb_to_pict_type[slice_id];
 
     if ((header & 0x9F) == 2) {
         i              = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
@@ -828,7 +828,7 @@ static int svq3_decode_slice_header(AVCodecContext *avctx)
         h->mb_skip_run = 0;
     }
 
-    h->slice_num      = get_bits(&h->gb, 8);
+    sl->slice_num     = get_bits(&h->gb, 8);
     sl->qscale        = get_bits(&h->gb, 5);
     s->adaptive_quant = get_bits1(&h->gb);
 
@@ -1134,7 +1134,7 @@ static int svq3_decode_frame(AVCodecContext *avctx, void *data,
     if (svq3_decode_slice_header(avctx))
         return -1;
 
-    h->pict_type = h->slice_type;
+    h->pict_type = sl->slice_type;
 
     if (h->pict_type != AV_PICTURE_TYPE_B)
         FFSWAP(H264Picture*, s->next_pic, s->last_pic);
@@ -1198,7 +1198,7 @@ static int svq3_decode_frame(AVCodecContext *avctx, void *data,
                "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
                av_get_picture_type_char(h->pict_type),
                s->halfpel_flag, s->thirdpel_flag,
-               s->adaptive_quant, h->slice_ctx[0].qscale, h->slice_num);
+               s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
 
     if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
         avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
@@ -1213,7 +1213,7 @@ static int svq3_decode_frame(AVCodecContext *avctx, void *data,
     }
 
     if (h->pict_type == AV_PICTURE_TYPE_B) {
-        h->frame_num_offset = h->slice_num - h->prev_frame_num;
+        h->frame_num_offset = sl->slice_num - h->prev_frame_num;
 
         if (h->frame_num_offset < 0)
             h->frame_num_offset += 256;
@@ -1224,7 +1224,7 @@ static int svq3_decode_frame(AVCodecContext *avctx, void *data,
         }
     } else {
         h->prev_frame_num        = h->frame_num;
-        h->frame_num             = h->slice_num;
+        h->frame_num             = sl->slice_num;
         h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
 
         if (h->prev_frame_num_offset < 0)

libavcodec/vaapi_h264.c

@@ -329,8 +329,8 @@ static int vaapi_h264_decode_slice(AVCodecContext *avctx,
         return -1;
     slice_param->slice_data_bit_offset          = get_bits_count(&h->gb) + 8; /* bit buffer started beyond nal_unit_type */
     slice_param->first_mb_in_slice              = (h->mb_y >> FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + h->mb_x;
-    slice_param->slice_type                     = ff_h264_get_slice_type(h);
-    slice_param->direct_spatial_mv_pred_flag    = h->slice_type == AV_PICTURE_TYPE_B ? h->direct_spatial_mv_pred : 0;
+    slice_param->slice_type                     = ff_h264_get_slice_type(sl);
+    slice_param->direct_spatial_mv_pred_flag    = sl->slice_type == AV_PICTURE_TYPE_B ? h->direct_spatial_mv_pred : 0;
     slice_param->num_ref_idx_l0_active_minus1   = h->list_count > 0 ? h->ref_count[0] - 1 : 0;
     slice_param->num_ref_idx_l1_active_minus1   = h->list_count > 1 ? h->ref_count[1] - 1 : 0;
     slice_param->cabac_init_idc                 = h->cabac_init_idc;