libavcodec/h264_cavlc.c:777: error: Buffer Overrun L1
  Offset: 9 Size: 1.

libavcodec/h264_cavlc.c:691:17: <Length trace>
689.             if(   IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
690.                || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
691.                 ff_h264_pred_direct_motion(h, &mb_type);
                     ^
692.                 h->ref_cache[0][scan8[4]] =
693.                 h->ref_cache[1][scan8[4]] =

libavcodec/h264_cavlc.c:691:17: Call
689.             if(   IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
690.                || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
691.                 ff_h264_pred_direct_motion(h, &mb_type);
                     ^
692.                 h->ref_cache[0][scan8[4]] =
693.                 h->ref_cache[1][scan8[4]] =

libavcodec/h264_direct.c:137:1: Parameter `h->mv_cache[*][*][*]`
  135. }
  136. 
  137. void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type){
       ^
  138.     MpegEncContext * const s = &h->s;
  139.     int b8_stride = h->b8_stride;

libavcodec/h264_cavlc.c:775:21: Assignment
773.                     }
774.                 }else{
775.                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
                         ^
776.                     p[0] = p[1]=
777.                     p[8] = p[9]= 0;

libavcodec/h264_cavlc.c:777:28: Array access: Offset: 9 Size: 1
775.                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
776.                     p[0] = p[1]=
777.                     p[8] = p[9]= 0;
                                ^
778.                 }
779.             }

int ff_h264_decode_mb_cavlc(H264Context *h){
    MpegEncContext * const s = &h->s;
    int mb_xy;
    int partition_count;
    unsigned int mb_type, cbp;
    int dct8x8_allowed= h->pps.transform_8x8_mode;
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
    tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
    cbp = 0;
    if(h->slice_type_nos != FF_I_TYPE){
        if(s->mb_skip_run==-1)
            s->mb_skip_run= get_ue_golomb(&s->gb);
        if (s->mb_skip_run--) {
            if(FRAME_MBAFF && (s->mb_y&1) == 0){
                if(s->mb_skip_run==0)
                    h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
                else
                    predict_field_decoding_flag(h);
            }
            decode_mb_skip(h);
            return 0;
        }
    }
    if(FRAME_MBAFF){
        if( (s->mb_y&1) == 0 )
            h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
    }
    h->prev_mb_skipped= 0;
    mb_type= get_ue_golomb(&s->gb);
    if(h->slice_type_nos == FF_B_TYPE){
        if(mb_type < 23){
            partition_count= b_mb_type_info[mb_type].partition_count;
            mb_type=         b_mb_type_info[mb_type].type;
        }else{
            mb_type -= 23;
            goto decode_intra_mb;
        }
    }else if(h->slice_type_nos == FF_P_TYPE){
        if(mb_type < 5){
            partition_count= p_mb_type_info[mb_type].partition_count;
            mb_type=         p_mb_type_info[mb_type].type;
        }else{
            mb_type -= 5;
            goto decode_intra_mb;
        }
    }else{
       assert(h->slice_type_nos == FF_I_TYPE);
        if(h->slice_type == FF_SI_TYPE && mb_type)
            mb_type--;
decode_intra_mb:
        if(mb_type > 25){
            av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
            return -1;
        }
        partition_count=0;
        cbp= i_mb_type_info[mb_type].cbp;
        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
        mb_type= i_mb_type_info[mb_type].type;
    }
    if(MB_FIELD)
        mb_type |= MB_TYPE_INTERLACED;
    h->slice_table[ mb_xy ]= h->slice_num;
    if(IS_INTRA_PCM(mb_type)){
        unsigned int x;
        align_get_bits(&s->gb);
        for(x=0; x < (CHROMA ? 384 : 256); x++){
            ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
        }
        s->current_picture.qscale_table[mb_xy]= 0;
        memset(h->non_zero_count[mb_xy], 16, 32);
        s->current_picture.mb_type[mb_xy]= mb_type;
        return 0;
    }
    if(MB_MBAFF){
        h->ref_count[0] <<= 1;
        h->ref_count[1] <<= 1;
    }
    fill_decode_caches(h, mb_type);
    if(IS_INTRA(mb_type)){
        int pred_mode;
        if(IS_INTRA4x4(mb_type)){
            int i;
            int di = 1;
            if(dct8x8_allowed && get_bits1(&s->gb)){
                mb_type |= MB_TYPE_8x8DCT;
                di = 4;
            }
            for(i=0; i<16; i+=di){
                int mode= pred_intra_mode(h, i);
                if(!get_bits1(&s->gb)){
                    const int rem_mode= get_bits(&s->gb, 3);
                    mode = rem_mode + (rem_mode >= mode);
                }
                if(di==4)
                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
                else
                    h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
            }
            ff_h264_write_back_intra_pred_mode(h);
            if( ff_h264_check_intra4x4_pred_mode(h) < 0)
                return -1;
        }else{
            h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode);
            if(h->intra16x16_pred_mode < 0)
                return -1;
        }
        if(CHROMA){
            pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&s->gb));
            if(pred_mode < 0)
                return -1;
            h->chroma_pred_mode= pred_mode;
        }
    }else if(partition_count==4){
        int i, j, sub_partition_count[4], list, ref[2][4];
        if(h->slice_type_nos == FF_B_TYPE){
            for(i=0; i<4; i++){
                h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
                if(h->sub_mb_type[i] >=13){
                    av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
                    return -1;
                }
                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
            }
            if(   IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
               || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
                ff_h264_pred_direct_motion(h, &mb_type);
                h->ref_cache[0][scan8[4]] =
                h->ref_cache[1][scan8[4]] =
                h->ref_cache[0][scan8[12]] =
                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
            }
        }else{
            assert(h->slice_type_nos == FF_P_TYPE);
            for(i=0; i<4; i++){
                h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
                if(h->sub_mb_type[i] >=4){
                    av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
                    return -1;
                }
                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
            }
        }
        for(list=0; list<h->list_count; list++){
            int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
            for(i=0; i<4; i++){
                if(IS_DIRECT(h->sub_mb_type[i])) continue;
                if(IS_DIR(h->sub_mb_type[i], 0, list)){
                    unsigned int tmp;
                    if(ref_count == 1){
                        tmp= 0;
                    }else if(ref_count == 2){
                        tmp= get_bits1(&s->gb)^1;
                    }else{
                        tmp= get_ue_golomb_31(&s->gb);
                        if(tmp>=ref_count){
                            av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
                            return -1;
                        }
                    }
                    ref[list][i]= tmp;
                }else{
                    ref[list][i] = -1;
                }
            }
        }
        if(dct8x8_allowed)
            dct8x8_allowed = get_dct8x8_allowed(h);
        for(list=0; list<h->list_count; list++){
            for(i=0; i<4; i++){
                if(IS_DIRECT(h->sub_mb_type[i])) {
                    h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
                    continue;
                }
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=
                h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
                if(IS_DIR(h->sub_mb_type[i], 0, list)){
                    const int sub_mb_type= h->sub_mb_type[i];
                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
                    for(j=0; j<sub_partition_count[i]; j++){
                        int mx, my;
                        const int index= 4*i + block_width*j;
                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
                        mx += get_se_golomb(&s->gb);
                        my += get_se_golomb(&s->gb);
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
                        if(IS_SUB_8X8(sub_mb_type)){
                            mv_cache[ 1 ][0]=
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
                            mv_cache[ 1 ][1]=
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
                        }else if(IS_SUB_8X4(sub_mb_type)){
                            mv_cache[ 1 ][0]= mx;
                            mv_cache[ 1 ][1]= my;
                        }else if(IS_SUB_4X8(sub_mb_type)){
                            mv_cache[ 8 ][0]= mx;
                            mv_cache[ 8 ][1]= my;
                        }
                        mv_cache[ 0 ][0]= mx;
                        mv_cache[ 0 ][1]= my;
                    }
                }else{
                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
                    p[0] = p[1]=
                    p[8] = p[9]= 0;
                }
            }
        }
    }else if(IS_DIRECT(mb_type)){
        ff_h264_pred_direct_motion(h, &mb_type);
        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
    }else{
        int list, mx, my, i;
        if(IS_16X16(mb_type)){
            for(list=0; list<h->list_count; list++){
                    unsigned int val;
                    if(IS_DIR(mb_type, 0, list)){
                        if(h->ref_count[list]==1){
                            val= 0;
                        }else if(h->ref_count[list]==2){
                            val= get_bits1(&s->gb)^1;
                        }else{
                            val= get_ue_golomb_31(&s->gb);
                            if(val >= h->ref_count[list]){
                                av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
                                return -1;
                            }
                        }
                    }else
                        val= LIST_NOT_USED&0xFF;
                    fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
            }
            for(list=0; list<h->list_count; list++){
                unsigned int val;
                if(IS_DIR(mb_type, 0, list)){
                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
                    mx += get_se_golomb(&s->gb);
                    my += get_se_golomb(&s->gb);
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
                    val= pack16to32(mx,my);
                }else
                    val=0;
                fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4);
            }
        }
        else if(IS_16X8(mb_type)){
            for(list=0; list<h->list_count; list++){
                    for(i=0; i<2; i++){
                        unsigned int val;
                        if(IS_DIR(mb_type, i, list)){
                            if(h->ref_count[list] == 1){
                                val= 0;
                            }else if(h->ref_count[list] == 2){
                                val= get_bits1(&s->gb)^1;
                            }else{
                                val= get_ue_golomb_31(&s->gb);
                                if(val >= h->ref_count[list]){
                                    av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
                                    return -1;
                                }
                            }
                        }else
                            val= LIST_NOT_USED&0xFF;
                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
                    }
            }
            for(list=0; list<h->list_count; list++){
                for(i=0; i<2; i++){
                    unsigned int val;
                    if(IS_DIR(mb_type, i, list)){
                        pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
                        mx += get_se_golomb(&s->gb);
                        my += get_se_golomb(&s->gb);
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
                        val= pack16to32(mx,my);
                    }else
                        val=0;
                    fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
                }
            }
        }else{
            assert(IS_8X16(mb_type));
            for(list=0; list<h->list_count; list++){
                    for(i=0; i<2; i++){
                        unsigned int val;
                        if(IS_DIR(mb_type, i, list)){
                            if(h->ref_count[list]==1){
                                val= 0;
                            }else if(h->ref_count[list]==2){
                                val= get_bits1(&s->gb)^1;
                            }else{
                                val= get_ue_golomb_31(&s->gb);
                                if(val >= h->ref_count[list]){
                                    av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
                                    return -1;
                                }
                            }
                        }else
                            val= LIST_NOT_USED&0xFF;
                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
                    }
            }
            for(list=0; list<h->list_count; list++){
                for(i=0; i<2; i++){
                    unsigned int val;
                    if(IS_DIR(mb_type, i, list)){
                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
                        mx += get_se_golomb(&s->gb);
                        my += get_se_golomb(&s->gb);
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
                        val= pack16to32(mx,my);
                    }else
                        val=0;
                    fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
                }
            }
        }
    }
    if(IS_INTER(mb_type))
        write_back_motion(h, mb_type);
    if(!IS_INTRA16x16(mb_type)){
        cbp= get_ue_golomb(&s->gb);
        if(cbp > 47){
            av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
            return -1;
        }
        if(CHROMA){
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
            else                     cbp= golomb_to_inter_cbp   [cbp];
        }else{
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
            else                     cbp= golomb_to_inter_cbp_gray[cbp];
        }
    }
    h->cbp = cbp;
    if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
        if(get_bits1(&s->gb)){
            mb_type |= MB_TYPE_8x8DCT;
            h->cbp_table[mb_xy]= cbp;
        }
    }
    s->current_picture.mb_type[mb_xy]= mb_type;
    if(cbp || IS_INTRA16x16(mb_type)){
        int i8x8, i4x4, chroma_idx;
        int dquant;
        GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
        const uint8_t *scan, *scan8x8, *dc_scan;
        if(IS_INTERLACED(mb_type)){
            scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
            scan= s->qscale ? h->field_scan : h->field_scan_q0;
            dc_scan= luma_dc_field_scan;
        }else{
            scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
            dc_scan= luma_dc_zigzag_scan;
        }
        dquant= get_se_golomb(&s->gb);
        if( dquant > 25 || dquant < -26 ){
            av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
            return -1;
        }
        s->qscale += dquant;
        if(((unsigned)s->qscale) > 51){
            if(s->qscale<0) s->qscale+= 52;
            else            s->qscale-= 52;
        }
        h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
        h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
        if(IS_INTRA16x16(mb_type)){
            if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
                return -1;
            }
            assert((cbp&15) == 0 || (cbp&15) == 15);
            if(cbp&15){
                for(i8x8=0; i8x8<4; i8x8++){
                    for(i4x4=0; i4x4<4; i4x4++){
                        const int index= i4x4 + 4*i8x8;
                        if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
                            return -1;
                        }
                    }
                }
            }else{
                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
            }
        }else{
            for(i8x8=0; i8x8<4; i8x8++){
                if(cbp & (1<<i8x8)){
                    if(IS_8x8DCT(mb_type)){
                        DCTELEM *buf = &h->mb[64*i8x8];
                        uint8_t *nnz;
                        for(i4x4=0; i4x4<4; i4x4++){
                            if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,
                                                h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
                                return -1;
                        }
                        nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
                        nnz[0] += nnz[1] + nnz[8] + nnz[9];
                    }else{
                        for(i4x4=0; i4x4<4; i4x4++){
                            const int index= i4x4 + 4*i8x8;
                            if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
                                return -1;
                            }
                        }
                    }
                }else{
                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
                }
            }
        }
        if(cbp&0x30){
            for(chroma_idx=0; chroma_idx<2; chroma_idx++)
                if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
                    return -1;
                }
        }
        if(cbp&0x20){
            for(chroma_idx=0; chroma_idx<2; chroma_idx++){
                const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
                for(i4x4=0; i4x4<4; i4x4++){
                    const int index= 16 + 4*chroma_idx + i4x4;
                    if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){
                        return -1;
                    }
                }
            }
        }else{
            uint8_t * const nnz= &h->non_zero_count_cache[0];
            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
        }
    }else{
        uint8_t * const nnz= &h->non_zero_count_cache[0];
        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
    }
    s->current_picture.qscale_table[mb_xy]= s->qscale;
    write_back_non_zero_count(h);
    if(MB_MBAFF){
        h->ref_count[0] >>= 1;
        h->ref_count[1] >>= 1;
    }
    return 0;
}
['int ff_h264_decode_mb_cavlc(H264Context *h){\n    MpegEncContext * const s = &h->s;\n    int mb_xy;\n    int partition_count;\n    unsigned int mb_type, cbp;\n    int dct8x8_allowed= h->pps.transform_8x8_mode;\n    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;\n    tprintf(s->avctx, "pic:%d mb:%d/%d\\n", h->frame_num, s->mb_x, s->mb_y);\n    cbp = 0;\n    if(h->slice_type_nos != FF_I_TYPE){\n        if(s->mb_skip_run==-1)\n            s->mb_skip_run= get_ue_golomb(&s->gb);\n        if (s->mb_skip_run--) {\n            if(FRAME_MBAFF && (s->mb_y&1) == 0){\n                if(s->mb_skip_run==0)\n                    h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);\n                else\n                    predict_field_decoding_flag(h);\n            }\n            decode_mb_skip(h);\n            return 0;\n        }\n    }\n    if(FRAME_MBAFF){\n        if( (s->mb_y&1) == 0 )\n            h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);\n    }\n    h->prev_mb_skipped= 0;\n    mb_type= get_ue_golomb(&s->gb);\n    if(h->slice_type_nos == FF_B_TYPE){\n        if(mb_type < 23){\n            partition_count= b_mb_type_info[mb_type].partition_count;\n            mb_type=         b_mb_type_info[mb_type].type;\n        }else{\n            mb_type -= 23;\n            goto decode_intra_mb;\n        }\n    }else if(h->slice_type_nos == FF_P_TYPE){\n        if(mb_type < 5){\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 -= 5;\n            goto decode_intra_mb;\n        }\n    }else{\n       assert(h->slice_type_nos == FF_I_TYPE);\n        if(h->slice_type == FF_SI_TYPE && mb_type)\n            mb_type--;\ndecode_intra_mb:\n        if(mb_type > 25){\n            av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);\n            return -1;\n        }\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        unsigned int x;\n        align_get_bits(&s->gb);\n        for(x=0; x < (CHROMA ? 384 : 256); x++){\n            ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);\n        }\n        s->current_picture.qscale_table[mb_xy]= 0;\n        memset(h->non_zero_count[mb_xy], 16, 32);\n        s->current_picture.mb_type[mb_xy]= mb_type;\n        return 0;\n    }\n    if(MB_MBAFF){\n        h->ref_count[0] <<= 1;\n        h->ref_count[1] <<= 1;\n    }\n    fill_decode_caches(h, mb_type);\n    if(IS_INTRA(mb_type)){\n        int pred_mode;\n        if(IS_INTRA4x4(mb_type)){\n            int i;\n            int di = 1;\n            if(dct8x8_allowed && get_bits1(&s->gb)){\n                mb_type |= MB_TYPE_8x8DCT;\n                di = 4;\n            }\n            for(i=0; i<16; i+=di){\n                int mode= pred_intra_mode(h, i);\n                if(!get_bits1(&s->gb)){\n                    const int rem_mode= get_bits(&s->gb, 3);\n                    mode = rem_mode + (rem_mode >= mode);\n                }\n                if(di==4)\n                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );\n                else\n                    h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;\n            }\n            ff_h264_write_back_intra_pred_mode(h);\n            if( ff_h264_check_intra4x4_pred_mode(h) < 0)\n                return -1;\n        }else{\n            h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode);\n            if(h->intra16x16_pred_mode < 0)\n                return -1;\n        }\n        if(CHROMA){\n            pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&s->gb));\n            if(pred_mode < 0)\n                return -1;\n            h->chroma_pred_mode= pred_mode;\n        }\n    }else if(partition_count==4){\n        int i, j, sub_partition_count[4], list, ref[2][4];\n        if(h->slice_type_nos == FF_B_TYPE){\n            for(i=0; i<4; i++){\n                h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);\n                if(h->sub_mb_type[i] >=13){\n                    av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\\n", h->sub_mb_type[i], s->mb_x, s->mb_y);\n                    return -1;\n                }\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]) || IS_DIRECT(h->sub_mb_type[1])\n               || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(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            }\n        }else{\n            assert(h->slice_type_nos == FF_P_TYPE);\n            for(i=0; i<4; i++){\n                h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);\n                if(h->sub_mb_type[i] >=4){\n                    av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\\n", h->sub_mb_type[i], s->mb_x, s->mb_y);\n                    return -1;\n                }\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            int ref_count= IS_REF0(mb_type) ? 1 : h->ref_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                    unsigned int tmp;\n                    if(ref_count == 1){\n                        tmp= 0;\n                    }else if(ref_count == 2){\n                        tmp= get_bits1(&s->gb)^1;\n                    }else{\n                        tmp= get_ue_golomb_31(&s->gb);\n                        if(tmp>=ref_count){\n                            av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\\n", tmp);\n                            return -1;\n                        }\n                    }\n                    ref[list][i]= tmp;\n                }else{\n                    ref[list][i] = -1;\n                }\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                if(IS_DIRECT(h->sub_mb_type[i])) {\n                    h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];\n                    continue;\n                }\n                h->ref_cache[list][ scan8[4*i]   ]=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                if(IS_DIR(h->sub_mb_type[i], 0, list)){\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 mx, my;\n                        const int index= 4*i + block_width*j;\n                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];\n                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);\n                        mx += get_se_golomb(&s->gb);\n                        my += get_se_golomb(&s->gb);\n                        tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                        if(IS_SUB_8X8(sub_mb_type)){\n                            mv_cache[ 1 ][0]=\n                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;\n                            mv_cache[ 1 ][1]=\n                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;\n                        }else if(IS_SUB_8X4(sub_mb_type)){\n                            mv_cache[ 1 ][0]= mx;\n                            mv_cache[ 1 ][1]= my;\n                        }else if(IS_SUB_4X8(sub_mb_type)){\n                            mv_cache[ 8 ][0]= mx;\n                            mv_cache[ 8 ][1]= my;\n                        }\n                        mv_cache[ 0 ][0]= mx;\n                        mv_cache[ 0 ][1]= my;\n                    }\n                }else{\n                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];\n                    p[0] = p[1]=\n                    p[8] = p[9]= 0;\n                }\n            }\n        }\n    }else if(IS_DIRECT(mb_type)){\n        ff_h264_pred_direct_motion(h, &mb_type);\n        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;\n    }else{\n        int list, mx, my, i;\n        if(IS_16X16(mb_type)){\n            for(list=0; list<h->list_count; list++){\n                    unsigned int val;\n                    if(IS_DIR(mb_type, 0, list)){\n                        if(h->ref_count[list]==1){\n                            val= 0;\n                        }else if(h->ref_count[list]==2){\n                            val= get_bits1(&s->gb)^1;\n                        }else{\n                            val= get_ue_golomb_31(&s->gb);\n                            if(val >= h->ref_count[list]){\n                                av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\\n", val);\n                                return -1;\n                            }\n                        }\n                    }else\n                        val= LIST_NOT_USED&0xFF;\n                    fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);\n            }\n            for(list=0; list<h->list_count; list++){\n                unsigned int val;\n                if(IS_DIR(mb_type, 0, list)){\n                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);\n                    mx += get_se_golomb(&s->gb);\n                    my += get_se_golomb(&s->gb);\n                    tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                    val= pack16to32(mx,my);\n                }else\n                    val=0;\n                fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4);\n            }\n        }\n        else if(IS_16X8(mb_type)){\n            for(list=0; list<h->list_count; list++){\n                    for(i=0; i<2; i++){\n                        unsigned int val;\n                        if(IS_DIR(mb_type, i, list)){\n                            if(h->ref_count[list] == 1){\n                                val= 0;\n                            }else if(h->ref_count[list] == 2){\n                                val= get_bits1(&s->gb)^1;\n                            }else{\n                                val= get_ue_golomb_31(&s->gb);\n                                if(val >= h->ref_count[list]){\n                                    av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\\n", val);\n                                    return -1;\n                                }\n                            }\n                        }else\n                            val= LIST_NOT_USED&0xFF;\n                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);\n                    }\n            }\n            for(list=0; list<h->list_count; list++){\n                for(i=0; i<2; i++){\n                    unsigned int val;\n                    if(IS_DIR(mb_type, i, list)){\n                        pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);\n                        mx += get_se_golomb(&s->gb);\n                        my += get_se_golomb(&s->gb);\n                        tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                        val= pack16to32(mx,my);\n                    }else\n                        val=0;\n                    fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);\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                        unsigned int val;\n                        if(IS_DIR(mb_type, i, list)){\n                            if(h->ref_count[list]==1){\n                                val= 0;\n                            }else if(h->ref_count[list]==2){\n                                val= get_bits1(&s->gb)^1;\n                            }else{\n                                val= get_ue_golomb_31(&s->gb);\n                                if(val >= h->ref_count[list]){\n                                    av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\\n", val);\n                                    return -1;\n                                }\n                            }\n                        }else\n                            val= LIST_NOT_USED&0xFF;\n                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);\n                    }\n            }\n            for(list=0; list<h->list_count; list++){\n                for(i=0; i<2; i++){\n                    unsigned int val;\n                    if(IS_DIR(mb_type, i, list)){\n                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);\n                        mx += get_se_golomb(&s->gb);\n                        my += get_se_golomb(&s->gb);\n                        tprintf(s->avctx, "final mv:%d %d\\n", mx, my);\n                        val= pack16to32(mx,my);\n                    }else\n                        val=0;\n                    fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);\n                }\n            }\n        }\n    }\n    if(IS_INTER(mb_type))\n        write_back_motion(h, mb_type);\n    if(!IS_INTRA16x16(mb_type)){\n        cbp= get_ue_golomb(&s->gb);\n        if(cbp > 47){\n            av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\\n", cbp, s->mb_x, s->mb_y);\n            return -1;\n        }\n        if(CHROMA){\n            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];\n            else                     cbp= golomb_to_inter_cbp   [cbp];\n        }else{\n            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];\n            else                     cbp= golomb_to_inter_cbp_gray[cbp];\n        }\n    }\n    h->cbp = cbp;\n    if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){\n        if(get_bits1(&s->gb)){\n            mb_type |= MB_TYPE_8x8DCT;\n            h->cbp_table[mb_xy]= cbp;\n        }\n    }\n    s->current_picture.mb_type[mb_xy]= mb_type;\n    if(cbp || IS_INTRA16x16(mb_type)){\n        int i8x8, i4x4, chroma_idx;\n        int dquant;\n        GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;\n        const uint8_t *scan, *scan8x8, *dc_scan;\n        if(IS_INTERLACED(mb_type)){\n            scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;\n            scan= s->qscale ? h->field_scan : h->field_scan_q0;\n            dc_scan= luma_dc_field_scan;\n        }else{\n            scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;\n            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;\n            dc_scan= luma_dc_zigzag_scan;\n        }\n        dquant= get_se_golomb(&s->gb);\n        if( dquant > 25 || dquant < -26 ){\n            av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\\n", dquant, s->mb_x, s->mb_y);\n            return -1;\n        }\n        s->qscale += dquant;\n        if(((unsigned)s->qscale) > 51){\n            if(s->qscale<0) s->qscale+= 52;\n            else            s->qscale-= 52;\n        }\n        h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);\n        h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);\n        if(IS_INTRA16x16(mb_type)){\n            if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){\n                return -1;\n            }\n            assert((cbp&15) == 0 || (cbp&15) == 15);\n            if(cbp&15){\n                for(i8x8=0; i8x8<4; i8x8++){\n                    for(i4x4=0; i4x4<4; i4x4++){\n                        const int index= i4x4 + 4*i8x8;\n                        if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){\n                            return -1;\n                        }\n                    }\n                }\n            }else{\n                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);\n            }\n        }else{\n            for(i8x8=0; i8x8<4; i8x8++){\n                if(cbp & (1<<i8x8)){\n                    if(IS_8x8DCT(mb_type)){\n                        DCTELEM *buf = &h->mb[64*i8x8];\n                        uint8_t *nnz;\n                        for(i4x4=0; i4x4<4; i4x4++){\n                            if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,\n                                                h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )\n                                return -1;\n                        }\n                        nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];\n                        nnz[0] += nnz[1] + nnz[8] + nnz[9];\n                    }else{\n                        for(i4x4=0; i4x4<4; i4x4++){\n                            const int index= i4x4 + 4*i8x8;\n                            if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){\n                                return -1;\n                            }\n                        }\n                    }\n                }else{\n                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];\n                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;\n                }\n            }\n        }\n        if(cbp&0x30){\n            for(chroma_idx=0; chroma_idx<2; chroma_idx++)\n                if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){\n                    return -1;\n                }\n        }\n        if(cbp&0x20){\n            for(chroma_idx=0; chroma_idx<2; chroma_idx++){\n                const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];\n                for(i4x4=0; i4x4<4; i4x4++){\n                    const int index= 16 + 4*chroma_idx + i4x4;\n                    if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){\n                        return -1;\n                    }\n                }\n            }\n        }else{\n            uint8_t * const nnz= &h->non_zero_count_cache[0];\n            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =\n            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;\n        }\n    }else{\n        uint8_t * const nnz= &h->non_zero_count_cache[0];\n        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);\n        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =\n        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;\n    }\n    s->current_picture.qscale_table[mb_xy]= s->qscale;\n    write_back_non_zero_count(h);\n    if(MB_MBAFF){\n        h->ref_count[0] >>= 1;\n        h->ref_count[1] >>= 1;\n    }\n    return 0;\n}', 'void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type){\n    MpegEncContext * const s = &h->s;\n    int b8_stride = h->b8_stride;\n    int b4_stride = h->b_stride;\n    int mb_xy = h->mb_xy;\n    int mb_type_col[2];\n    const int16_t (*l1mv0)[2], (*l1mv1)[2];\n    const int8_t *l1ref0, *l1ref1;\n    const int is_b8x8 = IS_8X8(*mb_type);\n    unsigned int sub_mb_type;\n    int i8, i4;\n    assert(h->ref_list[1][0].reference&3);\n#define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)\n    if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){\n        if(!IS_INTERLACED(*mb_type)){\n            int cur_poc = s->current_picture_ptr->poc;\n            int *col_poc = h->ref_list[1]->field_poc;\n            int col_parity = FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc);\n            mb_xy= s->mb_x + ((s->mb_y&~1) + col_parity)*s->mb_stride;\n            b8_stride = 0;\n        }else if(!(s->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff){\n            int fieldoff= 2*(h->ref_list[1][0].reference)-3;\n            mb_xy += s->mb_stride*fieldoff;\n        }\n        goto single_col;\n    }else{\n        if(IS_INTERLACED(*mb_type)){\n            mb_xy= s->mb_x + (s->mb_y&~1)*s->mb_stride;\n            mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy];\n            mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride];\n            b8_stride *= 3;\n            b4_stride *= 6;\n            if(    (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)\n                && (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA)\n                && !is_b8x8){\n                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2;\n                *mb_type   |= MB_TYPE_16x8 |MB_TYPE_L0L1|MB_TYPE_DIRECT2;\n            }else{\n                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2;\n                *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;\n            }\n        }else{\nsingle_col:\n            mb_type_col[0] =\n            mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy];\n            if(IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag){\n                sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2;\n                *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;\n            }else if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){\n                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2;\n                *mb_type   |= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2;\n            }else{\n                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2;\n                *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;\n            }\n        }\n    }\n    l1mv0  = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];\n    l1mv1  = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];\n    l1ref0 = &h->ref_list[1][0].ref_index [0][h->mb2b8_xy[mb_xy]];\n    l1ref1 = &h->ref_list[1][0].ref_index [1][h->mb2b8_xy[mb_xy]];\n    if(!b8_stride){\n        if(s->mb_y&1){\n            l1ref0 += h->b8_stride;\n            l1ref1 += h->b8_stride;\n            l1mv0  +=  2*b4_stride;\n            l1mv1  +=  2*b4_stride;\n        }\n    }\n    if(h->direct_spatial_mv_pred){\n        int ref[2];\n        int mv[2][2];\n        int list;\n        for(list=0; list<2; list++){\n            int refa = h->ref_cache[list][scan8[0] - 1];\n            int refb = h->ref_cache[list][scan8[0] - 8];\n            int refc = h->ref_cache[list][scan8[0] - 8 + 4];\n            if(refc == PART_NOT_AVAILABLE)\n                refc = h->ref_cache[list][scan8[0] - 8 - 1];\n            ref[list] = FFMIN3((unsigned)refa, (unsigned)refb, (unsigned)refc);\n            if(ref[list] < 0)\n                ref[list] = -1;\n        }\n        if(ref[0] < 0 && ref[1] < 0){\n            ref[0] = ref[1] = 0;\n            mv[0][0] = mv[0][1] =\n            mv[1][0] = mv[1][1] = 0;\n        }else{\n            for(list=0; list<2; list++){\n                if(ref[list] >= 0)\n                    pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);\n                else\n                    mv[list][0] = mv[list][1] = 0;\n            }\n        }\n        if(ref[1] < 0){\n            if(!is_b8x8)\n                *mb_type &= ~MB_TYPE_L1;\n            sub_mb_type &= ~MB_TYPE_L1;\n        }else if(ref[0] < 0){\n            if(!is_b8x8)\n                *mb_type &= ~MB_TYPE_L0;\n            sub_mb_type &= ~MB_TYPE_L0;\n        }\n        if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){\n            for(i8=0; i8<4; i8++){\n                int x8 = i8&1;\n                int y8 = i8>>1;\n                int xy8 = x8+y8*b8_stride;\n                int xy4 = 3*x8+y8*b4_stride;\n                int a=0, b=0;\n                if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))\n                    continue;\n                h->sub_mb_type[i8] = sub_mb_type;\n                fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);\n                fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);\n                if(!IS_INTRA(mb_type_col[y8])\n                   && (   (l1ref0[xy8] == 0 && FFABS(l1mv0[xy4][0]) <= 1 && FFABS(l1mv0[xy4][1]) <= 1)\n                       || (l1ref0[xy8]  < 0 && l1ref1[xy8] == 0 && FFABS(l1mv1[xy4][0]) <= 1 && FFABS(l1mv1[xy4][1]) <= 1))){\n                    if(ref[0] > 0)\n                        a= pack16to32(mv[0][0],mv[0][1]);\n                    if(ref[1] > 0)\n                        b= pack16to32(mv[1][0],mv[1][1]);\n                }else{\n                    a= pack16to32(mv[0][0],mv[0][1]);\n                    b= pack16to32(mv[1][0],mv[1][1]);\n                }\n                fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, a, 4);\n                fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, b, 4);\n            }\n        }else if(IS_16X16(*mb_type)){\n            int a=0, b=0;\n            fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);\n            fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);\n            if(!IS_INTRA(mb_type_col[0])\n               && (   (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1)\n                   || (l1ref0[0]  < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1\n                       && (h->x264_build>33 || !h->x264_build)))){\n                if(ref[0] > 0)\n                    a= pack16to32(mv[0][0],mv[0][1]);\n                if(ref[1] > 0)\n                    b= pack16to32(mv[1][0],mv[1][1]);\n            }else{\n                a= pack16to32(mv[0][0],mv[0][1]);\n                b= pack16to32(mv[1][0],mv[1][1]);\n            }\n            fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4);\n            fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4);\n        }else{\n            for(i8=0; i8<4; i8++){\n                const int x8 = i8&1;\n                const int y8 = i8>>1;\n                if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))\n                    continue;\n                h->sub_mb_type[i8] = sub_mb_type;\n                fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4);\n                fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4);\n                fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);\n                fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);\n                if(!IS_INTRA(mb_type_col[0]) && (   l1ref0[x8 + y8*b8_stride] == 0\n                                              || (l1ref0[x8 + y8*b8_stride] < 0 && l1ref1[x8 + y8*b8_stride] == 0\n                                                  && (h->x264_build>33 || !h->x264_build)))){\n                    const int16_t (*l1mv)[2]= l1ref0[x8 + y8*b8_stride] == 0 ? l1mv0 : l1mv1;\n                    if(IS_SUB_8X8(sub_mb_type)){\n                        const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];\n                        if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){\n                            if(ref[0] == 0)\n                                fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);\n                            if(ref[1] == 0)\n                                fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);\n                        }\n                    }else\n                    for(i4=0; i4<4; i4++){\n                        const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];\n                        if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){\n                            if(ref[0] == 0)\n                                *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;\n                            if(ref[1] == 0)\n                                *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;\n                        }\n                    }\n                }\n            }\n        }\n    }else{\n        const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]};\n        const int *dist_scale_factor = h->dist_scale_factor;\n        int ref_offset= 0;\n        if(FRAME_MBAFF && IS_INTERLACED(*mb_type)){\n            map_col_to_list0[0] = h->map_col_to_list0_field[s->mb_y&1][0];\n            map_col_to_list0[1] = h->map_col_to_list0_field[s->mb_y&1][1];\n            dist_scale_factor   =h->dist_scale_factor_field[s->mb_y&1];\n        }\n        if(h->ref_list[1][0].mbaff && IS_INTERLACED(mb_type_col[0]))\n            ref_offset += 16;\n        if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){\n            int y_shift  = 2*!IS_INTERLACED(*mb_type);\n            for(i8=0; i8<4; i8++){\n                const int x8 = i8&1;\n                const int y8 = i8>>1;\n                int ref0, scale;\n                const int16_t (*l1mv)[2]= l1mv0;\n                if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))\n                    continue;\n                h->sub_mb_type[i8] = sub_mb_type;\n                fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);\n                if(IS_INTRA(mb_type_col[y8])){\n                    fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);\n                    fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);\n                    fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);\n                    continue;\n                }\n                ref0 = l1ref0[x8 + y8*b8_stride];\n                if(ref0 >= 0)\n                    ref0 = map_col_to_list0[0][ref0 + ref_offset];\n                else{\n                    ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset];\n                    l1mv= l1mv1;\n                }\n                scale = dist_scale_factor[ref0];\n                fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);\n                {\n                    const int16_t *mv_col = l1mv[x8*3 + y8*b4_stride];\n                    int my_col = (mv_col[1]<<y_shift)/2;\n                    int mx = (scale * mv_col[0] + 128) >> 8;\n                    int my = (scale * my_col + 128) >> 8;\n                    fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);\n                    fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4);\n                }\n            }\n            return;\n        }\n        if(IS_16X16(*mb_type)){\n            int ref, mv0, mv1;\n            fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);\n            if(IS_INTRA(mb_type_col[0])){\n                ref=mv0=mv1=0;\n            }else{\n                const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset]\n                                                : map_col_to_list0[1][l1ref1[0] + ref_offset];\n                const int scale = dist_scale_factor[ref0];\n                const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];\n                int mv_l0[2];\n                mv_l0[0] = (scale * mv_col[0] + 128) >> 8;\n                mv_l0[1] = (scale * mv_col[1] + 128) >> 8;\n                ref= ref0;\n                mv0= pack16to32(mv_l0[0],mv_l0[1]);\n                mv1= pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);\n            }\n            fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);\n            fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4);\n            fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4);\n        }else{\n            for(i8=0; i8<4; i8++){\n                const int x8 = i8&1;\n                const int y8 = i8>>1;\n                int ref0, scale;\n                const int16_t (*l1mv)[2]= l1mv0;\n                if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))\n                    continue;\n                h->sub_mb_type[i8] = sub_mb_type;\n                fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);\n                if(IS_INTRA(mb_type_col[0])){\n                    fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);\n                    fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);\n                    fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);\n                    continue;\n                }\n                ref0 = l1ref0[x8 + y8*b8_stride] + ref_offset;\n                if(ref0 >= 0)\n                    ref0 = map_col_to_list0[0][ref0];\n                else{\n                    ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset];\n                    l1mv= l1mv1;\n                }\n                scale = dist_scale_factor[ref0];\n                fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);\n                if(IS_SUB_8X8(sub_mb_type)){\n                    const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];\n                    int mx = (scale * mv_col[0] + 128) >> 8;\n                    int my = (scale * mv_col[1] + 128) >> 8;\n                    fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);\n                    fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4);\n                }else\n                for(i4=0; i4<4; i4++){\n                    const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];\n                    int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]];\n                    mv_l0[0] = (scale * mv_col[0] + 128) >> 8;\n                    mv_l0[1] = (scale * mv_col[1] + 128) >> 8;\n                    *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] =\n                        pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);\n                }\n            }\n        }\n    }\n}']