libavcodec/h264_cabac.c:1710: error: Buffer Overrun L2
  Offset: [min(0, `h->mb_field_decoding_flag`), 62+max(1, `h->mb_field_decoding_flag`)] (⇐ [min(0, `h->mb_field_decoding_flag`), max(1, `h->mb_field_decoding_flag`)] + [0, 62]) Size: 2 by call to `decode_cabac_residual`.

libavcodec/h264_cabac.c:1279:1: Parameter `h->mb_field_decoding_flag`
1277.  * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1278.  */
1279. int ff_h264_decode_mb_cabac(H264Context *h) {
      ^
1280.     MpegEncContext * const s = &h->s;
1281.     int mb_xy;

libavcodec/h264_cabac.c:1404:5: Call
1402.     }
1403. 
1404.     fill_caches(h, mb_type, 0);
          ^
1405. 
1406.     if( IS_INTRA( mb_type ) ) {

libavcodec/h264.h:715:1: Parameter `h->mb_field_decoding_flag`
  713. static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my);
  714. 
  715. static void fill_caches(H264Context *h, int mb_type, int for_deblock){
       ^
  716.     MpegEncContext * const s = &h->s;
  717.     const int mb_xy= h->mb_xy;

libavcodec/h264_cabac.c:1710:13: Call
1708.             int i;
1709.             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1710.             decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
                  ^
1711. 
1712.             if( cbp&15 ) {

libavcodec/h264_cabac.c:1240:1: Parameter `h->mb_field_decoding_flag`
  1238. #endif
  1239. 
  1240. static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
        ^
  1241. #if CONFIG_SMALL
  1242.     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);

libavcodec/h264_cabac.c:1244:32: Call
  1242.     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
  1243. #else
  1244.     if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
                                       ^
  1245.     else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
  1246. #endif

libavcodec/h264_cabac.c:1231:1: Parameter `h->mb_field_decoding_flag`
    1229. 
    1230. #if !CONFIG_SMALL
    1231. static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
          ^
    1232.     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
    1233. }

libavcodec/h264_cabac.c:1232:5: Call
    1230. #if !CONFIG_SMALL
    1231. static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
    1232.     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
              ^
    1233. }
    1234. 

libavcodec/h264_cabac.c:1160:9: <Offset trace>
1158.         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1159. #else
1160.         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
              ^
1161.     } else {
1162.         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );

libavcodec/h264_cabac.c:1160:9: Assignment
      1158.         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
      1159. #else
      1160.         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
                    ^
      1161.     } else {
      1162.         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );

libavcodec/h264_cabac.c:1049:1: <Length trace>
1047. };
1048. 
1049. static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {
      ^
1050.     static const int significant_coeff_flag_offset[2][6] = {
1051.       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },

libavcodec/h264_cabac.c:1049:1: Parameter `h->mb_field_decoding_flag`
      1047. };
      1048. 
      1049. static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {
            ^
      1050.     static const int significant_coeff_flag_offset[2][6] = {
      1051.       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },

libavcodec/h264_cabac.c:1154:9: Assignment
      1152.             index[coeff_count++] = last;\
      1153.         }
      1154.         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
                    ^
      1155. #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
      1156.         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);

libavcodec/h264_cabac.c:1160:9: Array access: Offset: [min(0, h->mb_field_decoding_flag), 62+max(1, h->mb_field_decoding_flag)] (⇐ [min(0, h->mb_field_decoding_flag), max(1, h->mb_field_decoding_flag)] + [0, 62]) Size: 2 by call to `decode_cabac_residual` 
      1158.         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
      1159. #else
      1160.         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
                    ^
      1161.     } else {
      1162.         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );

static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {
    static const int significant_coeff_flag_offset[2][6] = {
      { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
      { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
    };
    static const int last_coeff_flag_offset[2][6] = {
      { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
      { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
    };
    static const int coeff_abs_level_m1_offset[6] = {
        227+0, 227+10, 227+20, 227+30, 227+39, 426
    };
    static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
      { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
        4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
        7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
       12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
      { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
        6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
        9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
        9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
    };
    static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
    static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
    static const uint8_t coeff_abs_level_transition[2][8] = {
        { 1, 2, 3, 3, 4, 5, 6, 7 },
        { 4, 4, 4, 4, 5, 6, 7, 7 }
    };
    int index[64];
    int av_unused last;
    int coeff_count = 0;
    int node_ctx = 0;
    uint8_t *significant_coeff_ctx_base;
    uint8_t *last_coeff_ctx_base;
    uint8_t *abs_level_m1_ctx_base;
#if !ARCH_X86
#define CABAC_ON_STACK
#endif
#ifdef CABAC_ON_STACK
#define CC &cc
    CABACContext cc;
    cc.range     = h->cabac.range;
    cc.low       = h->cabac.low;
    cc.bytestream= h->cabac.bytestream;
#else
#define CC &h->cabac
#endif
    if( is_dc || cat != 5 ) {
        if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
            if( !is_dc )
                h->non_zero_count_cache[scan8[n]] = 0;
#ifdef CABAC_ON_STACK
            h->cabac.range     = cc.range     ;
            h->cabac.low       = cc.low       ;
            h->cabac.bytestream= cc.bytestream;
#endif
            return;
        }
    }
    significant_coeff_ctx_base = h->cabac_state
        + significant_coeff_flag_offset[MB_FIELD][cat];
    last_coeff_ctx_base = h->cabac_state
        + last_coeff_flag_offset[MB_FIELD][cat];
    abs_level_m1_ctx_base = h->cabac_state
        + coeff_abs_level_m1_offset[cat];
    if( !is_dc && cat == 5 ) {
#define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
        for(last= 0; last < coefs; last++) { \
            uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
            if( get_cabac( CC, sig_ctx )) { \
                uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
                index[coeff_count++] = last; \
                if( get_cabac( CC, last_ctx ) ) { \
                    last= max_coeff; \
                    break; \
                } \
            } \
        }\
        if( last == max_coeff -1 ) {\
            index[coeff_count++] = last;\
        }
        const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
        coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
    } else {
        coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
#else
        DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
    } else {
        DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
#endif
    }
    assert(coeff_count > 0);
    if( is_dc ) {
        if( cat == 0 )
            h->cbp_table[h->mb_xy] |= 0x100;
        else
            h->cbp_table[h->mb_xy] |= 0x40 << n;
    } else {
        if( cat == 5 )
            fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
        else {
            assert( cat == 1 || cat == 2 || cat == 4 );
            h->non_zero_count_cache[scan8[n]] = coeff_count;
        }
    }
    do {
        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
        int j= scantable[index[--coeff_count]];
        if( get_cabac( CC, ctx ) == 0 ) {
            node_ctx = coeff_abs_level_transition[0][node_ctx];
            if( is_dc ) {
                block[j] = get_cabac_bypass_sign( CC, -1);
            }else{
                block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
            }
        } else {
            int coeff_abs = 2;
            ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
            node_ctx = coeff_abs_level_transition[1][node_ctx];
            while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
                coeff_abs++;
            }
            if( coeff_abs >= 15 ) {
                int j = 0;
                while( get_cabac_bypass( CC ) ) {
                    j++;
                }
                coeff_abs=1;
                while( j-- ) {
                    coeff_abs += coeff_abs + get_cabac_bypass( CC );
                }
                coeff_abs+= 14;
            }
            if( is_dc ) {
                block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
            }else{
                block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
            }
        }
    } while( coeff_count );
#ifdef CABAC_ON_STACK
            h->cabac.range     = cc.range     ;
            h->cabac.low       = cc.low       ;
            h->cabac.bytestream= cc.bytestream;
#endif
}
['int ff_h264_decode_mb_cabac(H264Context *h) {\n    MpegEncContext * const s = &h->s;\n    int mb_xy;\n    int mb_type, partition_count, cbp = 0;\n    int dct8x8_allowed= h->pps.transform_8x8_mode;\n    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;\n    tprintf(s->avctx, "pic:%d mb:%d/%d\\n", h->frame_num, s->mb_x, s->mb_y);\n    if( h->slice_type_nos != FF_I_TYPE ) {\n        int skip;\n        if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )\n            predict_field_decoding_flag(h);\n        if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )\n            skip = h->next_mb_skipped;\n        else\n            skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );\n        if( skip ) {\n            if( FRAME_MBAFF && (s->mb_y&1)==0 ){\n                s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;\n                h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );\n                if(!h->next_mb_skipped)\n                    h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);\n            }\n            decode_mb_skip(h);\n            h->cbp_table[mb_xy] = 0;\n            h->chroma_pred_mode_table[mb_xy] = 0;\n            h->last_qscale_diff = 0;\n            return 0;\n        }\n    }\n    if(FRAME_MBAFF){\n        if( (s->mb_y&1) == 0 )\n            h->mb_mbaff =\n            h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);\n    }\n    h->prev_mb_skipped = 0;\n    compute_mb_neighbors(h);\n    if( h->slice_type_nos == FF_B_TYPE ) {\n        mb_type = decode_cabac_mb_type_b( h );\n        if( mb_type < 23 ){\n            partition_count= b_mb_type_info[mb_type].partition_count;\n            mb_type=         b_mb_type_info[mb_type].type;\n        }else{\n            mb_type -= 23;\n            goto decode_intra_mb;\n        }\n    } else if( h->slice_type_nos == FF_P_TYPE ) {\n        if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {\n            if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {\n                mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );\n            } else {\n                mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );\n            }\n            partition_count= p_mb_type_info[mb_type].partition_count;\n            mb_type=         p_mb_type_info[mb_type].type;\n        } else {\n            mb_type= decode_cabac_intra_mb_type(h, 17, 0);\n            goto decode_intra_mb;\n        }\n    } else {\n        mb_type= decode_cabac_intra_mb_type(h, 3, 1);\n        if(h->slice_type == FF_SI_TYPE && mb_type)\n            mb_type--;\n        assert(h->slice_type_nos == FF_I_TYPE);\ndecode_intra_mb:\n        partition_count = 0;\n        cbp= i_mb_type_info[mb_type].cbp;\n        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;\n        mb_type= i_mb_type_info[mb_type].type;\n    }\n    if(MB_FIELD)\n        mb_type |= MB_TYPE_INTERLACED;\n    h->slice_table[ mb_xy ]= h->slice_num;\n    if(IS_INTRA_PCM(mb_type)) {\n        const uint8_t *ptr;\n        ptr= h->cabac.bytestream;\n        if(h->cabac.low&0x1) ptr--;\n        if(CABAC_BITS==16){\n            if(h->cabac.low&0x1FF) ptr--;\n        }\n        memcpy(h->mb, ptr, 256); ptr+=256;\n        if(CHROMA){\n            memcpy(h->mb+128, ptr, 128); ptr+=128;\n        }\n        ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);\n        h->cbp_table[mb_xy] = 0x1ef;\n        h->chroma_pred_mode_table[mb_xy] = 0;\n        s->current_picture.qscale_table[mb_xy]= 0;\n        memset(h->non_zero_count[mb_xy], 16, 16);\n        s->current_picture.mb_type[mb_xy]= mb_type;\n        h->last_qscale_diff = 0;\n        return 0;\n    }\n    if(MB_MBAFF){\n        h->ref_count[0] <<= 1;\n        h->ref_count[1] <<= 1;\n    }\n    fill_caches(h, mb_type, 0);\n    if( IS_INTRA( mb_type ) ) {\n        int i, pred_mode;\n        if( IS_INTRA4x4( mb_type ) ) {\n            if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {\n                mb_type |= MB_TYPE_8x8DCT;\n                for( i = 0; i < 16; i+=4 ) {\n                    int pred = pred_intra_mode( h, i );\n                    int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );\n                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );\n                }\n            } else {\n                for( i = 0; i < 16; i++ ) {\n                    int pred = pred_intra_mode( h, i );\n                    h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );\n                }\n            }\n            ff_h264_write_back_intra_pred_mode(h);\n            if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;\n        } else {\n            h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );\n            if( h->intra16x16_pred_mode < 0 ) return -1;\n        }\n        if(CHROMA){\n            h->chroma_pred_mode_table[mb_xy] =\n            pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );\n            pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );\n            if( pred_mode < 0 ) return -1;\n            h->chroma_pred_mode= pred_mode;\n        }\n    } else if( partition_count == 4 ) {\n        int i, j, sub_partition_count[4], list, ref[2][4];\n        if( h->slice_type_nos == FF_B_TYPE ) {\n            for( i = 0; i < 4; i++ ) {\n                h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );\n                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;\n                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;\n            }\n            if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |\n                          h->sub_mb_type[2] | h->sub_mb_type[3]) ) {\n                ff_h264_pred_direct_motion(h, &mb_type);\n                h->ref_cache[0][scan8[4]] =\n                h->ref_cache[1][scan8[4]] =\n                h->ref_cache[0][scan8[12]] =\n                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;\n                if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) {\n                    for( i = 0; i < 4; i++ )\n                        if( IS_DIRECT(h->sub_mb_type[i]) )\n                            fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 );\n                }\n            }\n        } else {\n            for( i = 0; i < 4; i++ ) {\n                h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );\n                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;\n                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;\n            }\n        }\n        for( list = 0; list < h->list_count; list++ ) {\n                for( i = 0; i < 4; i++ ) {\n                    if(IS_DIRECT(h->sub_mb_type[i])) continue;\n                    if(IS_DIR(h->sub_mb_type[i], 0, list)){\n                        if( h->ref_count[list] > 1 ){\n                            ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );\n                            if(ref[list][i] >= (unsigned)h->ref_count[list]){\n                                av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\\n", ref[list][i], h->ref_count[list]);\n                                return -1;\n                            }\n                        }else\n                            ref[list][i] = 0;\n                    } else {\n                        ref[list][i] = -1;\n                    }\n                                                       h->ref_cache[list][ scan8[4*i]+1 ]=\n                    h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];\n                }\n        }\n        if(dct8x8_allowed)\n            dct8x8_allowed = get_dct8x8_allowed(h);\n        for(list=0; list<h->list_count; list++){\n            for(i=0; i<4; i++){\n                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];\n                if(IS_DIRECT(h->sub_mb_type[i])){\n                    fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);\n                    continue;\n                }\n                if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){\n                    const int sub_mb_type= h->sub_mb_type[i];\n                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;\n                    for(j=0; j<sub_partition_count[i]; j++){\n                        int mpx, mpy;\n                        int mx, my;\n                        const int index= 4*i + block_width*j;\n                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];\n                        int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];\n                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);\n                        mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );\n                        my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );\n                        tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                        if(IS_SUB_8X8(sub_mb_type)){\n                            mv_cache[ 1 ][0]=\n                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;\n                            mv_cache[ 1 ][1]=\n                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;\n                            mvd_cache[ 1 ][0]=\n                            mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;\n                            mvd_cache[ 1 ][1]=\n                            mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;\n                        }else if(IS_SUB_8X4(sub_mb_type)){\n                            mv_cache[ 1 ][0]= mx;\n                            mv_cache[ 1 ][1]= my;\n                            mvd_cache[ 1 ][0]= mx - mpx;\n                            mvd_cache[ 1 ][1]= my - mpy;\n                        }else if(IS_SUB_4X8(sub_mb_type)){\n                            mv_cache[ 8 ][0]= mx;\n                            mv_cache[ 8 ][1]= my;\n                            mvd_cache[ 8 ][0]= mx - mpx;\n                            mvd_cache[ 8 ][1]= my - mpy;\n                        }\n                        mv_cache[ 0 ][0]= mx;\n                        mv_cache[ 0 ][1]= my;\n                        mvd_cache[ 0 ][0]= mx - mpx;\n                        mvd_cache[ 0 ][1]= my - mpy;\n                    }\n                }else{\n                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];\n                    uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];\n                    p[0] = p[1] = p[8] = p[9] = 0;\n                    pd[0]= pd[1]= pd[8]= pd[9]= 0;\n                }\n            }\n        }\n    } else if( IS_DIRECT(mb_type) ) {\n        ff_h264_pred_direct_motion(h, &mb_type);\n        fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);\n        fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);\n        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;\n    } else {\n        int list, mx, my, i, mpx, mpy;\n        if(IS_16X16(mb_type)){\n            for(list=0; list<h->list_count; list++){\n                if(IS_DIR(mb_type, 0, list)){\n                    int ref;\n                    if(h->ref_count[list] > 1){\n                        ref= decode_cabac_mb_ref(h, list, 0);\n                        if(ref >= (unsigned)h->ref_count[list]){\n                            av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\\n", ref, h->ref_count[list]);\n                            return -1;\n                        }\n                    }else\n                        ref=0;\n                        fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);\n                }else\n                    fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1);\n            }\n            for(list=0; list<h->list_count; list++){\n                if(IS_DIR(mb_type, 0, list)){\n                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);\n                    mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );\n                    my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );\n                    tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                    fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);\n                    fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);\n                }else\n                    fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);\n            }\n        }\n        else if(IS_16X8(mb_type)){\n            for(list=0; list<h->list_count; list++){\n                    for(i=0; i<2; i++){\n                        if(IS_DIR(mb_type, i, list)){\n                            int ref;\n                            if(h->ref_count[list] > 1){\n                                ref= decode_cabac_mb_ref( h, list, 8*i );\n                                if(ref >= (unsigned)h->ref_count[list]){\n                                    av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\\n", ref, h->ref_count[list]);\n                                    return -1;\n                                }\n                            }else\n                                ref=0;\n                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);\n                        }else\n                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);\n                    }\n            }\n            for(list=0; list<h->list_count; list++){\n                for(i=0; i<2; i++){\n                    if(IS_DIR(mb_type, i, list)){\n                        pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);\n                        mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );\n                        my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );\n                        tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);\n                        fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);\n                    }else{\n                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);\n                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);\n                    }\n                }\n            }\n        }else{\n            assert(IS_8X16(mb_type));\n            for(list=0; list<h->list_count; list++){\n                    for(i=0; i<2; i++){\n                        if(IS_DIR(mb_type, i, list)){\n                            int ref;\n                            if(h->ref_count[list] > 1){\n                                ref= decode_cabac_mb_ref( h, list, 4*i );\n                                if(ref >= (unsigned)h->ref_count[list]){\n                                    av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\\n", ref, h->ref_count[list]);\n                                    return -1;\n                                }\n                            }else\n                                ref=0;\n                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);\n                        }else\n                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);\n                    }\n            }\n            for(list=0; list<h->list_count; list++){\n                for(i=0; i<2; i++){\n                    if(IS_DIR(mb_type, i, list)){\n                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);\n                        mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );\n                        my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );\n                        tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);\n                        fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);\n                    }else{\n                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);\n                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);\n                    }\n                }\n            }\n        }\n    }\n   if( IS_INTER( mb_type ) ) {\n        h->chroma_pred_mode_table[mb_xy] = 0;\n        write_back_motion( h, mb_type );\n   }\n    if( !IS_INTRA16x16( mb_type ) ) {\n        cbp  = decode_cabac_mb_cbp_luma( h );\n        if(CHROMA)\n            cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;\n    }\n    h->cbp_table[mb_xy] = h->cbp = cbp;\n    if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {\n        if( decode_cabac_mb_transform_size( h ) )\n            mb_type |= MB_TYPE_8x8DCT;\n    }\n    s->current_picture.mb_type[mb_xy]= mb_type;\n    if( cbp || IS_INTRA16x16( mb_type ) ) {\n        const uint8_t *scan, *scan8x8, *dc_scan;\n        const uint32_t *qmul;\n        int dqp;\n        if(IS_INTERLACED(mb_type)){\n            scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;\n            scan= s->qscale ? h->field_scan : h->field_scan_q0;\n            dc_scan= luma_dc_field_scan;\n        }else{\n            scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;\n            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;\n            dc_scan= luma_dc_zigzag_scan;\n        }\n        h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );\n        if( dqp == INT_MIN ){\n            av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\\n", s->mb_x, s->mb_y);\n            return -1;\n        }\n        s->qscale += dqp;\n        if(((unsigned)s->qscale) > 51){\n            if(s->qscale<0) s->qscale+= 52;\n            else            s->qscale-= 52;\n        }\n        h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);\n        h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);\n        if( IS_INTRA16x16( mb_type ) ) {\n            int i;\n            decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);\n            if( cbp&15 ) {\n                qmul = h->dequant4_coeff[0][s->qscale];\n                for( i = 0; i < 16; i++ ) {\n                    decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);\n                }\n            } else {\n                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);\n            }\n        } else {\n            int i8x8, i4x4;\n            for( i8x8 = 0; i8x8 < 4; i8x8++ ) {\n                if( cbp & (1<<i8x8) ) {\n                    if( IS_8x8DCT(mb_type) ) {\n                        decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,\n                            scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);\n                    } else {\n                        qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];\n                        for( i4x4 = 0; i4x4 < 4; i4x4++ ) {\n                            const int index = 4*i8x8 + i4x4;\n                            decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);\n                        }\n                    }\n                } else {\n                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];\n                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;\n                }\n            }\n        }\n        if( cbp&0x30 ){\n            int c;\n            for( c = 0; c < 2; c++ ) {\n                decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);\n            }\n        }\n        if( cbp&0x20 ) {\n            int c, i;\n            for( c = 0; c < 2; c++ ) {\n                qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];\n                for( i = 0; i < 4; i++ ) {\n                    const int index = 16 + 4 * c + i;\n                    decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);\n                }\n            }\n        } else {\n            uint8_t * const nnz= &h->non_zero_count_cache[0];\n            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =\n            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;\n        }\n    } else {\n        uint8_t * const nnz= &h->non_zero_count_cache[0];\n        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);\n        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =\n        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;\n        h->last_qscale_diff = 0;\n    }\n    s->current_picture.qscale_table[mb_xy]= s->qscale;\n    write_back_non_zero_count(h);\n    if(MB_MBAFF){\n        h->ref_count[0] >>= 1;\n        h->ref_count[1] >>= 1;\n    }\n    return 0;\n}', 'static void fill_caches(H264Context *h, int mb_type, int for_deblock){\n    MpegEncContext * const s = &h->s;\n    const int mb_xy= h->mb_xy;\n    int topleft_xy, top_xy, topright_xy, left_xy[2];\n    int topleft_type, top_type, topright_type, left_type[2];\n    const uint8_t * left_block;\n    int topleft_partition= -1;\n    int i;\n    static const uint8_t left_block_options[4][8]={\n        {0,1,2,3,7,10,8,11},\n        {2,2,3,3,8,11,8,11},\n        {0,0,1,1,7,10,7,10},\n        {0,2,0,2,7,10,7,10}\n    };\n    top_xy     = mb_xy  - (s->mb_stride << FIELD_PICTURE);\n    if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[top_xy]) && !FRAME_MBAFF)\n        return;\n    topleft_xy = top_xy - 1;\n    topright_xy= top_xy + 1;\n    left_xy[1] = left_xy[0] = mb_xy-1;\n    left_block = left_block_options[0];\n    if(FRAME_MBAFF){\n        const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;\n        const int top_pair_xy      = pair_xy     - s->mb_stride;\n        const int topleft_pair_xy  = top_pair_xy - 1;\n        const int topright_pair_xy = top_pair_xy + 1;\n        const int topleft_mb_field_flag  = IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);\n        const int top_mb_field_flag      = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);\n        const int topright_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);\n        const int left_mb_field_flag     = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);\n        const int curr_mb_field_flag     = IS_INTERLACED(mb_type);\n        const int bottom = (s->mb_y & 1);\n        tprintf(s->avctx, "fill_caches: curr_mb_field_flag:%d, left_mb_field_flag:%d, topleft_mb_field_flag:%d, top_mb_field_flag:%d, topright_mb_field_flag:%d\\n", curr_mb_field_flag, left_mb_field_flag, topleft_mb_field_flag, top_mb_field_flag, topright_mb_field_flag);\n        if (curr_mb_field_flag && (bottom || top_mb_field_flag)){\n            top_xy -= s->mb_stride;\n        }\n        if (curr_mb_field_flag && (bottom || topleft_mb_field_flag)){\n            topleft_xy -= s->mb_stride;\n        } else if(bottom && !curr_mb_field_flag && left_mb_field_flag) {\n            topleft_xy += s->mb_stride;\n            topleft_partition = 0;\n        }\n        if (curr_mb_field_flag && (bottom || topright_mb_field_flag)){\n            topright_xy -= s->mb_stride;\n        }\n        if (left_mb_field_flag != curr_mb_field_flag) {\n            left_xy[1] = left_xy[0] = pair_xy - 1;\n            if (curr_mb_field_flag) {\n                left_xy[1] += s->mb_stride;\n                left_block = left_block_options[3];\n            } else {\n                left_block= left_block_options[2 - bottom];\n            }\n        }\n    }\n    h->top_mb_xy = top_xy;\n    h->left_mb_xy[0] = left_xy[0];\n    h->left_mb_xy[1] = left_xy[1];\n    if(for_deblock){\n        topleft_type = 0;\n        topright_type = 0;\n        top_type     = h->slice_table[top_xy     ] < 0xFFFF ? s->current_picture.mb_type[top_xy]     : 0;\n        left_type[0] = h->slice_table[left_xy[0] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[0]] : 0;\n        left_type[1] = h->slice_table[left_xy[1] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[1]] : 0;\n        if(MB_MBAFF && !IS_INTRA(mb_type)){\n            int list;\n            for(list=0; list<h->list_count; list++){\n                if(USES_LIST(mb_type,list)){\n                    int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]];\n                    *(uint32_t*)&h->ref_cache[list][scan8[ 0]] =\n                    *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101;\n                    ref += h->b8_stride;\n                    *(uint32_t*)&h->ref_cache[list][scan8[ 8]] =\n                    *(uint32_t*)&h->ref_cache[list][scan8[10]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101;\n                }\n            }\n        }\n    }else{\n        topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;\n        top_type     = h->slice_table[top_xy     ] == h->slice_num ? s->current_picture.mb_type[top_xy]     : 0;\n        topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;\n        left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;\n        left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;\n    if(IS_INTRA(mb_type)){\n        int type_mask= h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;\n        h->topleft_samples_available=\n        h->top_samples_available=\n        h->left_samples_available= 0xFFFF;\n        h->topright_samples_available= 0xEEEA;\n        if(!(top_type & type_mask)){\n            h->topleft_samples_available= 0xB3FF;\n            h->top_samples_available= 0x33FF;\n            h->topright_samples_available= 0x26EA;\n        }\n        if(IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[0])){\n            if(IS_INTERLACED(mb_type)){\n                if(!(left_type[0] & type_mask)){\n                    h->topleft_samples_available&= 0xDFFF;\n                    h->left_samples_available&= 0x5FFF;\n                }\n                if(!(left_type[1] & type_mask)){\n                    h->topleft_samples_available&= 0xFF5F;\n                    h->left_samples_available&= 0xFF5F;\n                }\n            }else{\n                int left_typei = h->slice_table[left_xy[0] + s->mb_stride ] == h->slice_num\n                                ? s->current_picture.mb_type[left_xy[0] + s->mb_stride] : 0;\n                assert(left_xy[0] == left_xy[1]);\n                if(!((left_typei & type_mask) && (left_type[0] & type_mask))){\n                    h->topleft_samples_available&= 0xDF5F;\n                    h->left_samples_available&= 0x5F5F;\n                }\n            }\n        }else{\n            if(!(left_type[0] & type_mask)){\n                h->topleft_samples_available&= 0xDF5F;\n                h->left_samples_available&= 0x5F5F;\n            }\n        }\n        if(!(topleft_type & type_mask))\n            h->topleft_samples_available&= 0x7FFF;\n        if(!(topright_type & type_mask))\n            h->topright_samples_available&= 0xFBFF;\n        if(IS_INTRA4x4(mb_type)){\n            if(IS_INTRA4x4(top_type)){\n                h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];\n                h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];\n                h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];\n                h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];\n            }else{\n                int pred;\n                if(!(top_type & type_mask))\n                    pred= -1;\n                else{\n                    pred= 2;\n                }\n                h->intra4x4_pred_mode_cache[4+8*0]=\n                h->intra4x4_pred_mode_cache[5+8*0]=\n                h->intra4x4_pred_mode_cache[6+8*0]=\n                h->intra4x4_pred_mode_cache[7+8*0]= pred;\n            }\n            for(i=0; i<2; i++){\n                if(IS_INTRA4x4(left_type[i])){\n                    h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];\n                    h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];\n                }else{\n                    int pred;\n                    if(!(left_type[i] & type_mask))\n                        pred= -1;\n                    else{\n                        pred= 2;\n                    }\n                    h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=\n                    h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;\n                }\n            }\n        }\n    }\n    }\n    if(top_type){\n        h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4];\n        h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5];\n        h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6];\n        h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];\n        h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9];\n        h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];\n        h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12];\n        h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];\n    }else{\n        h->non_zero_count_cache[4+8*0]=\n        h->non_zero_count_cache[5+8*0]=\n        h->non_zero_count_cache[6+8*0]=\n        h->non_zero_count_cache[7+8*0]=\n        h->non_zero_count_cache[1+8*0]=\n        h->non_zero_count_cache[2+8*0]=\n        h->non_zero_count_cache[1+8*3]=\n        h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;\n    }\n    for (i=0; i<2; i++) {\n        if(left_type[i]){\n            h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]];\n            h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]];\n            h->non_zero_count_cache[0+8*1 +   8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]];\n            h->non_zero_count_cache[0+8*4 +   8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]];\n        }else{\n            h->non_zero_count_cache[3+8*1 + 2*8*i]=\n            h->non_zero_count_cache[3+8*2 + 2*8*i]=\n            h->non_zero_count_cache[0+8*1 +   8*i]=\n            h->non_zero_count_cache[0+8*4 +   8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;\n        }\n    }\n    if( h->pps.cabac ) {\n        if(top_type) {\n            h->top_cbp = h->cbp_table[top_xy];\n        } else if(IS_INTRA(mb_type)) {\n            h->top_cbp = 0x1C0;\n        } else {\n            h->top_cbp = 0;\n        }\n        if (left_type[0]) {\n            h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;\n        } else if(IS_INTRA(mb_type)) {\n            h->left_cbp = 0x1C0;\n        } else {\n            h->left_cbp = 0;\n        }\n        if (left_type[0]) {\n            h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1;\n        }\n        if (left_type[1]) {\n            h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3;\n        }\n    }\n#if 1\n    if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){\n        int list;\n        for(list=0; list<h->list_count; list++){\n            if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){\n                continue;\n            }\n            h->mv_cache_clean[list]= 0;\n            if(USES_LIST(top_type, list)){\n                const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;\n                const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;\n                *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];\n                *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];\n                *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];\n                *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];\n                h->ref_cache[list][scan8[0] + 0 - 1*8]=\n                h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];\n                h->ref_cache[list][scan8[0] + 2 - 1*8]=\n                h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];\n            }else{\n                *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]=\n                *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]=\n                *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]=\n                *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;\n                *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;\n            }\n            for(i=0; i<2; i++){\n                int cache_idx = scan8[0] - 1 + i*2*8;\n                if(USES_LIST(left_type[i], list)){\n                    const int b_xy= h->mb2b_xy[left_xy[i]] + 3;\n                    const int b8_xy= h->mb2b8_xy[left_xy[i]] + 1;\n                    *(uint32_t*)h->mv_cache[list][cache_idx  ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0+i*2]];\n                    *(uint32_t*)h->mv_cache[list][cache_idx+8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1+i*2]];\n                    h->ref_cache[list][cache_idx  ]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0+i*2]>>1)];\n                    h->ref_cache[list][cache_idx+8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1+i*2]>>1)];\n                }else{\n                    *(uint32_t*)h->mv_cache [list][cache_idx  ]=\n                    *(uint32_t*)h->mv_cache [list][cache_idx+8]= 0;\n                    h->ref_cache[list][cache_idx  ]=\n                    h->ref_cache[list][cache_idx+8]= left_type[i] ? LIST_NOT_USED : PART_NOT_AVAILABLE;\n                }\n            }\n            if(for_deblock || ((IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred) && !FRAME_MBAFF))\n                continue;\n            if(USES_LIST(topleft_type, list)){\n                const int b_xy = h->mb2b_xy[topleft_xy] + 3 + h->b_stride + (topleft_partition & 2*h->b_stride);\n                const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + (topleft_partition & h->b8_stride);\n                *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];\n                h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];\n            }else{\n                *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;\n                h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;\n            }\n            if(USES_LIST(topright_type, list)){\n                const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;\n                const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;\n                *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];\n                h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];\n            }else{\n                *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;\n                h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;\n            }\n            if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF)\n                continue;\n            h->ref_cache[list][scan8[5 ]+1] =\n            h->ref_cache[list][scan8[7 ]+1] =\n            h->ref_cache[list][scan8[13]+1] =\n            h->ref_cache[list][scan8[4 ]] =\n            h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;\n            *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=\n            *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=\n            *(uint32_t*)h->mv_cache [list][scan8[13]+1]=\n            *(uint32_t*)h->mv_cache [list][scan8[4 ]]=\n            *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;\n            if( h->pps.cabac ) {\n                if(USES_LIST(top_type, list)){\n                    const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;\n                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0];\n                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1];\n                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2];\n                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3];\n                }else{\n                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]=\n                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]=\n                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]=\n                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0;\n                }\n                if(USES_LIST(left_type[0], list)){\n                    const int b_xy= h->mb2b_xy[left_xy[0]] + 3;\n                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[0]];\n                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[1]];\n                }else{\n                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]=\n                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0;\n                }\n                if(USES_LIST(left_type[1], list)){\n                    const int b_xy= h->mb2b_xy[left_xy[1]] + 3;\n                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[2]];\n                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[3]];\n                }else{\n                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]=\n                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0;\n                }\n                *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]=\n                *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]=\n                *(uint32_t*)h->mvd_cache [list][scan8[13]+1]=\n                *(uint32_t*)h->mvd_cache [list][scan8[4 ]]=\n                *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0;\n                if(h->slice_type_nos == FF_B_TYPE){\n                    fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1);\n                    if(IS_DIRECT(top_type)){\n                        *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101;\n                    }else if(IS_8X8(top_type)){\n                        int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride;\n                        h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy];\n                        h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1];\n                    }else{\n                        *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0;\n                    }\n                    if(IS_DIRECT(left_type[0]))\n                        h->direct_cache[scan8[0] - 1 + 0*8]= 1;\n                    else if(IS_8X8(left_type[0]))\n                        h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[h->mb2b8_xy[left_xy[0]] + 1 + h->b8_stride*(left_block[0]>>1)];\n                    else\n                        h->direct_cache[scan8[0] - 1 + 0*8]= 0;\n                    if(IS_DIRECT(left_type[1]))\n                        h->direct_cache[scan8[0] - 1 + 2*8]= 1;\n                    else if(IS_8X8(left_type[1]))\n                        h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[h->mb2b8_xy[left_xy[1]] + 1 + h->b8_stride*(left_block[2]>>1)];\n                    else\n                        h->direct_cache[scan8[0] - 1 + 2*8]= 0;\n                }\n            }\n            if(FRAME_MBAFF){\n#define MAP_MVS\\\n                    MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\\\n                    MAP_F2F(scan8[0] + 0 - 1*8, top_type)\\\n                    MAP_F2F(scan8[0] + 1 - 1*8, top_type)\\\n                    MAP_F2F(scan8[0] + 2 - 1*8, top_type)\\\n                    MAP_F2F(scan8[0] + 3 - 1*8, top_type)\\\n                    MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\\\n                    MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\\\n                    MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\\\n                    MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\\\n                    MAP_F2F(scan8[0] - 1 + 3*8, left_type[1])\n                if(MB_FIELD){\n#define MAP_F2F(idx, mb_type)\\\n                    if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\\\n                        h->ref_cache[list][idx] <<= 1;\\\n                        h->mv_cache[list][idx][1] /= 2;\\\n                        h->mvd_cache[list][idx][1] /= 2;\\\n                    }\n                    MAP_MVS\n#undef MAP_F2F\n                }else{\n#define MAP_F2F(idx, mb_type)\\\n                    if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\\\n                        h->ref_cache[list][idx] >>= 1;\\\n                        h->mv_cache[list][idx][1] <<= 1;\\\n                        h->mvd_cache[list][idx][1] <<= 1;\\\n                    }\n                    MAP_MVS\n#undef MAP_F2F\n                }\n            }\n        }\n    }\n#endif\n    h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);\n}', 'static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {\n#if CONFIG_SMALL\n    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);\n#else\n    if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);\n    else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);\n#endif\n}', 'static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {\n    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);\n}', 'static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {\n    static const int significant_coeff_flag_offset[2][6] = {\n      { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },\n      { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }\n    };\n    static const int last_coeff_flag_offset[2][6] = {\n      { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },\n      { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }\n    };\n    static const int coeff_abs_level_m1_offset[6] = {\n        227+0, 227+10, 227+20, 227+30, 227+39, 426\n    };\n    static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {\n      { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,\n        4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,\n        7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,\n       12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },\n      { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,\n        6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,\n        9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,\n        9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }\n    };\n    static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };\n    static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };\n    static const uint8_t coeff_abs_level_transition[2][8] = {\n        { 1, 2, 3, 3, 4, 5, 6, 7 },\n        { 4, 4, 4, 4, 5, 6, 7, 7 }\n    };\n    int index[64];\n    int av_unused last;\n    int coeff_count = 0;\n    int node_ctx = 0;\n    uint8_t *significant_coeff_ctx_base;\n    uint8_t *last_coeff_ctx_base;\n    uint8_t *abs_level_m1_ctx_base;\n#if !ARCH_X86\n#define CABAC_ON_STACK\n#endif\n#ifdef CABAC_ON_STACK\n#define CC &cc\n    CABACContext cc;\n    cc.range     = h->cabac.range;\n    cc.low       = h->cabac.low;\n    cc.bytestream= h->cabac.bytestream;\n#else\n#define CC &h->cabac\n#endif\n    if( is_dc || cat != 5 ) {\n        if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {\n            if( !is_dc )\n                h->non_zero_count_cache[scan8[n]] = 0;\n#ifdef CABAC_ON_STACK\n            h->cabac.range     = cc.range     ;\n            h->cabac.low       = cc.low       ;\n            h->cabac.bytestream= cc.bytestream;\n#endif\n            return;\n        }\n    }\n    significant_coeff_ctx_base = h->cabac_state\n        + significant_coeff_flag_offset[MB_FIELD][cat];\n    last_coeff_ctx_base = h->cabac_state\n        + last_coeff_flag_offset[MB_FIELD][cat];\n    abs_level_m1_ctx_base = h->cabac_state\n        + coeff_abs_level_m1_offset[cat];\n    if( !is_dc && cat == 5 ) {\n#define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \\\n        for(last= 0; last < coefs; last++) { \\\n            uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \\\n            if( get_cabac( CC, sig_ctx )) { \\\n                uint8_t *last_ctx = last_coeff_ctx_base + last_off; \\\n                index[coeff_count++] = last; \\\n                if( get_cabac( CC, last_ctx ) ) { \\\n                    last= max_coeff; \\\n                    break; \\\n                } \\\n            } \\\n        }\\\n        if( last == max_coeff -1 ) {\\\n            index[coeff_count++] = last;\\\n        }\n        const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];\n#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)\n        coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);\n    } else {\n        coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);\n#else\n        DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );\n    } else {\n        DECODE_SIGNIFICANCE( max_coeff - 1, last, last );\n#endif\n    }\n    assert(coeff_count > 0);\n    if( is_dc ) {\n        if( cat == 0 )\n            h->cbp_table[h->mb_xy] |= 0x100;\n        else\n            h->cbp_table[h->mb_xy] |= 0x40 << n;\n    } else {\n        if( cat == 5 )\n            fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);\n        else {\n            assert( cat == 1 || cat == 2 || cat == 4 );\n            h->non_zero_count_cache[scan8[n]] = coeff_count;\n        }\n    }\n    do {\n        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;\n        int j= scantable[index[--coeff_count]];\n        if( get_cabac( CC, ctx ) == 0 ) {\n            node_ctx = coeff_abs_level_transition[0][node_ctx];\n            if( is_dc ) {\n                block[j] = get_cabac_bypass_sign( CC, -1);\n            }else{\n                block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;\n            }\n        } else {\n            int coeff_abs = 2;\n            ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;\n            node_ctx = coeff_abs_level_transition[1][node_ctx];\n            while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {\n                coeff_abs++;\n            }\n            if( coeff_abs >= 15 ) {\n                int j = 0;\n                while( get_cabac_bypass( CC ) ) {\n                    j++;\n                }\n                coeff_abs=1;\n                while( j-- ) {\n                    coeff_abs += coeff_abs + get_cabac_bypass( CC );\n                }\n                coeff_abs+= 14;\n            }\n            if( is_dc ) {\n                block[j] = get_cabac_bypass_sign( CC, -coeff_abs );\n            }else{\n                block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;\n            }\n        }\n    } while( coeff_count );\n#ifdef CABAC_ON_STACK\n            h->cabac.range     = cc.range     ;\n            h->cabac.low       = cc.low       ;\n            h->cabac.bytestream= cc.bytestream;\n#endif\n}']