libavcodec/h264.c:4029: error: Integer Overflow L2
  ([0, +oo] - 1):unsigned32 by call to `ff_h264_hl_decode_mb`.

libavcodec/h264.c:4024:23: Call
4022.         for (;;) {
4023.             // START_TIMER
4024.             int ret = ff_h264_decode_mb_cabac(h);
                            ^
4025.             int eos;
4026.             // STOP_TIMER("decode_mb_cabac")

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

libavcodec/h264.c:4029:17: Call
4027. 
4028.             if (ret >= 0)
4029.                 ff_h264_hl_decode_mb(h);
                      ^
4030. 
4031.             // FIXME optimal? or let mb_decode decode 16x32 ?

libavcodec/h264.c:2298:1: Parameter `h->list_count`
  2296. #include "h264_mb_template.c"
  2297. 
  2298. void ff_h264_hl_decode_mb(H264Context *h)
        ^
  2299. {
  2300.     const int mb_xy   = h->mb_xy;

libavcodec/h264.c:2306:13: Call
  2304.     if (CHROMA444) {
  2305.         if (is_complex || h->pixel_shift)
  2306.             hl_decode_mb_444_complex(h);
                    ^
  2307.         else
  2308.             hl_decode_mb_444_simple_8(h);

libavcodec/h264_mb_template.c:277:1: Parameter `h->list_count`
    275. #include "h264_mc_template.c"
    276. 
    277. static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h)
         ^
    278. {
    279.     const int mb_x    = h->mb_x;

libavcodec/h264_mb_template.c:360:13: Call
    358.                                linesize, 0, 1, SIMPLE, PIXEL_SHIFT);
    359.         } else {
    360.             FUNC(hl_motion_444)(h, dest[0], dest[1], dest[2],
                     ^
    361.                       h->me.qpel_put, h->h264chroma.put_h264_chroma_pixels_tab,
    362.                       h->me.qpel_avg, h->h264chroma.avg_h264_chroma_pixels_tab,

libavcodec/h264_mc_template.c:61:1: Parameter `h->list_count`
      59. }
      60. 
      61. static void MCFUNC(hl_motion)(H264Context *h, uint8_t *dest_y,
          ^
      62.                               uint8_t *dest_cb, uint8_t *dest_cr,
      63.                               qpel_mc_func(*qpix_put)[16],

libavcodec/h264_mc_template.c:76:9: Call
      74. 
      75.     if (HAVE_THREADS && (h->avctx->active_thread_type & FF_THREAD_FRAME))
      76.         await_references(h);
                  ^
      77.     prefetch_motion(h, 0, PIXEL_SHIFT, CHROMA_IDC);
      78. 

libavcodec/h264.c:538:1: <LHS trace>
536.  * @param h the H264 context
537.  */
538. static void await_references(H264Context *h)
     ^
539. {
540.     const int mb_xy   = h->mb_xy;

libavcodec/h264.c:538:1: Parameter `h->list_count`
        536.  * @param h the H264 context
        537.  */
        538. static void await_references(H264Context *h)
             ^
        539. {
        540.     const int mb_xy   = h->mb_xy;

libavcodec/h264.c:608:10: Binary operation: ([0, +oo] - 1):unsigned32 by call to `ff_h264_hl_decode_mb` 
        606.     }
        607. 
        608.     for (list = h->list_count - 1; list >= 0; list--)
                      ^
        609.         for (ref = 0; ref < 48 && nrefs[list]; ref++) {
        610.             int row = refs[list][ref];

static void await_references(H264Context *h)
{
    const int mb_xy   = h->mb_xy;
    const int mb_type = h->cur_pic.f.mb_type[mb_xy];
    int refs[2][48];
    int nrefs[2] = { 0 };
    int ref, list;
    memset(refs, -1, sizeof(refs));
    if (IS_16X16(mb_type)) {
        get_lowest_part_y(h, refs, 0, 16, 0,
                          IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
    } else if (IS_16X8(mb_type)) {
        get_lowest_part_y(h, refs, 0, 8, 0,
                          IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
        get_lowest_part_y(h, refs, 8, 8, 8,
                          IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);
    } else if (IS_8X16(mb_type)) {
        get_lowest_part_y(h, refs, 0, 16, 0,
                          IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
        get_lowest_part_y(h, refs, 4, 16, 0,
                          IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);
    } else {
        int i;
        assert(IS_8X8(mb_type));
        for (i = 0; i < 4; i++) {
            const int sub_mb_type = h->sub_mb_type[i];
            const int n           = 4 * i;
            int y_offset          = (i & 2) << 2;
            if (IS_SUB_8X8(sub_mb_type)) {
                get_lowest_part_y(h, refs, n, 8, y_offset,
                                  IS_DIR(sub_mb_type, 0, 0),
                                  IS_DIR(sub_mb_type, 0, 1),
                                  nrefs);
            } else if (IS_SUB_8X4(sub_mb_type)) {
                get_lowest_part_y(h, refs, n, 4, y_offset,
                                  IS_DIR(sub_mb_type, 0, 0),
                                  IS_DIR(sub_mb_type, 0, 1),
                                  nrefs);
                get_lowest_part_y(h, refs, n + 2, 4, y_offset + 4,
                                  IS_DIR(sub_mb_type, 0, 0),
                                  IS_DIR(sub_mb_type, 0, 1),
                                  nrefs);
            } else if (IS_SUB_4X8(sub_mb_type)) {
                get_lowest_part_y(h, refs, n, 8, y_offset,
                                  IS_DIR(sub_mb_type, 0, 0),
                                  IS_DIR(sub_mb_type, 0, 1),
                                  nrefs);
                get_lowest_part_y(h, refs, n + 1, 8, y_offset,
                                  IS_DIR(sub_mb_type, 0, 0),
                                  IS_DIR(sub_mb_type, 0, 1),
                                  nrefs);
            } else {
                int j;
                assert(IS_SUB_4X4(sub_mb_type));
                for (j = 0; j < 4; j++) {
                    int sub_y_offset = y_offset + 2 * (j & 2);
                    get_lowest_part_y(h, refs, n + j, 4, sub_y_offset,
                                      IS_DIR(sub_mb_type, 0, 0),
                                      IS_DIR(sub_mb_type, 0, 1),
                                      nrefs);
                }
            }
        }
    }
    for (list = h->list_count - 1; list >= 0; list--)
        for (ref = 0; ref < 48 && nrefs[list]; ref++) {
            int row = refs[list][ref];
            if (row >= 0) {
                Picture *ref_pic      = &h->ref_list[list][ref];
                int ref_field         = ref_pic->f.reference - 1;
                int ref_field_picture = ref_pic->field_picture;
                int pic_height        = 16 * h->mb_height >> ref_field_picture;
                row <<= MB_MBAFF;
                nrefs[list]--;
                if (!FIELD_PICTURE && ref_field_picture) {
                    ff_thread_await_progress(&ref_pic->f,
                                             FFMIN((row >> 1) - !(row & 1),
                                                   pic_height - 1),
                                             1);
                    ff_thread_await_progress(&ref_pic->f,
                                             FFMIN((row >> 1), pic_height - 1),
                                             0);
                } else if (FIELD_PICTURE && !ref_field_picture) {
                    ff_thread_await_progress(&ref_pic->f,
                                             FFMIN(row * 2 + ref_field,
                                                   pic_height - 1),
                                             0);
                } else if (FIELD_PICTURE) {
                    ff_thread_await_progress(&ref_pic->f,
                                             FFMIN(row, pic_height - 1),
                                             ref_field);
                } else {
                    ff_thread_await_progress(&ref_pic->f,
                                             FFMIN(row, pic_height - 1),
                                             0);
                }
            }
        }
}
['static int decode_slice(struct AVCodecContext *avctx, void *arg)\n{\n    H264Context *h = *(void **)arg;\n    int lf_x_start = h->mb_x;\n    h->mb_skip_run = -1;\n    h->is_complex = FRAME_MBAFF || h->picture_structure != PICT_FRAME ||\n                    avctx->codec_id != AV_CODEC_ID_H264 ||\n                    (CONFIG_GRAY && (h->flags & CODEC_FLAG_GRAY));\n    if (h->pps.cabac) {\n        align_get_bits(&h->gb);\n        ff_init_cabac_states(&h->cabac);\n        ff_init_cabac_decoder(&h->cabac,\n                              h->gb.buffer + get_bits_count(&h->gb) / 8,\n                              (get_bits_left(&h->gb) + 7) / 8);\n        ff_h264_init_cabac_states(h);\n        for (;;) {\n            int ret = ff_h264_decode_mb_cabac(h);\n            int eos;\n            if (ret >= 0)\n                ff_h264_hl_decode_mb(h);\n            if (ret >= 0 && FRAME_MBAFF) {\n                h->mb_y++;\n                ret = ff_h264_decode_mb_cabac(h);\n                if (ret >= 0)\n                    ff_h264_hl_decode_mb(h);\n                h->mb_y--;\n            }\n            eos = get_cabac_terminate(&h->cabac);\n            if ((h->workaround_bugs & FF_BUG_TRUNCATED) &&\n                h->cabac.bytestream > h->cabac.bytestream_end + 2) {\n                er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x - 1,\n                                h->mb_y, ER_MB_END);\n                if (h->mb_x >= lf_x_start)\n                    loop_filter(h, lf_x_start, h->mb_x + 1);\n                return 0;\n            }\n            if (ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {\n                av_log(h->avctx, AV_LOG_ERROR,\n                       "error while decoding MB %d %d, bytestream (%td)\\n",\n                       h->mb_x, h->mb_y,\n                       h->cabac.bytestream_end - h->cabac.bytestream);\n                er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x,\n                                h->mb_y, ER_MB_ERROR);\n                return -1;\n            }\n            if (++h->mb_x >= h->mb_width) {\n                loop_filter(h, lf_x_start, h->mb_x);\n                h->mb_x = lf_x_start = 0;\n                decode_finish_row(h);\n                ++h->mb_y;\n                if (FIELD_OR_MBAFF_PICTURE) {\n                    ++h->mb_y;\n                    if (FRAME_MBAFF && h->mb_y < h->mb_height)\n                        predict_field_decoding_flag(h);\n                }\n            }\n            if (eos || h->mb_y >= h->mb_height) {\n                tprintf(h->avctx, "slice end %d %d\\n",\n                        get_bits_count(&h->gb), h->gb.size_in_bits);\n                er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x - 1,\n                                h->mb_y, ER_MB_END);\n                if (h->mb_x > lf_x_start)\n                    loop_filter(h, lf_x_start, h->mb_x);\n                return 0;\n            }\n        }\n    } else {\n        for (;;) {\n            int ret = ff_h264_decode_mb_cavlc(h);\n            if (ret >= 0)\n                ff_h264_hl_decode_mb(h);\n            if (ret >= 0 && FRAME_MBAFF) {\n                h->mb_y++;\n                ret = ff_h264_decode_mb_cavlc(h);\n                if (ret >= 0)\n                    ff_h264_hl_decode_mb(h);\n                h->mb_y--;\n            }\n            if (ret < 0) {\n                av_log(h->avctx, AV_LOG_ERROR,\n                       "error while decoding MB %d %d\\n", h->mb_x, h->mb_y);\n                er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x,\n                                h->mb_y, ER_MB_ERROR);\n                return -1;\n            }\n            if (++h->mb_x >= h->mb_width) {\n                loop_filter(h, lf_x_start, h->mb_x);\n                h->mb_x = lf_x_start = 0;\n                decode_finish_row(h);\n                ++h->mb_y;\n                if (FIELD_OR_MBAFF_PICTURE) {\n                    ++h->mb_y;\n                    if (FRAME_MBAFF && h->mb_y < h->mb_height)\n                        predict_field_decoding_flag(h);\n                }\n                if (h->mb_y >= h->mb_height) {\n                    tprintf(h->avctx, "slice end %d %d\\n",\n                            get_bits_count(&h->gb), h->gb.size_in_bits);\n                    if (get_bits_left(&h->gb) == 0) {\n                        er_add_slice(h, h->resync_mb_x, h->resync_mb_y,\n                                        h->mb_x - 1, h->mb_y,\n                                        ER_MB_END);\n                        return 0;\n                    } else {\n                        er_add_slice(h, h->resync_mb_x, h->resync_mb_y,\n                                        h->mb_x - 1, h->mb_y,\n                                        ER_MB_END);\n                        return -1;\n                    }\n                }\n            }\n            if (get_bits_left(&h->gb) <= 0 && h->mb_skip_run <= 0) {\n                tprintf(h->avctx, "slice end %d %d\\n",\n                        get_bits_count(&h->gb), h->gb.size_in_bits);\n                if (get_bits_left(&h->gb) == 0) {\n                    er_add_slice(h, h->resync_mb_x, h->resync_mb_y,\n                                    h->mb_x - 1, h->mb_y,\n                                    ER_MB_END);\n                    if (h->mb_x > lf_x_start)\n                        loop_filter(h, lf_x_start, h->mb_x);\n                    return 0;\n                } else {\n                    er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x,\n                                    h->mb_y, ER_MB_ERROR);\n                    return -1;\n                }\n            }\n        }\n    }\n}', '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->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->mb_y&1)==0 ){\n                h->cur_pic.f.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){\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));\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)\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        memcpy(h->mb, ptr, mb_size); 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.f.qscale_table[mb_xy] = 0;\n        memset(h->non_zero_count[mb_xy], 16, 48);\n        h->cur_pic.f.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;\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;\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;\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;\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 && 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 && !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.f.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){\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) {\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.f.qscale_table[mb_xy] = h->qscale;\n    write_back_non_zero_count(h);\n    return 0;\n}', 'void ff_h264_hl_decode_mb(H264Context *h)\n{\n    const int mb_xy   = h->mb_xy;\n    const int mb_type = h->cur_pic.f.mb_type[mb_xy];\n    int is_complex    = CONFIG_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || h->qscale == 0;\n    if (CHROMA444) {\n        if (is_complex || h->pixel_shift)\n            hl_decode_mb_444_complex(h);\n        else\n            hl_decode_mb_444_simple_8(h);\n    } else if (is_complex) {\n        hl_decode_mb_complex(h);\n    } else if (h->pixel_shift) {\n        hl_decode_mb_simple_16(h);\n    } else\n        hl_decode_mb_simple_8(h);\n}', 'static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h)\n{\n    const int mb_x    = h->mb_x;\n    const int mb_y    = h->mb_y;\n    const int mb_xy   = h->mb_xy;\n    const int mb_type = h->cur_pic.f.mb_type[mb_xy];\n    uint8_t *dest[3];\n    int linesize;\n    int i, j, p;\n    int *block_offset = &h->block_offset[0];\n    const int transform_bypass = !SIMPLE && (h->qscale == 0 && h->sps.transform_bypass);\n    const int plane_count      = (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) ? 3 : 1;\n    for (p = 0; p < plane_count; p++) {\n        dest[p] = h->cur_pic.f.data[p] +\n                  ((mb_x << PIXEL_SHIFT) + mb_y * h->linesize) * 16;\n        h->vdsp.prefetch(dest[p] + (h->mb_x & 3) * 4 * h->linesize + (64 << PIXEL_SHIFT),\n                         h->linesize, 4);\n    }\n    h->list_counts[mb_xy] = h->list_count;\n    if (!SIMPLE && MB_FIELD) {\n        linesize     = h->mb_linesize = h->mb_uvlinesize = h->linesize * 2;\n        block_offset = &h->block_offset[48];\n        if (mb_y & 1)\n            for (p = 0; p < 3; p++)\n                dest[p] -= h->linesize * 15;\n        if (FRAME_MBAFF) {\n            int list;\n            for (list = 0; list < h->list_count; list++) {\n                if (!USES_LIST(mb_type, list))\n                    continue;\n                if (IS_16X16(mb_type)) {\n                    int8_t *ref = &h->ref_cache[list][scan8[0]];\n                    fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (h->mb_y & 1), 1);\n                } else {\n                    for (i = 0; i < 16; i += 4) {\n                        int ref = h->ref_cache[list][scan8[i]];\n                        if (ref >= 0)\n                            fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2,\n                                           8, (16 + ref) ^ (h->mb_y & 1), 1);\n                    }\n                }\n            }\n        }\n    } else {\n        linesize = h->mb_linesize = h->mb_uvlinesize = h->linesize;\n    }\n    if (!SIMPLE && IS_INTRA_PCM(mb_type)) {\n        if (PIXEL_SHIFT) {\n            const int bit_depth = h->sps.bit_depth_luma;\n            GetBitContext gb;\n            init_get_bits(&gb, (uint8_t *)h->mb, 768 * bit_depth);\n            for (p = 0; p < plane_count; p++)\n                for (i = 0; i < 16; i++) {\n                    uint16_t *tmp = (uint16_t *)(dest[p] + i * linesize);\n                    for (j = 0; j < 16; j++)\n                        tmp[j] = get_bits(&gb, bit_depth);\n                }\n        } else {\n            for (p = 0; p < plane_count; p++)\n                for (i = 0; i < 16; i++)\n                    memcpy(dest[p] + i * linesize,\n                           (uint8_t *)h->mb + p * 256 + i * 16, 16);\n        }\n    } else {\n        if (IS_INTRA(mb_type)) {\n            if (h->deblocking_filter)\n                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize,\n                               linesize, 1, 1, SIMPLE, PIXEL_SHIFT);\n            for (p = 0; p < plane_count; p++)\n                hl_decode_mb_predict_luma(h, mb_type, 1, SIMPLE,\n                                          transform_bypass, PIXEL_SHIFT,\n                                          block_offset, linesize, dest[p], p);\n            if (h->deblocking_filter)\n                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize,\n                               linesize, 0, 1, SIMPLE, PIXEL_SHIFT);\n        } else {\n            FUNC(hl_motion_444)(h, dest[0], dest[1], dest[2],\n                      h->me.qpel_put, h->h264chroma.put_h264_chroma_pixels_tab,\n                      h->me.qpel_avg, h->h264chroma.avg_h264_chroma_pixels_tab,\n                      h->h264dsp.weight_h264_pixels_tab,\n                      h->h264dsp.biweight_h264_pixels_tab);\n        }\n        for (p = 0; p < plane_count; p++)\n            hl_decode_mb_idct_luma(h, mb_type, 1, SIMPLE, transform_bypass,\n                                   PIXEL_SHIFT, block_offset, linesize,\n                                   dest[p], p);\n    }\n    if (h->cbp || IS_INTRA(mb_type)) {\n        h->dsp.clear_blocks(h->mb);\n        h->dsp.clear_blocks(h->mb + (24 * 16 << PIXEL_SHIFT));\n    }\n}', 'static void MCFUNC(hl_motion)(H264Context *h, uint8_t *dest_y,\n                              uint8_t *dest_cb, uint8_t *dest_cr,\n                              qpel_mc_func(*qpix_put)[16],\n                              h264_chroma_mc_func(*chroma_put),\n                              qpel_mc_func(*qpix_avg)[16],\n                              h264_chroma_mc_func(*chroma_avg),\n                              h264_weight_func *weight_op,\n                              h264_biweight_func *weight_avg)\n{\n    const int mb_xy   = h->mb_xy;\n    const int mb_type = h->cur_pic.f.mb_type[mb_xy];\n    assert(IS_INTER(mb_type));\n    if (HAVE_THREADS && (h->avctx->active_thread_type & FF_THREAD_FRAME))\n        await_references(h);\n    prefetch_motion(h, 0, PIXEL_SHIFT, CHROMA_IDC);\n    if (IS_16X16(mb_type)) {\n        mc_part(h, 0, 1, 16, 0, dest_y, dest_cb, dest_cr, 0, 0,\n                qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],\n                weight_op, weight_avg,\n                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));\n    } else if (IS_16X8(mb_type)) {\n        mc_part(h, 0, 0, 8, 8 << PIXEL_SHIFT, dest_y, dest_cb, dest_cr, 0, 0,\n                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],\n                weight_op, weight_avg,\n                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));\n        mc_part(h, 8, 0, 8, 8 << PIXEL_SHIFT, dest_y, dest_cb, dest_cr, 0, 4,\n                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],\n                weight_op, weight_avg,\n                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));\n    } else if (IS_8X16(mb_type)) {\n        mc_part(h, 0, 0, 16, 8 * h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,\n                qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],\n                &weight_op[1], &weight_avg[1],\n                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));\n        mc_part(h, 4, 0, 16, 8 * h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,\n                qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],\n                &weight_op[1], &weight_avg[1],\n                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));\n    } else {\n        int i;\n        assert(IS_8X8(mb_type));\n        for (i = 0; i < 4; i++) {\n            const int sub_mb_type = h->sub_mb_type[i];\n            const int n  = 4 * i;\n            int x_offset = (i & 1) << 2;\n            int y_offset = (i & 2) << 1;\n            if (IS_SUB_8X8(sub_mb_type)) {\n                mc_part(h, n, 1, 8, 0, dest_y, dest_cb, dest_cr,\n                        x_offset, y_offset,\n                        qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],\n                        &weight_op[1], &weight_avg[1],\n                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\n            } else if (IS_SUB_8X4(sub_mb_type)) {\n                mc_part(h, n, 0, 4, 4 << PIXEL_SHIFT, dest_y, dest_cb, dest_cr,\n                        x_offset, y_offset,\n                        qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],\n                        &weight_op[1], &weight_avg[1],\n                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\n                mc_part(h, n + 2, 0, 4, 4 << PIXEL_SHIFT,\n                        dest_y, dest_cb, dest_cr, x_offset, y_offset + 2,\n                        qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],\n                        &weight_op[1], &weight_avg[1],\n                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\n            } else if (IS_SUB_4X8(sub_mb_type)) {\n                mc_part(h, n, 0, 8, 4 * h->mb_linesize,\n                        dest_y, dest_cb, dest_cr, x_offset, y_offset,\n                        qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],\n                        &weight_op[2], &weight_avg[2],\n                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\n                mc_part(h, n + 1, 0, 8, 4 * h->mb_linesize,\n                        dest_y, dest_cb, dest_cr, x_offset + 2, y_offset,\n                        qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],\n                        &weight_op[2], &weight_avg[2],\n                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\n            } else {\n                int j;\n                assert(IS_SUB_4X4(sub_mb_type));\n                for (j = 0; j < 4; j++) {\n                    int sub_x_offset = x_offset + 2 * (j & 1);\n                    int sub_y_offset = y_offset + (j & 2);\n                    mc_part(h, n + j, 1, 4, 0,\n                            dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,\n                            qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],\n                            &weight_op[2], &weight_avg[2],\n                            IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));\n                }\n            }\n        }\n    }\n    prefetch_motion(h, 1, PIXEL_SHIFT, CHROMA_IDC);\n}', 'static void await_references(H264Context *h)\n{\n    const int mb_xy   = h->mb_xy;\n    const int mb_type = h->cur_pic.f.mb_type[mb_xy];\n    int refs[2][48];\n    int nrefs[2] = { 0 };\n    int ref, list;\n    memset(refs, -1, sizeof(refs));\n    if (IS_16X16(mb_type)) {\n        get_lowest_part_y(h, refs, 0, 16, 0,\n                          IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);\n    } else if (IS_16X8(mb_type)) {\n        get_lowest_part_y(h, refs, 0, 8, 0,\n                          IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);\n        get_lowest_part_y(h, refs, 8, 8, 8,\n                          IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);\n    } else if (IS_8X16(mb_type)) {\n        get_lowest_part_y(h, refs, 0, 16, 0,\n                          IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);\n        get_lowest_part_y(h, refs, 4, 16, 0,\n                          IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);\n    } else {\n        int i;\n        assert(IS_8X8(mb_type));\n        for (i = 0; i < 4; i++) {\n            const int sub_mb_type = h->sub_mb_type[i];\n            const int n           = 4 * i;\n            int y_offset          = (i & 2) << 2;\n            if (IS_SUB_8X8(sub_mb_type)) {\n                get_lowest_part_y(h, refs, n, 8, y_offset,\n                                  IS_DIR(sub_mb_type, 0, 0),\n                                  IS_DIR(sub_mb_type, 0, 1),\n                                  nrefs);\n            } else if (IS_SUB_8X4(sub_mb_type)) {\n                get_lowest_part_y(h, refs, n, 4, y_offset,\n                                  IS_DIR(sub_mb_type, 0, 0),\n                                  IS_DIR(sub_mb_type, 0, 1),\n                                  nrefs);\n                get_lowest_part_y(h, refs, n + 2, 4, y_offset + 4,\n                                  IS_DIR(sub_mb_type, 0, 0),\n                                  IS_DIR(sub_mb_type, 0, 1),\n                                  nrefs);\n            } else if (IS_SUB_4X8(sub_mb_type)) {\n                get_lowest_part_y(h, refs, n, 8, y_offset,\n                                  IS_DIR(sub_mb_type, 0, 0),\n                                  IS_DIR(sub_mb_type, 0, 1),\n                                  nrefs);\n                get_lowest_part_y(h, refs, n + 1, 8, y_offset,\n                                  IS_DIR(sub_mb_type, 0, 0),\n                                  IS_DIR(sub_mb_type, 0, 1),\n                                  nrefs);\n            } else {\n                int j;\n                assert(IS_SUB_4X4(sub_mb_type));\n                for (j = 0; j < 4; j++) {\n                    int sub_y_offset = y_offset + 2 * (j & 2);\n                    get_lowest_part_y(h, refs, n + j, 4, sub_y_offset,\n                                      IS_DIR(sub_mb_type, 0, 0),\n                                      IS_DIR(sub_mb_type, 0, 1),\n                                      nrefs);\n                }\n            }\n        }\n    }\n    for (list = h->list_count - 1; list >= 0; list--)\n        for (ref = 0; ref < 48 && nrefs[list]; ref++) {\n            int row = refs[list][ref];\n            if (row >= 0) {\n                Picture *ref_pic      = &h->ref_list[list][ref];\n                int ref_field         = ref_pic->f.reference - 1;\n                int ref_field_picture = ref_pic->field_picture;\n                int pic_height        = 16 * h->mb_height >> ref_field_picture;\n                row <<= MB_MBAFF;\n                nrefs[list]--;\n                if (!FIELD_PICTURE && ref_field_picture) {\n                    ff_thread_await_progress(&ref_pic->f,\n                                             FFMIN((row >> 1) - !(row & 1),\n                                                   pic_height - 1),\n                                             1);\n                    ff_thread_await_progress(&ref_pic->f,\n                                             FFMIN((row >> 1), pic_height - 1),\n                                             0);\n                } else if (FIELD_PICTURE && !ref_field_picture) {\n                    ff_thread_await_progress(&ref_pic->f,\n                                             FFMIN(row * 2 + ref_field,\n                                                   pic_height - 1),\n                                             0);\n                } else if (FIELD_PICTURE) {\n                    ff_thread_await_progress(&ref_pic->f,\n                                             FFMIN(row, pic_height - 1),\n                                             ref_field);\n                } else {\n                    ff_thread_await_progress(&ref_pic->f,\n                                             FFMIN(row, pic_height - 1),\n                                             0);\n                }\n            }\n        }\n}']