libavcodec/h264_cabac.c:2356: 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_luma_residual`.

libavcodec/h264_cabac.c:1876:1: Parameter `h->mb_field_decoding_flag`
1874.  * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR if an error is noticed
1875.  */
1876. int ff_h264_decode_mb_cabac(H264Context *h) {
      ^
1877.     int mb_xy;
1878.     int mb_type, partition_count, cbp = 0;

libavcodec/h264_cabac.c:2023:5: Call
2021.     }
2022. 
2023.     fill_decode_caches(h, mb_type);
          ^
2024. 
2025.     if( IS_INTRA( mb_type ) ) {

libavcodec/h264_mvpred.h:439:1: Parameter `h->mb_field_decoding_flag`
  437. }
  438. 
  439. static void fill_decode_caches(H264Context *h, int mb_type)
       ^
  440. {
  441.     int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];

libavcodec/h264_cabac.c:2356:9: Call
2354.             h->last_qscale_diff=0;
2355. 
2356.         decode_cabac_luma_residual(h, scan, scan8x8, pixel_shift, mb_type, cbp, 0);
              ^
2357.         if (CHROMA444(h)) {
2358.             decode_cabac_luma_residual(h, scan, scan8x8, pixel_shift, mb_type, cbp, 1);

libavcodec/h264_cabac.c:1826:1: Parameter `h->mb_field_decoding_flag`
  1824. }
  1825. 
  1826. static av_always_inline void decode_cabac_luma_residual( H264Context *h, const uint8_t *scan, const uint8_t *scan8x8, int pixel_shift, int mb_type, int cbp, int p )
        ^
  1827. {
  1828.     static const uint8_t ctx_cat[4][3] = {{0,6,10},{1,7,11},{2,8,12},{5,9,13}};

libavcodec/h264_cabac.c:1837:9: Call
  1835.         AV_ZERO128(h->mb_luma_dc[p]+16);
  1836.         AV_ZERO128(h->mb_luma_dc[p]+24);
  1837.         decode_cabac_residual_dc(h, h->mb_luma_dc[p], ctx_cat[0][p], LUMA_DC_BLOCK_INDEX+p, scan, 16);
                ^
  1838. 
  1839.         if( cbp&15 ) {

libavcodec/h264_cabac.c:1780:1: Parameter `h->mb_field_decoding_flag`
    1778.  * as well as because most blocks have zero CBFs. */
    1779. 
    1780. static av_always_inline void decode_cabac_residual_dc(H264Context *h,
          ^
    1781.                                                       int16_t *block,
    1782.                                                       int cat, int n,

libavcodec/h264_cabac.c:1791:5: Call
    1789.         return;
    1790.     }
    1791.     decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );
              ^
    1792. }
    1793. 

libavcodec/h264_cabac.c:1744:1: Parameter `h->mb_field_decoding_flag`
      1742. }
      1743. 
      1744. static void decode_cabac_residual_dc_internal(H264Context *h, int16_t *block,
            ^
      1745.                                               int cat, int n,
      1746.                                               const uint8_t *scantable,

libavcodec/h264_cabac.c:1749:5: Call
      1747.                                               int max_coeff)
      1748. {
      1749.     decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1, 0);
                ^
      1750. }
      1751. 

libavcodec/h264_cabac.c:1662:9: <Offset trace>
1660.         }
1661. #else
1662.         DECODE_SIGNIFICANCE( 63, sig_off[last], ff_h264_last_coeff_flag_offset_8x8[last] );
              ^
1663.     } else {
1664.         if (is_dc && chroma422) { // dc 422

libavcodec/h264_cabac.c:1662:9: Assignment
        1660.         }
        1661. #else
        1662.         DECODE_SIGNIFICANCE( 63, sig_off[last], ff_h264_last_coeff_flag_offset_8x8[last] );
                      ^
        1663.     } else {
        1664.         if (is_dc && chroma422) { // dc 422

libavcodec/h264_cabac.c:1559:1: <Length trace>
1557. }
1558. 
1559. static av_always_inline void
      ^
1560. decode_cabac_residual_internal(H264Context *h, int16_t *block,
1561.                                int cat, int n, const uint8_t *scantable,

libavcodec/h264_cabac.c:1559:1: Parameter `h->mb_field_decoding_flag`
        1557. }
        1558. 
        1559. static av_always_inline void
              ^
        1560. decode_cabac_residual_internal(H264Context *h, int16_t *block,
        1561.                                int cat, int n, const uint8_t *scantable,

libavcodec/h264_cabac.c:1650:9: Assignment
        1648.             index[coeff_count++] = last;\
        1649.         }
        1650.         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD(h)];
                      ^
        1651. #ifdef decode_significance
        1652.         coeff_count = decode_significance_8x8(CC, significant_coeff_ctx_base, index,

libavcodec/h264_cabac.c:1662: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_luma_residual` 
        1660.         }
        1661. #else
        1662.         DECODE_SIGNIFICANCE( 63, sig_off[last], ff_h264_last_coeff_flag_offset_8x8[last] );
                      ^
        1663.     } else {
        1664.         if (is_dc && chroma422) { // dc 422

static av_always_inline void
decode_cabac_residual_internal(H264Context *h, int16_t *block,
                               int cat, int n, const uint8_t *scantable,
                               const uint32_t *qmul, int max_coeff,
                               int is_dc, int chroma422)
{
    static const int significant_coeff_flag_offset[2][14] = {
      { 105+0, 105+15, 105+29, 105+44, 105+47, 402, 484+0, 484+15, 484+29, 660, 528+0, 528+15, 528+29, 718 },
      { 277+0, 277+15, 277+29, 277+44, 277+47, 436, 776+0, 776+15, 776+29, 675, 820+0, 820+15, 820+29, 733 }
    };
    static const int last_coeff_flag_offset[2][14] = {
      { 166+0, 166+15, 166+29, 166+44, 166+47, 417, 572+0, 572+15, 572+29, 690, 616+0, 616+15, 616+29, 748 },
      { 338+0, 338+15, 338+29, 338+44, 338+47, 451, 864+0, 864+15, 864+29, 699, 908+0, 908+15, 908+29, 757 }
    };
    static const int coeff_abs_level_m1_offset[14] = {
        227+0, 227+10, 227+20, 227+30, 227+39, 426, 952+0, 952+10, 952+20, 708, 982+0, 982+10, 982+20, 766
    };
    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 sig_coeff_offset_dc[7] = { 0, 0, 1, 1, 2, 2, 2 };
    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[2][8] = {
        { 5, 5, 5, 5, 6, 7, 8, 9 },
        { 5, 5, 5, 5, 6, 7, 8, 8 },
    };
    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;
    cc.bytestream_end = h->cabac.bytestream_end;
#else
#define CC &h->cabac
#endif
    significant_coeff_ctx_base = h->cabac_state
        + significant_coeff_flag_offset[MB_FIELD(h)][cat];
    last_coeff_ctx_base = h->cabac_state
        + last_coeff_flag_offset[MB_FIELD(h)][cat];
    abs_level_m1_ctx_base = h->cabac_state
        + coeff_abs_level_m1_offset[cat];
    if( !is_dc && max_coeff == 64 ) {
#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(h)];
#ifdef decode_significance
        coeff_count = decode_significance_8x8(CC, significant_coeff_ctx_base, index,
                                                 last_coeff_ctx_base, sig_off);
    } else {
        if (is_dc && chroma422) {
            DECODE_SIGNIFICANCE(7, sig_coeff_offset_dc[last], sig_coeff_offset_dc[last]);
        } else {
            coeff_count = decode_significance(CC, max_coeff, significant_coeff_ctx_base, index,
                                                 last_coeff_ctx_base-significant_coeff_ctx_base);
        }
#else
        DECODE_SIGNIFICANCE( 63, sig_off[last], ff_h264_last_coeff_flag_offset_8x8[last] );
    } else {
        if (is_dc && chroma422) {
            DECODE_SIGNIFICANCE(7, sig_coeff_offset_dc[last], sig_coeff_offset_dc[last]);
        } else {
            DECODE_SIGNIFICANCE(max_coeff - 1, last, last);
        }
#endif
    }
    assert(coeff_count > 0);
    if( is_dc ) {
        if( cat == 3 )
            h->cbp_table[h->mb_xy] |= 0x40 << (n - CHROMA_DC_BLOCK_INDEX);
        else
            h->cbp_table[h->mb_xy] |= 0x100 << (n - LUMA_DC_BLOCK_INDEX);
        h->non_zero_count_cache[scan8[n]] = coeff_count;
    } else {
        if( max_coeff == 64 )
            fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
        else {
            assert( cat == 1 || cat ==  2 || cat ==  4 || cat == 7 || cat == 8 || cat == 11 || cat == 12 );
            h->non_zero_count_cache[scan8[n]] = coeff_count;
        }
    }
#define STORE_BLOCK(type) \
    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 ) { \
                ((type*)block)[j] = get_cabac_bypass_sign( CC, -1); \
            }else{ \
                ((type*)block)[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; \
            } \
        } else { \
            int coeff_abs = 2; \
            ctx = coeff_abs_levelgt1_ctx[is_dc && chroma422][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 ) { \
                ((type*)block)[j] = get_cabac_bypass_sign( CC, -coeff_abs ); \
            }else{ \
                ((type*)block)[j] = ((int)(get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32)) >> 6; \
            } \
        } \
    } while ( coeff_count );
    if (h->pixel_shift) {
        STORE_BLOCK(int32_t)
    } else {
        STORE_BLOCK(int16_t)
    }
#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    int mb_xy;\n    int mb_type, partition_count, cbp = 0;\n    int dct8x8_allowed= h->pps.transform_8x8_mode;\n    int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;\n    const int pixel_shift = h->pixel_shift;\n    mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;\n    tprintf(h->avctx, "pic:%d mb:%d/%d\\n", h->frame_num, h->mb_x, h->mb_y);\n    if( h->slice_type_nos != AV_PICTURE_TYPE_I ) {\n        int skip;\n        if (FRAME_MBAFF(h) && (h->mb_y & 1) == 1 && h->prev_mb_skipped)\n            skip = h->next_mb_skipped;\n        else\n            skip = decode_cabac_mb_skip( h, h->mb_x, h->mb_y );\n        if( skip ) {\n            if (FRAME_MBAFF(h) && (h->mb_y & 1) == 0) {\n                h->cur_pic.mb_type[mb_xy] = MB_TYPE_SKIP;\n                h->next_mb_skipped = decode_cabac_mb_skip( h, h->mb_x, h->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(h)) {\n        if( (h->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    fill_decode_neighbors(h, -(MB_FIELD(h)));\n    if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {\n        int ctx = 0;\n        assert(h->slice_type_nos == AV_PICTURE_TYPE_B);\n        if( !IS_DIRECT( h->left_type[LTOP]-1 ) )\n            ctx++;\n        if( !IS_DIRECT( h->top_type-1 ) )\n            ctx++;\n        if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){\n            mb_type= 0;\n        }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {\n            mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );\n        }else{\n            int bits;\n            bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;\n            bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;\n            bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;\n            bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );\n            if( bits < 8 ){\n                mb_type= bits + 3;\n            }else if( bits == 13 ){\n                mb_type= decode_cabac_intra_mb_type(h, 32, 0);\n                goto decode_intra_mb;\n            }else if( bits == 14 ){\n                mb_type= 11;\n            }else if( bits == 15 ){\n                mb_type= 22;\n            }else{\n                bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );\n                mb_type= bits - 4;\n            }\n        }\n            partition_count= b_mb_type_info[mb_type].partition_count;\n            mb_type=         b_mb_type_info[mb_type].type;\n    } else if( h->slice_type_nos == AV_PICTURE_TYPE_P ) {\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 == AV_PICTURE_TYPE_SI && mb_type)\n            mb_type--;\n        assert(h->slice_type_nos == AV_PICTURE_TYPE_I);\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(h))\n        mb_type |= MB_TYPE_INTERLACED;\n    h->slice_table[ mb_xy ]= h->slice_num;\n    if(IS_INTRA_PCM(mb_type)) {\n        const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *\n                            h->sps.bit_depth_luma >> 3;\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        if ((int) (h->cabac.bytestream_end - ptr) < mb_size)\n            return -1;\n        h->intra_pcm_ptr = ptr;\n        ptr += mb_size;\n        ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);\n        h->cbp_table[mb_xy] = 0xf7ef;\n        h->chroma_pred_mode_table[mb_xy] = 0;\n        h->cur_pic.qscale_table[mb_xy] = 0;\n        memset(h->non_zero_count[mb_xy], 16, 48);\n        h->cur_pic.mb_type[mb_xy] = mb_type;\n        h->last_qscale_diff = 0;\n        return 0;\n    }\n    fill_decode_caches(h, mb_type);\n    if( IS_INTRA( mb_type ) ) {\n        int i, pred_mode;\n        if( IS_INTRA4x4( mb_type ) ) {\n            if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {\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                    av_dlog(h->avctx, "i4x4 pred=%d mode=%d\\n", pred,\n                            h->intra4x4_pred_mode_cache[scan8[i]]);\n                }\n            }\n            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, 0 );\n            if( h->intra16x16_pred_mode < 0 ) return -1;\n        }\n        if(decode_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, 1 );\n            if( pred_mode < 0 ) return -1;\n            h->chroma_pred_mode= pred_mode;\n        } else {\n            h->chroma_pred_mode= DC_128_PRED8x8;\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 == AV_PICTURE_TYPE_B ) {\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                    for( i = 0; i < 4; i++ )\n                        fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );\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                        int rc = h->ref_count[list] << MB_MBAFF(h);\n                        if (rc > 1) {\n                            ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );\n                            if (ref[list][i] >= (unsigned) rc) {\n                                av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\\n", ref[list][i], rc);\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, 2);\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                        uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];\n                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);\n                        DECODE_CABAC_MB_MVD( h, list, index)\n                        tprintf(h->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]= mpx;\n                            mvd_cache[ 1 ][1]=\n                            mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= 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]=  mpx;\n                            mvd_cache[ 1 ][1]= 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]= mpx;\n                            mvd_cache[ 8 ][1]= mpy;\n                        }\n                        mv_cache[ 0 ][0]= mx;\n                        mv_cache[ 0 ][1]= my;\n                        mvd_cache[ 0 ][0]= mpx;\n                        mvd_cache[ 0 ][1]= mpy;\n                    }\n                }else{\n                    fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);\n                    fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);\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, 2);\n        fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);\n        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;\n    } else {\n        int list, i;\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, rc = h->ref_count[list] << MB_MBAFF(h);\n                    if (rc > 1) {\n                        ref= decode_cabac_mb_ref(h, list, 0);\n                        if (ref >= (unsigned) rc) {\n                            av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\\n", ref, rc);\n                            return -1;\n                        }\n                    }else\n                        ref=0;\n                        fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);\n                }\n            }\n            for(list=0; list<h->list_count; list++){\n                if(IS_DIR(mb_type, 0, list)){\n                    int mx,my,mpx,mpy;\n                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);\n                    DECODE_CABAC_MB_MVD( h, list, 0)\n                    tprintf(h->avctx, "final mv:%d %d\\n", mx, my);\n                    fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);\n                    fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);\n                }\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, rc = h->ref_count[list] << MB_MBAFF(h);\n                            if (rc > 1) {\n                                ref= decode_cabac_mb_ref( h, list, 8*i );\n                                if (ref >= (unsigned) rc) {\n                                    av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\\n", ref, rc);\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                        int mx,my,mpx,mpy;\n                        pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);\n                        DECODE_CABAC_MB_MVD( h, list, 8*i)\n                        tprintf(h->avctx, "final mv:%d %d\\n", mx, my);\n                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);\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, 2);\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, rc = h->ref_count[list] << MB_MBAFF(h);\n                            if (rc > 1) {\n                                ref= decode_cabac_mb_ref( h, list, 4*i );\n                                if (ref >= (unsigned) rc) {\n                                    av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\\n", ref, rc);\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                        int mx,my,mpx,mpy;\n                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);\n                        DECODE_CABAC_MB_MVD( h, list, 4*i)\n                        tprintf(h->avctx, "final mv:%d %d\\n", mx, my);\n                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);\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, 2);\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(decode_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        mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );\n    }\n    if (CHROMA444(h) && IS_8x8DCT(mb_type)){\n        int i;\n        uint8_t *nnz_cache = h->non_zero_count_cache;\n        for (i = 0; i < 2; i++){\n            if (h->left_type[LEFT(i)] && !IS_8x8DCT(h->left_type[LEFT(i)])){\n                nnz_cache[3+8* 1 + 2*8*i]=\n                nnz_cache[3+8* 2 + 2*8*i]=\n                nnz_cache[3+8* 6 + 2*8*i]=\n                nnz_cache[3+8* 7 + 2*8*i]=\n                nnz_cache[3+8*11 + 2*8*i]=\n                nnz_cache[3+8*12 + 2*8*i]= IS_INTRA(mb_type) ? 64 : 0;\n            }\n        }\n        if (h->top_type && !IS_8x8DCT(h->top_type)){\n            uint32_t top_empty = CABAC(h) && !IS_INTRA(mb_type) ? 0 : 0x40404040;\n            AV_WN32A(&nnz_cache[4+8* 0], top_empty);\n            AV_WN32A(&nnz_cache[4+8* 5], top_empty);\n            AV_WN32A(&nnz_cache[4+8*10], top_empty);\n        }\n    }\n    h->cur_pic.mb_type[mb_xy] = mb_type;\n    if( cbp || IS_INTRA16x16( mb_type ) ) {\n        const uint8_t *scan, *scan8x8;\n        const uint32_t *qmul;\n        if(IS_INTERLACED(mb_type)){\n            scan8x8= h->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;\n            scan= h->qscale ? h->field_scan : h->field_scan_q0;\n        }else{\n            scan8x8= h->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;\n            scan= h->qscale ? h->zigzag_scan : h->zigzag_scan_q0;\n        }\n        if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){\n            int val = 1;\n            int ctx= 2;\n            const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);\n            while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {\n                ctx= 3;\n                val++;\n                if(val > 2*max_qp){\n                    av_log(h->avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\\n", h->mb_x, h->mb_y);\n                    return -1;\n                }\n            }\n            if( val&0x01 )\n                val=   (val + 1)>>1 ;\n            else\n                val= -((val + 1)>>1);\n            h->last_qscale_diff = val;\n            h->qscale += val;\n            if(((unsigned)h->qscale) > max_qp){\n                if(h->qscale<0) h->qscale+= max_qp+1;\n                else            h->qscale-= max_qp+1;\n            }\n            h->chroma_qp[0] = get_chroma_qp(h, 0, h->qscale);\n            h->chroma_qp[1] = get_chroma_qp(h, 1, h->qscale);\n        }else\n            h->last_qscale_diff=0;\n        decode_cabac_luma_residual(h, scan, scan8x8, pixel_shift, mb_type, cbp, 0);\n        if (CHROMA444(h)) {\n            decode_cabac_luma_residual(h, scan, scan8x8, pixel_shift, mb_type, cbp, 1);\n            decode_cabac_luma_residual(h, scan, scan8x8, pixel_shift, mb_type, cbp, 2);\n        } else if (CHROMA422(h)) {\n            if( cbp&0x30 ){\n                int c;\n                for (c = 0; c < 2; c++)\n                    decode_cabac_residual_dc_422(h, h->mb + ((256 + 16*16*c) << pixel_shift), 3,\n                                                 CHROMA_DC_BLOCK_INDEX + c,\n                                                 chroma422_dc_scan, 8);\n            }\n            if( cbp&0x20 ) {\n                int c, i, i8x8;\n                for( c = 0; c < 2; c++ ) {\n                    int16_t *mb = h->mb + (16*(16 + 16*c) << pixel_shift);\n                    qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];\n                    for (i8x8 = 0; i8x8 < 2; i8x8++) {\n                        for (i = 0; i < 4; i++) {\n                            const int index = 16 + 16 * c + 8*i8x8 + i;\n                            decode_cabac_residual_nondc(h, mb, 4, index, scan + 1, qmul, 15);\n                            mb += 16<<pixel_shift;\n                        }\n                    }\n                }\n            } else {\n                fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);\n                fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);\n            }\n        } else   {\n            if( cbp&0x30 ){\n                int c;\n                for (c = 0; c < 2; c++)\n                    decode_cabac_residual_dc(h, h->mb + ((256 + 16*16*c) << pixel_shift), 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);\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 + 16 * c + i;\n                        decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), 4, index, scan + 1, qmul, 15);\n                    }\n                }\n            } else {\n                fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);\n                fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);\n            }\n        }\n    } else {\n        fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);\n        fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);\n        fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);\n        h->last_qscale_diff = 0;\n    }\n    h->cur_pic.qscale_table[mb_xy] = h->qscale;\n    write_back_non_zero_count(h);\n    return 0;\n}', 'static void fill_decode_caches(H264Context *h, int mb_type)\n{\n    int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];\n    int topleft_type, top_type, topright_type, left_type[LEFT_MBS];\n    const uint8_t *left_block = h->left_block;\n    int i;\n    uint8_t *nnz;\n    uint8_t *nnz_cache;\n    topleft_xy      = h->topleft_mb_xy;\n    top_xy          = h->top_mb_xy;\n    topright_xy     = h->topright_mb_xy;\n    left_xy[LTOP]   = h->left_mb_xy[LTOP];\n    left_xy[LBOT]   = h->left_mb_xy[LBOT];\n    topleft_type    = h->topleft_type;\n    top_type        = h->top_type;\n    topright_type   = h->topright_type;\n    left_type[LTOP] = h->left_type[LTOP];\n    left_type[LBOT] = h->left_type[LBOT];\n    if (!IS_SKIP(mb_type)) {\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[LTOP])) {\n                if (IS_INTERLACED(mb_type)) {\n                    if (!(left_type[LTOP] & type_mask)) {\n                        h->topleft_samples_available &= 0xDFFF;\n                        h->left_samples_available    &= 0x5FFF;\n                    }\n                    if (!(left_type[LBOT] & type_mask)) {\n                        h->topleft_samples_available &= 0xFF5F;\n                        h->left_samples_available    &= 0xFF5F;\n                    }\n                } else {\n                    int left_typei = h->cur_pic.mb_type[left_xy[LTOP] + h->mb_stride];\n                    assert(left_xy[LTOP] == left_xy[LBOT]);\n                    if (!((left_typei & type_mask) && (left_type[LTOP] & type_mask))) {\n                        h->topleft_samples_available &= 0xDF5F;\n                        h->left_samples_available    &= 0x5F5F;\n                    }\n                }\n            } else {\n                if (!(left_type[LTOP] & 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                    AV_COPY32(h->intra4x4_pred_mode_cache + 4 + 8 * 0, h->intra4x4_pred_mode + h->mb2br_xy[top_xy]);\n                } else {\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] = 2 - 3 * !(top_type & type_mask);\n                }\n                for (i = 0; i < 2; i++) {\n                    if (IS_INTRA4x4(left_type[LEFT(i)])) {\n                        int8_t *mode = h->intra4x4_pred_mode + h->mb2br_xy[left_xy[LEFT(i)]];\n                        h->intra4x4_pred_mode_cache[3 + 8 * 1 + 2 * 8 * i] = mode[6 - left_block[0 + 2 * i]];\n                        h->intra4x4_pred_mode_cache[3 + 8 * 2 + 2 * 8 * i] = mode[6 - left_block[1 + 2 * i]];\n                    } else {\n                        h->intra4x4_pred_mode_cache[3 + 8 * 1 + 2 * 8 * i] =\n                        h->intra4x4_pred_mode_cache[3 + 8 * 2 + 2 * 8 * i] = 2 - 3 * !(left_type[LEFT(i)] & type_mask);\n                    }\n                }\n            }\n        }\n        nnz_cache = h->non_zero_count_cache;\n        if (top_type) {\n            nnz = h->non_zero_count[top_xy];\n            AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[4 * 3]);\n            if (!h->chroma_y_shift) {\n                AV_COPY32(&nnz_cache[4 + 8 *  5], &nnz[4 *  7]);\n                AV_COPY32(&nnz_cache[4 + 8 * 10], &nnz[4 * 11]);\n            } else {\n                AV_COPY32(&nnz_cache[4 + 8 *  5], &nnz[4 * 5]);\n                AV_COPY32(&nnz_cache[4 + 8 * 10], &nnz[4 * 9]);\n            }\n        } else {\n            uint32_t top_empty = CABAC(h) && !IS_INTRA(mb_type) ? 0 : 0x40404040;\n            AV_WN32A(&nnz_cache[4 + 8 *  0], top_empty);\n            AV_WN32A(&nnz_cache[4 + 8 *  5], top_empty);\n            AV_WN32A(&nnz_cache[4 + 8 * 10], top_empty);\n        }\n        for (i = 0; i < 2; i++) {\n            if (left_type[LEFT(i)]) {\n                nnz = h->non_zero_count[left_xy[LEFT(i)]];\n                nnz_cache[3 + 8 * 1 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i]];\n                nnz_cache[3 + 8 * 2 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i]];\n                if (CHROMA444(h)) {\n                    nnz_cache[3 + 8 *  6 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] + 4 * 4];\n                    nnz_cache[3 + 8 *  7 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] + 4 * 4];\n                    nnz_cache[3 + 8 * 11 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] + 8 * 4];\n                    nnz_cache[3 + 8 * 12 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] + 8 * 4];\n                } else if (CHROMA422(h)) {\n                    nnz_cache[3 + 8 *  6 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] - 2 + 4 * 4];\n                    nnz_cache[3 + 8 *  7 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] - 2 + 4 * 4];\n                    nnz_cache[3 + 8 * 11 + 2 * 8 * i] = nnz[left_block[8 + 0 + 2 * i] - 2 + 8 * 4];\n                    nnz_cache[3 + 8 * 12 + 2 * 8 * i] = nnz[left_block[8 + 1 + 2 * i] - 2 + 8 * 4];\n                } else {\n                    nnz_cache[3 + 8 *  6 + 8 * i] = nnz[left_block[8 + 4 + 2 * i]];\n                    nnz_cache[3 + 8 * 11 + 8 * i] = nnz[left_block[8 + 5 + 2 * i]];\n                }\n            } else {\n                nnz_cache[3 + 8 *  1 + 2 * 8 * i] =\n                nnz_cache[3 + 8 *  2 + 2 * 8 * i] =\n                nnz_cache[3 + 8 *  6 + 2 * 8 * i] =\n                nnz_cache[3 + 8 *  7 + 2 * 8 * i] =\n                nnz_cache[3 + 8 * 11 + 2 * 8 * i] =\n                nnz_cache[3 + 8 * 12 + 2 * 8 * i] = CABAC(h) && !IS_INTRA(mb_type) ? 0 : 64;\n            }\n        }\n        if (CABAC(h)) {\n            if (top_type)\n                h->top_cbp = h->cbp_table[top_xy];\n            else\n                h->top_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;\n            if (left_type[LTOP]) {\n                h->left_cbp =   (h->cbp_table[left_xy[LTOP]] & 0x7F0) |\n                               ((h->cbp_table[left_xy[LTOP]] >> (left_block[0] & (~1))) & 2) |\n                              (((h->cbp_table[left_xy[LBOT]] >> (left_block[2] & (~1))) & 2) << 2);\n            } else {\n                h->left_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;\n            }\n        }\n    }\n    if (IS_INTER(mb_type) || (IS_DIRECT(mb_type) && h->direct_spatial_mv_pred)) {\n        int list;\n        int b_stride = h->b_stride;\n        for (list = 0; list < h->list_count; list++) {\n            int8_t *ref_cache = &h->ref_cache[list][scan8[0]];\n            int8_t *ref       = h->cur_pic.ref_index[list];\n            int16_t(*mv_cache)[2] = &h->mv_cache[list][scan8[0]];\n            int16_t(*mv)[2]       = h->cur_pic.motion_val[list];\n            if (!USES_LIST(mb_type, list))\n                continue;\n            assert(!(IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred));\n            if (USES_LIST(top_type, list)) {\n                const int b_xy = h->mb2b_xy[top_xy] + 3 * b_stride;\n                AV_COPY128(mv_cache[0 - 1 * 8], mv[b_xy + 0]);\n                ref_cache[0 - 1 * 8] =\n                ref_cache[1 - 1 * 8] = ref[4 * top_xy + 2];\n                ref_cache[2 - 1 * 8] =\n                ref_cache[3 - 1 * 8] = ref[4 * top_xy + 3];\n            } else {\n                AV_ZERO128(mv_cache[0 - 1 * 8]);\n                AV_WN32A(&ref_cache[0 - 1 * 8],\n                         ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE) & 0xFF) * 0x01010101u);\n            }\n            if (mb_type & (MB_TYPE_16x8 | MB_TYPE_8x8)) {\n                for (i = 0; i < 2; i++) {\n                    int cache_idx = -1 + i * 2 * 8;\n                    if (USES_LIST(left_type[LEFT(i)], list)) {\n                        const int b_xy  = h->mb2b_xy[left_xy[LEFT(i)]] + 3;\n                        const int b8_xy = 4 * left_xy[LEFT(i)] + 1;\n                        AV_COPY32(mv_cache[cache_idx],\n                                  mv[b_xy + b_stride * left_block[0 + i * 2]]);\n                        AV_COPY32(mv_cache[cache_idx + 8],\n                                  mv[b_xy + b_stride * left_block[1 + i * 2]]);\n                        ref_cache[cache_idx]     = ref[b8_xy + (left_block[0 + i * 2] & ~1)];\n                        ref_cache[cache_idx + 8] = ref[b8_xy + (left_block[1 + i * 2] & ~1)];\n                    } else {\n                        AV_ZERO32(mv_cache[cache_idx]);\n                        AV_ZERO32(mv_cache[cache_idx + 8]);\n                        ref_cache[cache_idx]     =\n                        ref_cache[cache_idx + 8] = (left_type[LEFT(i)]) ? LIST_NOT_USED\n                                                                        : PART_NOT_AVAILABLE;\n                    }\n                }\n            } else {\n                if (USES_LIST(left_type[LTOP], list)) {\n                    const int b_xy  = h->mb2b_xy[left_xy[LTOP]] + 3;\n                    const int b8_xy = 4 * left_xy[LTOP] + 1;\n                    AV_COPY32(mv_cache[-1], mv[b_xy + b_stride * left_block[0]]);\n                    ref_cache[-1] = ref[b8_xy + (left_block[0] & ~1)];\n                } else {\n                    AV_ZERO32(mv_cache[-1]);\n                    ref_cache[-1] = left_type[LTOP] ? LIST_NOT_USED\n                                                    : PART_NOT_AVAILABLE;\n                }\n            }\n            if (USES_LIST(topright_type, list)) {\n                const int b_xy = h->mb2b_xy[topright_xy] + 3 * b_stride;\n                AV_COPY32(mv_cache[4 - 1 * 8], mv[b_xy]);\n                ref_cache[4 - 1 * 8] = ref[4 * topright_xy + 2];\n            } else {\n                AV_ZERO32(mv_cache[4 - 1 * 8]);\n                ref_cache[4 - 1 * 8] = topright_type ? LIST_NOT_USED\n                                                     : PART_NOT_AVAILABLE;\n            }\n            if (ref_cache[4 - 1 * 8] < 0) {\n                if (USES_LIST(topleft_type, list)) {\n                    const int b_xy  = h->mb2b_xy[topleft_xy] + 3 + b_stride +\n                                      (h->topleft_partition & 2 * b_stride);\n                    const int b8_xy = 4 * topleft_xy + 1 + (h->topleft_partition & 2);\n                    AV_COPY32(mv_cache[-1 - 1 * 8], mv[b_xy]);\n                    ref_cache[-1 - 1 * 8] = ref[b8_xy];\n                } else {\n                    AV_ZERO32(mv_cache[-1 - 1 * 8]);\n                    ref_cache[-1 - 1 * 8] = topleft_type ? LIST_NOT_USED\n                                                         : PART_NOT_AVAILABLE;\n                }\n            }\n            if ((mb_type & (MB_TYPE_SKIP | MB_TYPE_DIRECT2)) && !FRAME_MBAFF(h))\n                continue;\n            if (!(mb_type & (MB_TYPE_SKIP | MB_TYPE_DIRECT2))) {\n                uint8_t(*mvd_cache)[2]   = &h->mvd_cache[list][scan8[0]];\n                uint8_t(*mvd)[2]         = h->mvd_table[list];\n                ref_cache[2 + 8 * 0] =\n                ref_cache[2 + 8 * 2] = PART_NOT_AVAILABLE;\n                AV_ZERO32(mv_cache[2 + 8 * 0]);\n                AV_ZERO32(mv_cache[2 + 8 * 2]);\n                if (CABAC(h)) {\n                    if (USES_LIST(top_type, list)) {\n                        const int b_xy = h->mb2br_xy[top_xy];\n                        AV_COPY64(mvd_cache[0 - 1 * 8], mvd[b_xy + 0]);\n                    } else {\n                        AV_ZERO64(mvd_cache[0 - 1 * 8]);\n                    }\n                    if (USES_LIST(left_type[LTOP], list)) {\n                        const int b_xy = h->mb2br_xy[left_xy[LTOP]] + 6;\n                        AV_COPY16(mvd_cache[-1 + 0 * 8], mvd[b_xy - left_block[0]]);\n                        AV_COPY16(mvd_cache[-1 + 1 * 8], mvd[b_xy - left_block[1]]);\n                    } else {\n                        AV_ZERO16(mvd_cache[-1 + 0 * 8]);\n                        AV_ZERO16(mvd_cache[-1 + 1 * 8]);\n                    }\n                    if (USES_LIST(left_type[LBOT], list)) {\n                        const int b_xy = h->mb2br_xy[left_xy[LBOT]] + 6;\n                        AV_COPY16(mvd_cache[-1 + 2 * 8], mvd[b_xy - left_block[2]]);\n                        AV_COPY16(mvd_cache[-1 + 3 * 8], mvd[b_xy - left_block[3]]);\n                    } else {\n                        AV_ZERO16(mvd_cache[-1 + 2 * 8]);\n                        AV_ZERO16(mvd_cache[-1 + 3 * 8]);\n                    }\n                    AV_ZERO16(mvd_cache[2 + 8 * 0]);\n                    AV_ZERO16(mvd_cache[2 + 8 * 2]);\n                    if (h->slice_type_nos == AV_PICTURE_TYPE_B) {\n                        uint8_t *direct_cache = &h->direct_cache[scan8[0]];\n                        uint8_t *direct_table = h->direct_table;\n                        fill_rectangle(direct_cache, 4, 4, 8, MB_TYPE_16x16 >> 1, 1);\n                        if (IS_DIRECT(top_type)) {\n                            AV_WN32A(&direct_cache[-1 * 8],\n                                     0x01010101u * (MB_TYPE_DIRECT2 >> 1));\n                        } else if (IS_8X8(top_type)) {\n                            int b8_xy = 4 * top_xy;\n                            direct_cache[0 - 1 * 8] = direct_table[b8_xy + 2];\n                            direct_cache[2 - 1 * 8] = direct_table[b8_xy + 3];\n                        } else {\n                            AV_WN32A(&direct_cache[-1 * 8],\n                                     0x01010101 * (MB_TYPE_16x16 >> 1));\n                        }\n                        if (IS_DIRECT(left_type[LTOP]))\n                            direct_cache[-1 + 0 * 8] = MB_TYPE_DIRECT2 >> 1;\n                        else if (IS_8X8(left_type[LTOP]))\n                            direct_cache[-1 + 0 * 8] = direct_table[4 * left_xy[LTOP] + 1 + (left_block[0] & ~1)];\n                        else\n                            direct_cache[-1 + 0 * 8] = MB_TYPE_16x16 >> 1;\n                        if (IS_DIRECT(left_type[LBOT]))\n                            direct_cache[-1 + 2 * 8] = MB_TYPE_DIRECT2 >> 1;\n                        else if (IS_8X8(left_type[LBOT]))\n                            direct_cache[-1 + 2 * 8] = direct_table[4 * left_xy[LBOT] + 1 + (left_block[2] & ~1)];\n                        else\n                            direct_cache[-1 + 2 * 8] = MB_TYPE_16x16 >> 1;\n                    }\n                }\n            }\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[LTOP])                      \\\n    MAP_F2F(scan8[0] - 1 + 1 * 8, left_type[LTOP])                      \\\n    MAP_F2F(scan8[0] - 1 + 2 * 8, left_type[LBOT])                      \\\n    MAP_F2F(scan8[0] - 1 + 3 * 8, left_type[LBOT])\n            if (FRAME_MBAFF(h)) {\n                if (MB_FIELD(h)) {\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] >>= 1;                               \\\n    }\n                    MAP_MVS\n                } else {\n#undef MAP_F2F\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    h->neighbor_transform_size = !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[LTOP]);\n}', 'static av_always_inline void decode_cabac_luma_residual( H264Context *h, const uint8_t *scan, const uint8_t *scan8x8, int pixel_shift, int mb_type, int cbp, int p )\n{\n    static const uint8_t ctx_cat[4][3] = {{0,6,10},{1,7,11},{2,8,12},{5,9,13}};\n    const uint32_t *qmul;\n    int i8x8, i4x4;\n    int qscale = p == 0 ? h->qscale : h->chroma_qp[p-1];\n    if( IS_INTRA16x16( mb_type ) ) {\n        AV_ZERO128(h->mb_luma_dc[p]+0);\n        AV_ZERO128(h->mb_luma_dc[p]+8);\n        AV_ZERO128(h->mb_luma_dc[p]+16);\n        AV_ZERO128(h->mb_luma_dc[p]+24);\n        decode_cabac_residual_dc(h, h->mb_luma_dc[p], ctx_cat[0][p], LUMA_DC_BLOCK_INDEX+p, scan, 16);\n        if( cbp&15 ) {\n            qmul = h->dequant4_coeff[p][qscale];\n            for( i4x4 = 0; i4x4 < 16; i4x4++ ) {\n                const int index = 16*p + i4x4;\n                decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), ctx_cat[1][p], index, scan + 1, qmul, 15);\n            }\n        } else {\n            fill_rectangle(&h->non_zero_count_cache[scan8[16*p]], 4, 4, 8, 0, 1);\n        }\n    } else {\n        int cqm = (IS_INTRA( mb_type ) ? 0:3) + p;\n        for( i8x8 = 0; i8x8 < 4; i8x8++ ) {\n            if( cbp & (1<<i8x8) ) {\n                if( IS_8x8DCT(mb_type) ) {\n                    const int index = 16*p + 4*i8x8;\n                    decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), ctx_cat[3][p], index,\n                                                scan8x8, h->dequant8_coeff[cqm][qscale], 64);\n                } else {\n                    qmul = h->dequant4_coeff[cqm][qscale];\n                    for( i4x4 = 0; i4x4 < 4; i4x4++ ) {\n                        const int index = 16*p + 4*i8x8 + i4x4;\n                        decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), ctx_cat[2][p], index, scan, qmul, 16);\n                    }\n                }\n            } else {\n                fill_rectangle(&h->non_zero_count_cache[scan8[4*i8x8+16*p]], 2, 2, 8, 0, 1);\n            }\n        }\n    }\n}', 'static av_always_inline void decode_cabac_residual_dc(H264Context *h,\n                                                      int16_t *block,\n                                                      int cat, int n,\n                                                      const uint8_t *scantable,\n                                                      int max_coeff)\n{\n    if( get_cabac( &h->cabac, &h->cabac_state[get_cabac_cbf_ctx( h, cat, n, max_coeff, 1 ) ] ) == 0 ) {\n        h->non_zero_count_cache[scan8[n]] = 0;\n        return;\n    }\n    decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );\n}', 'static void decode_cabac_residual_dc_internal(H264Context *h, int16_t *block,\n                                              int cat, int n,\n                                              const uint8_t *scantable,\n                                              int max_coeff)\n{\n    decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1, 0);\n}', 'static av_always_inline void\ndecode_cabac_residual_internal(H264Context *h, int16_t *block,\n                               int cat, int n, const uint8_t *scantable,\n                               const uint32_t *qmul, int max_coeff,\n                               int is_dc, int chroma422)\n{\n    static const int significant_coeff_flag_offset[2][14] = {\n      { 105+0, 105+15, 105+29, 105+44, 105+47, 402, 484+0, 484+15, 484+29, 660, 528+0, 528+15, 528+29, 718 },\n      { 277+0, 277+15, 277+29, 277+44, 277+47, 436, 776+0, 776+15, 776+29, 675, 820+0, 820+15, 820+29, 733 }\n    };\n    static const int last_coeff_flag_offset[2][14] = {\n      { 166+0, 166+15, 166+29, 166+44, 166+47, 417, 572+0, 572+15, 572+29, 690, 616+0, 616+15, 616+29, 748 },\n      { 338+0, 338+15, 338+29, 338+44, 338+47, 451, 864+0, 864+15, 864+29, 699, 908+0, 908+15, 908+29, 757 }\n    };\n    static const int coeff_abs_level_m1_offset[14] = {\n        227+0, 227+10, 227+20, 227+30, 227+39, 426, 952+0, 952+10, 952+20, 708, 982+0, 982+10, 982+20, 766\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 sig_coeff_offset_dc[7] = { 0, 0, 1, 1, 2, 2, 2 };\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[2][8] = {\n        { 5, 5, 5, 5, 6, 7, 8, 9 },\n        { 5, 5, 5, 5, 6, 7, 8, 8 },\n    };\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    cc.bytestream_end = h->cabac.bytestream_end;\n#else\n#define CC &h->cabac\n#endif\n    significant_coeff_ctx_base = h->cabac_state\n        + significant_coeff_flag_offset[MB_FIELD(h)][cat];\n    last_coeff_ctx_base = h->cabac_state\n        + last_coeff_flag_offset[MB_FIELD(h)][cat];\n    abs_level_m1_ctx_base = h->cabac_state\n        + coeff_abs_level_m1_offset[cat];\n    if( !is_dc && max_coeff == 64 ) {\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(h)];\n#ifdef decode_significance\n        coeff_count = decode_significance_8x8(CC, significant_coeff_ctx_base, index,\n                                                 last_coeff_ctx_base, sig_off);\n    } else {\n        if (is_dc && chroma422) {\n            DECODE_SIGNIFICANCE(7, sig_coeff_offset_dc[last], sig_coeff_offset_dc[last]);\n        } else {\n            coeff_count = decode_significance(CC, max_coeff, significant_coeff_ctx_base, index,\n                                                 last_coeff_ctx_base-significant_coeff_ctx_base);\n        }\n#else\n        DECODE_SIGNIFICANCE( 63, sig_off[last], ff_h264_last_coeff_flag_offset_8x8[last] );\n    } else {\n        if (is_dc && chroma422) {\n            DECODE_SIGNIFICANCE(7, sig_coeff_offset_dc[last], sig_coeff_offset_dc[last]);\n        } else {\n            DECODE_SIGNIFICANCE(max_coeff - 1, last, last);\n        }\n#endif\n    }\n    assert(coeff_count > 0);\n    if( is_dc ) {\n        if( cat == 3 )\n            h->cbp_table[h->mb_xy] |= 0x40 << (n - CHROMA_DC_BLOCK_INDEX);\n        else\n            h->cbp_table[h->mb_xy] |= 0x100 << (n - LUMA_DC_BLOCK_INDEX);\n        h->non_zero_count_cache[scan8[n]] = coeff_count;\n    } else {\n        if( max_coeff == 64 )\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 || cat == 7 || cat == 8 || cat == 11 || cat == 12 );\n            h->non_zero_count_cache[scan8[n]] = coeff_count;\n        }\n    }\n#define STORE_BLOCK(type) \\\n    do { \\\n        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base; \\\n \\\n        int j= scantable[index[--coeff_count]]; \\\n \\\n        if( get_cabac( CC, ctx ) == 0 ) { \\\n            node_ctx = coeff_abs_level_transition[0][node_ctx]; \\\n            if( is_dc ) { \\\n                ((type*)block)[j] = get_cabac_bypass_sign( CC, -1); \\\n            }else{ \\\n                ((type*)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[is_dc && chroma422][node_ctx] + abs_level_m1_ctx_base; \\\n            node_ctx = coeff_abs_level_transition[1][node_ctx]; \\\n\\\n            while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { \\\n                coeff_abs++; \\\n            } \\\n\\\n            if( coeff_abs >= 15 ) { \\\n                int j = 0; \\\n                while( get_cabac_bypass( CC ) ) { \\\n                    j++; \\\n                } \\\n\\\n                coeff_abs=1; \\\n                while( j-- ) { \\\n                    coeff_abs += coeff_abs + get_cabac_bypass( CC ); \\\n                } \\\n                coeff_abs+= 14; \\\n            } \\\n\\\n            if( is_dc ) { \\\n                ((type*)block)[j] = get_cabac_bypass_sign( CC, -coeff_abs ); \\\n            }else{ \\\n                ((type*)block)[j] = ((int)(get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32)) >> 6; \\\n            } \\\n        } \\\n    } while ( coeff_count );\n    if (h->pixel_shift) {\n        STORE_BLOCK(int32_t)\n    } else {\n        STORE_BLOCK(int16_t)\n    }\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}']