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

libavcodec/mpeg12.c:1959:9: Call
1957.         s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
1958. 
1959.         ff_er_frame_end(s);
              ^
1960. 
1961.         MPV_frame_end(s);

libavcodec/error_resilience.c:781:1: Parameter `s->list_count`
  779. }
  780. 
  781. void ff_er_frame_end(MpegEncContext *s){
       ^
  782.     int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error;
  783.     int distance;

libavcodec/error_resilience.c:1000:13: Call
   998.             s->mb_x= mb_x;
   999.             s->mb_y= mb_y;
  1000.             decode_mb(s, 0/*FIXME h264 partitioned slices need this set*/);
                    ^
  1001.         }
  1002.     }

libavcodec/error_resilience.c:43:1: Parameter `s->list_count`
    41. #undef mb_intra
    42. 
    43. static void decode_mb(MpegEncContext *s, int ref){
        ^
    44.     s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* s->linesize  ) + s->mb_x * 16;
    45.     s->dest[1] = s->current_picture.data[1] + (s->mb_y * (16>>s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16>>s->chroma_x_shift);

libavcodec/error_resilience.c:59:9: Call
    57.         fill_rectangle(h->mv_cache[0][ scan8[0] ], 4, 4, 8, pack16to32(s->mv[0][0][0],s->mv[0][0][1]), 4);
    58.         assert(!FRAME_MBAFF);
    59.         ff_h264_hl_decode_mb(h);
                ^
    60.     }else{
    61.         assert(ref==0);

libavcodec/h264.c:2037:1: Parameter `h->list_count`
      2035. }
      2036. 
      2037. void ff_h264_hl_decode_mb(H264Context *h){
            ^
      2038.     MpegEncContext * const s = &h->s;
      2039.     const int mb_xy= h->mb_xy;

libavcodec/h264.c:2045:13: Call
      2043.     if (CHROMA444) {
      2044.         if(is_complex || h->pixel_shift)
      2045.             hl_decode_mb_444_complex(h);
                        ^
      2046.         else
      2047.             hl_decode_mb_444_simple(h);

libavcodec/h264.c:2029:1: Parameter `h->list_count`
        2027. }
        2028. 
        2029. static void av_noinline hl_decode_mb_444_complex(H264Context *h){
              ^
        2030.     hl_decode_mb_444_internal(h, 0, h->pixel_shift);
        2031. }

libavcodec/h264.c:2030:5: Call
        2028. 
        2029. static void av_noinline hl_decode_mb_444_complex(H264Context *h){
        2030.     hl_decode_mb_444_internal(h, 0, h->pixel_shift);
                  ^
        2031. }
        2032. 

libavcodec/h264.c:1916:1: Parameter `h->list_count`
          1914. }
          1915. 
          1916. static av_always_inline void hl_decode_mb_444_internal(H264Context *h, int simple, int pixel_shift){
                ^
          1917.     MpegEncContext * const s = &h->s;
          1918.     const int mb_x= s->mb_x;

libavcodec/h264.c:1995:13: Call
          1993.                 xchg_mb_border(h, dest[0], dest[1], dest[2], linesize, linesize, 0, 1, simple, pixel_shift);
          1994.         }else{
          1995.             hl_motion(h, dest[0], dest[1], dest[2],
                            ^
          1996.                       s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
          1997.                       s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,

libavcodec/h264.c:680:1: Parameter `h->list_count`
            678. }
            679. 
            680. static av_always_inline void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                 ^
            681.                       qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
            682.                       qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),

libavcodec/h264.c:692:9: Call
            690. 
            691.     if(HAVE_PTHREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
            692.         await_references(h);
                         ^
            693.     prefetch_motion(h, 0, pixel_shift, chroma444);
            694. 

libavcodec/h264.c:290:1: <LHS trace>
288.  * @param h the H264 context
289.  */
290. static void await_references(H264Context *h){
     ^
291.     MpegEncContext * const s = &h->s;
292.     const int mb_xy= h->mb_xy;

libavcodec/h264.c:290:1: Parameter `h->list_count`
              288.  * @param h the H264 context
              289.  */
              290. static void await_references(H264Context *h){
                   ^
              291.     MpegEncContext * const s = &h->s;
              292.     const int mb_xy= h->mb_xy;

libavcodec/h264.c:348:9: Binary operation: ([0, +oo] - 1):unsigned32 by call to `ff_er_frame_end` 
              346.     }
              347. 
              348.     for(list=h->list_count-1; list>=0; list--){
                           ^
              349.         for(ref=0; ref<48 && nrefs[list]; ref++){
              350.             int row = refs[list][ref];

static void await_references(H264Context *h){
    MpegEncContext * const s = &h->s;
    const int mb_xy= h->mb_xy;
    const int mb_type= s->current_picture.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->reference - 1;
                int ref_field_picture = ref_pic->field_picture;
                int pic_height = 16*s->mb_height >> ref_field_picture;
                row <<= MB_MBAFF;
                nrefs[list]--;
                if(!FIELD_PICTURE && ref_field_picture){
                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) - !(row&1), pic_height-1), 1);
                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1)           , pic_height-1), 0);
                }else if(FIELD_PICTURE && !ref_field_picture){
                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row*2 + ref_field    , pic_height-1), 0);
                }else if(FIELD_PICTURE){
                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), ref_field);
                }else{
                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), 0);
                }
            }
        }
    }
}
['static int slice_end(AVCodecContext *avctx, AVFrame *pict)\n{\n    Mpeg1Context *s1 = avctx->priv_data;\n    MpegEncContext *s = &s1->mpeg_enc_ctx;\n    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)\n        return 0;\n    if (s->avctx->hwaccel) {\n        if (s->avctx->hwaccel->end_frame(s->avctx) < 0)\n            av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\\n");\n    }\n    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)\n        ff_xvmc_field_end(s);\n    if (  !s->first_field) {\n        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;\n        ff_er_frame_end(s);\n        MPV_frame_end(s);\n        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {\n            *pict= *(AVFrame*)s->current_picture_ptr;\n            ff_print_debug_info(s, pict);\n        } else {\n            if (avctx->active_thread_type & FF_THREAD_FRAME)\n                s->picture_number++;\n            if (s->last_picture_ptr != NULL) {\n                *pict= *(AVFrame*)s->last_picture_ptr;\n                 ff_print_debug_info(s, pict);\n            }\n        }\n        return 1;\n    } else {\n        return 0;\n    }\n}', 'void ff_er_frame_end(MpegEncContext *s){\n    int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error;\n    int distance;\n    int threshold_part[4]= {100,100,100};\n    int threshold= 50;\n    int is_intra_likely;\n    int size = s->b8_stride * 2 * s->mb_height;\n    Picture *pic= s->current_picture_ptr;\n    if(!s->error_recognition || s->error_count==0 || s->avctx->lowres ||\n       s->avctx->hwaccel ||\n       s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU ||\n       s->picture_structure != PICT_FRAME ||\n       s->error_count==3*s->mb_width*(s->avctx->skip_top + s->avctx->skip_bottom)) return;\n    if(s->current_picture.motion_val[0] == NULL){\n        av_log(s->avctx, AV_LOG_ERROR, "Warning MVs not available\\n");\n        for(i=0; i<2; i++){\n            pic->ref_index[i]= av_mallocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t));\n            pic->motion_val_base[i]= av_mallocz((size+4) * 2 * sizeof(uint16_t));\n            pic->motion_val[i]= pic->motion_val_base[i]+4;\n        }\n        pic->motion_subsample_log2= 3;\n        s->current_picture= *s->current_picture_ptr;\n    }\n    if(s->avctx->debug&FF_DEBUG_ER){\n        for(mb_y=0; mb_y<s->mb_height; mb_y++){\n            for(mb_x=0; mb_x<s->mb_width; mb_x++){\n                int status= s->error_status_table[mb_x + mb_y*s->mb_stride];\n                av_log(s->avctx, AV_LOG_DEBUG, "%2X ", status);\n            }\n            av_log(s->avctx, AV_LOG_DEBUG, "\\n");\n        }\n    }\n    for(error_type=1; error_type<=3; error_type++){\n        int end_ok=0;\n        for(i=s->mb_num-1; i>=0; i--){\n            const int mb_xy= s->mb_index2xy[i];\n            int error= s->error_status_table[mb_xy];\n            if(error&(1<<error_type))\n                end_ok=1;\n            if(error&(8<<error_type))\n                end_ok=1;\n            if(!end_ok)\n                s->error_status_table[mb_xy]|= 1<<error_type;\n            if(error&VP_START)\n                end_ok=0;\n        }\n    }\n    if(s->partitioned_frame){\n        int end_ok=0;\n        for(i=s->mb_num-1; i>=0; i--){\n            const int mb_xy= s->mb_index2xy[i];\n            int error= s->error_status_table[mb_xy];\n            if(error&AC_END)\n                end_ok=0;\n            if((error&MV_END) || (error&DC_END) || (error&AC_ERROR))\n                end_ok=1;\n            if(!end_ok)\n                s->error_status_table[mb_xy]|= AC_ERROR;\n            if(error&VP_START)\n                end_ok=0;\n        }\n    }\n    if(s->error_recognition>=4){\n        int end_ok=1;\n        for(i=s->mb_num-2; i>=s->mb_width+100; i--){\n            const int mb_xy= s->mb_index2xy[i];\n            int error1= s->error_status_table[mb_xy  ];\n            int error2= s->error_status_table[s->mb_index2xy[i+1]];\n            if(error1&VP_START)\n                end_ok=1;\n            if(   error2==(VP_START|DC_ERROR|AC_ERROR|MV_ERROR|AC_END|DC_END|MV_END)\n               && error1!=(VP_START|DC_ERROR|AC_ERROR|MV_ERROR|AC_END|DC_END|MV_END)\n               && ((error1&AC_END) || (error1&DC_END) || (error1&MV_END))){\n                end_ok=0;\n            }\n            if(!end_ok)\n                s->error_status_table[mb_xy]|= DC_ERROR|AC_ERROR|MV_ERROR;\n        }\n    }\n    distance=9999999;\n    for(error_type=1; error_type<=3; error_type++){\n        for(i=s->mb_num-1; i>=0; i--){\n            const int mb_xy= s->mb_index2xy[i];\n            int error= s->error_status_table[mb_xy];\n            if(!s->mbskip_table[mb_xy])\n                distance++;\n            if(error&(1<<error_type))\n                distance= 0;\n            if(s->partitioned_frame){\n                if(distance < threshold_part[error_type-1])\n                    s->error_status_table[mb_xy]|= 1<<error_type;\n            }else{\n                if(distance < threshold)\n                    s->error_status_table[mb_xy]|= 1<<error_type;\n            }\n            if(error&VP_START)\n                distance= 9999999;\n        }\n    }\n    error=0;\n    for(i=0; i<s->mb_num; i++){\n        const int mb_xy= s->mb_index2xy[i];\n        int old_error= s->error_status_table[mb_xy];\n        if(old_error&VP_START)\n            error= old_error& (DC_ERROR|AC_ERROR|MV_ERROR);\n        else{\n            error|= old_error& (DC_ERROR|AC_ERROR|MV_ERROR);\n            s->error_status_table[mb_xy]|= error;\n        }\n    }\n    if(!s->partitioned_frame){\n        for(i=0; i<s->mb_num; i++){\n            const int mb_xy= s->mb_index2xy[i];\n            error= s->error_status_table[mb_xy];\n            if(error&(AC_ERROR|DC_ERROR|MV_ERROR))\n                error|= AC_ERROR|DC_ERROR|MV_ERROR;\n            s->error_status_table[mb_xy]= error;\n        }\n    }\n    dc_error= ac_error= mv_error=0;\n    for(i=0; i<s->mb_num; i++){\n        const int mb_xy= s->mb_index2xy[i];\n        error= s->error_status_table[mb_xy];\n        if(error&DC_ERROR) dc_error ++;\n        if(error&AC_ERROR) ac_error ++;\n        if(error&MV_ERROR) mv_error ++;\n    }\n    av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors\\n", dc_error, ac_error, mv_error);\n    is_intra_likely= is_intra_more_likely(s);\n    for(i=0; i<s->mb_num; i++){\n        const int mb_xy= s->mb_index2xy[i];\n        error= s->error_status_table[mb_xy];\n        if(!((error&DC_ERROR) && (error&MV_ERROR)))\n            continue;\n        if(is_intra_likely)\n            s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA4x4;\n        else\n            s->current_picture.mb_type[mb_xy]= MB_TYPE_16x16 | MB_TYPE_L0;\n    }\n    if (!s->last_picture.data[0] && !s->next_picture.data[0])\n        for(i=0; i<s->mb_num; i++){\n            const int mb_xy= s->mb_index2xy[i];\n            if(!IS_INTRA(s->current_picture.mb_type[mb_xy]))\n                s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA4x4;\n        }\n    for(mb_y=0; mb_y<s->mb_height; mb_y++){\n        for(mb_x=0; mb_x<s->mb_width; mb_x++){\n            const int mb_xy= mb_x + mb_y * s->mb_stride;\n            const int mb_type= s->current_picture.mb_type[mb_xy];\n            int dir = !s->last_picture.data[0];\n            error= s->error_status_table[mb_xy];\n            if(IS_INTRA(mb_type)) continue;\n            if(error&MV_ERROR) continue;\n            if(!(error&AC_ERROR)) continue;\n            s->mv_dir = dir ? MV_DIR_BACKWARD : MV_DIR_FORWARD;\n            s->mb_intra=0;\n            s->mb_skipped=0;\n            if(IS_8X8(mb_type)){\n                int mb_index= mb_x*2 + mb_y*2*s->b8_stride;\n                int j;\n                s->mv_type = MV_TYPE_8X8;\n                for(j=0; j<4; j++){\n                    s->mv[0][j][0] = s->current_picture.motion_val[dir][ mb_index + (j&1) + (j>>1)*s->b8_stride ][0];\n                    s->mv[0][j][1] = s->current_picture.motion_val[dir][ mb_index + (j&1) + (j>>1)*s->b8_stride ][1];\n                }\n            }else{\n                s->mv_type = MV_TYPE_16X16;\n                s->mv[0][0][0] = s->current_picture.motion_val[dir][ mb_x*2 + mb_y*2*s->b8_stride ][0];\n                s->mv[0][0][1] = s->current_picture.motion_val[dir][ mb_x*2 + mb_y*2*s->b8_stride ][1];\n            }\n            s->dsp.clear_blocks(s->block[0]);\n            s->mb_x= mb_x;\n            s->mb_y= mb_y;\n            decode_mb(s, 0 );\n        }\n    }\n    if(s->pict_type==AV_PICTURE_TYPE_B){\n        for(mb_y=0; mb_y<s->mb_height; mb_y++){\n            for(mb_x=0; mb_x<s->mb_width; mb_x++){\n                int xy= mb_x*2 + mb_y*2*s->b8_stride;\n                const int mb_xy= mb_x + mb_y * s->mb_stride;\n                const int mb_type= s->current_picture.mb_type[mb_xy];\n                error= s->error_status_table[mb_xy];\n                if(IS_INTRA(mb_type)) continue;\n                if(!(error&MV_ERROR)) continue;\n                if(!(error&AC_ERROR)) continue;\n                s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD;\n                if(!s->last_picture.data[0]) s->mv_dir &= ~MV_DIR_FORWARD;\n                if(!s->next_picture.data[0]) s->mv_dir &= ~MV_DIR_BACKWARD;\n                s->mb_intra=0;\n                s->mv_type = MV_TYPE_16X16;\n                s->mb_skipped=0;\n                if(s->pp_time){\n                    int time_pp= s->pp_time;\n                    int time_pb= s->pb_time;\n                    if (s->avctx->codec_id == CODEC_ID_H264) {\n                    } else {\n                        ff_thread_await_progress((AVFrame *) s->next_picture_ptr,\n                                                 mb_y, 0);\n                    }\n                    s->mv[0][0][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp;\n                    s->mv[0][0][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp;\n                    s->mv[1][0][0] = s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;\n                    s->mv[1][0][1] = s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;\n                }else{\n                    s->mv[0][0][0]= 0;\n                    s->mv[0][0][1]= 0;\n                    s->mv[1][0][0]= 0;\n                    s->mv[1][0][1]= 0;\n                }\n                s->dsp.clear_blocks(s->block[0]);\n                s->mb_x= mb_x;\n                s->mb_y= mb_y;\n                decode_mb(s, 0);\n            }\n        }\n    }else\n        guess_mv(s);\n    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)\n        goto ec_clean;\n    for(mb_y=0; mb_y<s->mb_height; mb_y++){\n        for(mb_x=0; mb_x<s->mb_width; mb_x++){\n            int dc, dcu, dcv, y, n;\n            int16_t *dc_ptr;\n            uint8_t *dest_y, *dest_cb, *dest_cr;\n            const int mb_xy= mb_x + mb_y * s->mb_stride;\n            const int mb_type= s->current_picture.mb_type[mb_xy];\n            error= s->error_status_table[mb_xy];\n            if(IS_INTRA(mb_type) && s->partitioned_frame) continue;\n            dest_y = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;\n            dest_cb= s->current_picture.data[1] + mb_x*8  + mb_y*8 *s->uvlinesize;\n            dest_cr= s->current_picture.data[2] + mb_x*8  + mb_y*8 *s->uvlinesize;\n            dc_ptr= &s->dc_val[0][mb_x*2 + mb_y*2*s->b8_stride];\n            for(n=0; n<4; n++){\n                dc=0;\n                for(y=0; y<8; y++){\n                    int x;\n                    for(x=0; x<8; x++){\n                       dc+= dest_y[x + (n&1)*8 + (y + (n>>1)*8)*s->linesize];\n                    }\n                }\n                dc_ptr[(n&1) + (n>>1)*s->b8_stride]= (dc+4)>>3;\n            }\n            dcu=dcv=0;\n            for(y=0; y<8; y++){\n                int x;\n                for(x=0; x<8; x++){\n                    dcu+=dest_cb[x + y*(s->uvlinesize)];\n                    dcv+=dest_cr[x + y*(s->uvlinesize)];\n                }\n            }\n            s->dc_val[1][mb_x + mb_y*s->mb_stride]= (dcu+4)>>3;\n            s->dc_val[2][mb_x + mb_y*s->mb_stride]= (dcv+4)>>3;\n        }\n    }\n    guess_dc(s, s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride, 1);\n    guess_dc(s, s->dc_val[1], s->mb_width  , s->mb_height  , s->mb_stride, 0);\n    guess_dc(s, s->dc_val[2], s->mb_width  , s->mb_height  , s->mb_stride, 0);\n    filter181(s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride);\n    for(mb_y=0; mb_y<s->mb_height; mb_y++){\n        for(mb_x=0; mb_x<s->mb_width; mb_x++){\n            uint8_t *dest_y, *dest_cb, *dest_cr;\n            const int mb_xy= mb_x + mb_y * s->mb_stride;\n            const int mb_type= s->current_picture.mb_type[mb_xy];\n            error= s->error_status_table[mb_xy];\n            if(IS_INTER(mb_type)) continue;\n            if(!(error&AC_ERROR)) continue;\n            dest_y = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;\n            dest_cb= s->current_picture.data[1] + mb_x*8  + mb_y*8 *s->uvlinesize;\n            dest_cr= s->current_picture.data[2] + mb_x*8  + mb_y*8 *s->uvlinesize;\n            put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);\n        }\n    }\n    if(s->avctx->error_concealment&FF_EC_DEBLOCK){\n        h_block_filter(s, s->current_picture.data[0], s->mb_width*2, s->mb_height*2, s->linesize  , 1);\n        h_block_filter(s, s->current_picture.data[1], s->mb_width  , s->mb_height  , s->uvlinesize, 0);\n        h_block_filter(s, s->current_picture.data[2], s->mb_width  , s->mb_height  , s->uvlinesize, 0);\n        v_block_filter(s, s->current_picture.data[0], s->mb_width*2, s->mb_height*2, s->linesize  , 1);\n        v_block_filter(s, s->current_picture.data[1], s->mb_width  , s->mb_height  , s->uvlinesize, 0);\n        v_block_filter(s, s->current_picture.data[2], s->mb_width  , s->mb_height  , s->uvlinesize, 0);\n    }\nec_clean:\n    for(i=0; i<s->mb_num; i++){\n        const int mb_xy= s->mb_index2xy[i];\n        int error= s->error_status_table[mb_xy];\n        if(s->pict_type!=AV_PICTURE_TYPE_B && (error&(DC_ERROR|MV_ERROR|AC_ERROR))){\n            s->mbskip_table[mb_xy]=0;\n        }\n        s->mbintra_table[mb_xy]=1;\n    }\n}', 'static void decode_mb(MpegEncContext *s, int ref){\n    s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* s->linesize  ) + s->mb_x * 16;\n    s->dest[1] = s->current_picture.data[1] + (s->mb_y * (16>>s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16>>s->chroma_x_shift);\n    s->dest[2] = s->current_picture.data[2] + (s->mb_y * (16>>s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16>>s->chroma_x_shift);\n    if(CONFIG_H264_DECODER && s->codec_id == CODEC_ID_H264){\n        H264Context *h= (void*)s;\n        h->mb_xy= s->mb_x + s->mb_y*s->mb_stride;\n        memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache));\n        assert(ref>=0);\n        if(ref >= h->ref_count[0])\n            ref=0;\n        fill_rectangle(&s->current_picture.ref_index[0][4*h->mb_xy], 2, 2, 2, ref, 1);\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, pack16to32(s->mv[0][0][0],s->mv[0][0][1]), 4);\n        assert(!FRAME_MBAFF);\n        ff_h264_hl_decode_mb(h);\n    }else{\n        assert(ref==0);\n    MPV_decode_mb(s, s->block);\n    }\n}', 'void ff_h264_hl_decode_mb(H264Context *h){\n    MpegEncContext * const s = &h->s;\n    const int mb_xy= h->mb_xy;\n    const int mb_type= s->current_picture.mb_type[mb_xy];\n    int is_complex = CONFIG_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->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(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 void av_noinline hl_decode_mb_444_complex(H264Context *h){\n    hl_decode_mb_444_internal(h, 0, h->pixel_shift);\n}', 'static av_always_inline void hl_decode_mb_444_internal(H264Context *h, int simple, int pixel_shift){\n    MpegEncContext * const s = &h->s;\n    const int mb_x= s->mb_x;\n    const int mb_y= s->mb_y;\n    const int mb_xy= h->mb_xy;\n    const int mb_type= s->current_picture.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 && (s->qscale == 0 && h->sps.transform_bypass);\n    const int plane_count = (simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) ? 3 : 1;\n    for (p = 0; p < plane_count; p++)\n    {\n        dest[p] = s->current_picture.data[p] + ((mb_x << pixel_shift) + mb_y * s->linesize) * 16;\n        s->dsp.prefetch(dest[p] + (s->mb_x&3)*4*s->linesize + (64 << pixel_shift), s->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 = s->linesize * 2;\n        block_offset = &h->block_offset[48];\n        if(mb_y&1)\n            for (p = 0; p < 3; p++)\n                dest[p] -= s->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)^(s->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, 8, (16+ref)^(s->mb_y&1), 1);\n                    }\n                }\n            }\n        }\n    } else {\n        linesize   = h->mb_linesize = h->mb_uvlinesize = s->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            }\n        } else {\n            for (p = 0; p < plane_count; p++) {\n                for (i = 0; i < 16; i++) {\n                    memcpy(dest[p] + i*linesize, h->mb + p*128 + i*8, 16);\n                }\n            }\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, 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, transform_bypass, pixel_shift, block_offset, linesize, dest[p], p);\n            if(h->deblocking_filter)\n                xchg_mb_border(h, dest[0], dest[1], dest[2], linesize, linesize, 0, 1, simple, pixel_shift);\n        }else{\n            hl_motion(h, dest[0], dest[1], dest[2],\n                      s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,\n                      s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,\n                      h->h264dsp.weight_h264_pixels_tab,\n                      h->h264dsp.biweight_h264_pixels_tab, pixel_shift, 1);\n        }\n        for (p = 0; p < plane_count; p++)\n            hl_decode_mb_idct_luma(h, mb_type, 1, simple, transform_bypass, pixel_shift, block_offset, linesize, dest[p], p);\n    }\n    if(h->cbp || IS_INTRA(mb_type))\n    {\n        s->dsp.clear_blocks(h->mb);\n        s->dsp.clear_blocks(h->mb+(24*16<<pixel_shift));\n    }\n}', 'static av_always_inline void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,\n                      qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),\n                      qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),\n                      h264_weight_func *weight_op, h264_biweight_func *weight_avg,\n                      int pixel_shift, int chroma444){\n    MpegEncContext * const s = &h->s;\n    const int mb_xy= h->mb_xy;\n    const int mb_type= s->current_picture.mb_type[mb_xy];\n    assert(IS_INTER(mb_type));\n    if(HAVE_PTHREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))\n        await_references(h);\n    prefetch_motion(h, 0, pixel_shift, chroma444);\n    if(IS_16X16(mb_type)){\n        mc_part(h, 0, 1, 8, 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                pixel_shift, chroma444);\n    }else if(IS_16X8(mb_type)){\n        mc_part(h, 0, 0, 4, 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[1], &weight_avg[1],\n                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),\n                pixel_shift, chroma444);\n        mc_part(h, 8, 0, 4, 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[1], &weight_avg[1],\n                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1),\n                pixel_shift, chroma444);\n    }else if(IS_8X16(mb_type)){\n        mc_part(h, 0, 0, 8, 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[2], &weight_avg[2],\n                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),\n                pixel_shift, chroma444);\n        mc_part(h, 4, 0, 8, 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[2], &weight_avg[2],\n                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1),\n                pixel_shift, chroma444);\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, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,\n                    qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],\n                    &weight_op[3], &weight_avg[3],\n                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),\n                    pixel_shift, chroma444);\n            }else if(IS_SUB_8X4(sub_mb_type)){\n                mc_part(h, n  , 0, 2, 4 << pixel_shift, dest_y, dest_cb, dest_cr, x_offset, y_offset,\n                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],\n                    &weight_op[4], &weight_avg[4],\n                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),\n                    pixel_shift, chroma444);\n                mc_part(h, n+2, 0, 2, 4 << pixel_shift, 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[4], &weight_avg[4],\n                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),\n                    pixel_shift, chroma444);\n            }else if(IS_SUB_4X8(sub_mb_type)){\n                mc_part(h, n  , 0, 4, 4*h->mb_linesize, 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[5], &weight_avg[5],\n                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),\n                    pixel_shift, chroma444);\n                mc_part(h, n+1, 0, 4, 4*h->mb_linesize, 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[5], &weight_avg[5],\n                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),\n                    pixel_shift, chroma444);\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, 2, 0, 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[6], &weight_avg[6],\n                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),\n                        pixel_shift, chroma444);\n                }\n            }\n        }\n    }\n    prefetch_motion(h, 1, pixel_shift, chroma444);\n}', 'static void await_references(H264Context *h){\n    MpegEncContext * const s = &h->s;\n    const int mb_xy= h->mb_xy;\n    const int mb_type= s->current_picture.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), IS_DIR(sub_mb_type, 0, 1), 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), IS_DIR(sub_mb_type, 0, 1), nrefs);\n                get_lowest_part_y(h, refs, n+2, 4, y_offset+4,\n                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), 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), IS_DIR(sub_mb_type, 0, 1), nrefs);\n                get_lowest_part_y(h, refs, n+1, 8, y_offset,\n                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), 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), IS_DIR(sub_mb_type, 0, 1), 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->reference - 1;\n                int ref_field_picture = ref_pic->field_picture;\n                int pic_height = 16*s->mb_height >> ref_field_picture;\n                row <<= MB_MBAFF;\n                nrefs[list]--;\n                if(!FIELD_PICTURE && ref_field_picture){\n                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) - !(row&1), pic_height-1), 1);\n                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1)           , pic_height-1), 0);\n                }else if(FIELD_PICTURE && !ref_field_picture){\n                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row*2 + ref_field    , pic_height-1), 0);\n                }else if(FIELD_PICTURE){\n                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), ref_field);\n                }else{\n                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), 0);\n                }\n            }\n        }\n    }\n}']