static int is_intra_more_likely(ERContext *s)

{

    int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y;



    if (!s->last_pic.f || !s->last_pic.f->data[0])

        return 1; // no previous frame available -> use spatial prediction



    undamaged_count = 0;

    for (i = 0; i < s->mb_num; i++) {

        const int mb_xy = s->mb_index2xy[i];

        const int error = s->error_status_table[mb_xy];

        if (!((error & ER_DC_ERROR) && (error & ER_MV_ERROR)))

            undamaged_count++;

    }



    if (s->avctx->codec_id == AV_CODEC_ID_H264 && s->ref_count <= 0)

        return 1;



    if (undamaged_count < 5)

        return 0; // almost all MBs damaged -> use temporal prediction



#if FF_API_XVMC

FF_DISABLE_DEPRECATION_WARNINGS

    // prevent dsp.sad() check, that requires access to the image

    if (CONFIG_MPEG_XVMC_DECODER    &&

        s->avctx->xvmc_acceleration &&

        s->cur_pic.f->pict_type == AV_PICTURE_TYPE_I)

        return 1;

FF_ENABLE_DEPRECATION_WARNINGS

#endif /* FF_API_XVMC */



    skip_amount     = FFMAX(undamaged_count / 50, 1); // check only up to 50 MBs

    is_intra_likely = 0;



    j = 0;

    for (mb_y = 0; mb_y < s->mb_height - 1; mb_y++) {

        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {

            int error;

            const int mb_xy = mb_x + mb_y * s->mb_stride;



            error = s->error_status_table[mb_xy];

            if ((error & ER_DC_ERROR) && (error & ER_MV_ERROR))

                continue; // skip damaged



            j++;

            // skip a few to speed things up

            if ((j % skip_amount) != 0)

                continue;



            if (s->cur_pic.f->pict_type == AV_PICTURE_TYPE_I) {

                int *linesize = s->cur_pic.f->linesize;

                uint8_t *mb_ptr      = s->cur_pic.f->data[0] +

                                       mb_x * 16 + mb_y * 16 * linesize[0];

                uint8_t *last_mb_ptr = s->last_pic.f->data[0] +

                                       mb_x * 16 + mb_y * 16 * linesize[0];



                if (s->avctx->codec_id == AV_CODEC_ID_H264) {

                    // FIXME

                } else {

                    ff_thread_await_progress(s->last_pic.tf, mb_y, 0);

                }

                is_intra_likely += s->mecc->sad[0](NULL, last_mb_ptr, mb_ptr,

                                                   linesize[0], 16);

                is_intra_likely -= s->mecc->sad[0](NULL, last_mb_ptr,

                                                   last_mb_ptr + linesize[0] * 16,

                                                   linesize[0], 16);

            } else {

                if (IS_INTRA(s->cur_pic.mb_type[mb_xy]))

                   is_intra_likely++;

                else

                   is_intra_likely--;

            }

        }

    }

    return is_intra_likely > 0;

}

static int is_intra_more_likely(ERContext *s)

{

    int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y;



    if (!s->last_pic.f || !s->last_pic.f->data[0])

        return 1; 



    undamaged_count = 0;

    for (i = 0; i < s->mb_num; i++) {

        const int mb_xy = s->mb_index2xy[i];

        const int error = s->error_status_table[mb_xy];

        if (!((error & ER_DC_ERROR) && (error & ER_MV_ERROR)))

            undamaged_count++;

    }



    if (s->avctx->codec_id == AV_CODEC_ID_H264 && s->ref_count <= 0)

        return 1;



    if (undamaged_count < 5)

        return 0; 



#if FF_API_XVMC

FF_DISABLE_DEPRECATION_WARNINGS

    

    if (CONFIG_MPEG_XVMC_DECODER    &&

        s->avctx->xvmc_acceleration &&

        s->cur_pic.f->pict_type == AV_PICTURE_TYPE_I)

        return 1;

FF_ENABLE_DEPRECATION_WARNINGS

#endif 



    skip_amount     = FFMAX(undamaged_count / 50, 1); 

    is_intra_likely = 0;



    j = 0;

    for (mb_y = 0; mb_y < s->mb_height - 1; mb_y++) {

        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {

            int error;

            const int mb_xy = mb_x + mb_y * s->mb_stride;



            error = s->error_status_table[mb_xy];

            if ((error & ER_DC_ERROR) && (error & ER_MV_ERROR))

                continue; 



            j++;

            

            if ((j % skip_amount) != 0)

                continue;



            if (s->cur_pic.f->pict_type == AV_PICTURE_TYPE_I) {

                int *linesize = s->cur_pic.f->linesize;

                uint8_t *mb_ptr      = s->cur_pic.f->data[0] +

                                       mb_x * 16 + mb_y * 16 * linesize[0];

                uint8_t *last_mb_ptr = s->last_pic.f->data[0] +

                                       mb_x * 16 + mb_y * 16 * linesize[0];



                if (s->avctx->codec_id == AV_CODEC_ID_H264) {

                    

                } else {

                    ff_thread_await_progress(s->last_pic.tf, mb_y, 0);

                }

                is_intra_likely += s->mecc->sad[0](NULL, last_mb_ptr, mb_ptr,

                                                   linesize[0], 16);

                is_intra_likely -= s->mecc->sad[0](NULL, last_mb_ptr,

                                                   last_mb_ptr + linesize[0] * 16,

                                                   linesize[0], 16);

            } else {

                if (IS_INTRA(s->cur_pic.mb_type[mb_xy]))

                   is_intra_likely++;

                else

                   is_intra_likely--;

            }

        }

    }

    return is_intra_likely > 0;

}

static int FUNC_0(ERContext *VAR_0)

{

    int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;



    if (!VAR_0->last_pic.f || !VAR_0->last_pic.f->data[0])

        return 1; 



    VAR_4 = 0;

    for (VAR_2 = 0; VAR_2 < VAR_0->mb_num; VAR_2++) {

        const int mb_xy = VAR_0->mb_index2xy[VAR_2];

        const int error = VAR_0->error_status_table[mb_xy];

        if (!((error & ER_DC_ERROR) && (error & ER_MV_ERROR)))

            VAR_4++;

    }



    if (VAR_0->avctx->codec_id == AV_CODEC_ID_H264 && VAR_0->ref_count <= 0)

        return 1;



    if (VAR_4 < 5)

        return 0; 



#if FF_API_XVMC

FF_DISABLE_DEPRECATION_WARNINGS

    

    if (CONFIG_MPEG_XVMC_DECODER    &&

        VAR_0->avctx->xvmc_acceleration &&

        VAR_0->cur_pic.f->pict_type == AV_PICTURE_TYPE_I)

        return 1;

FF_ENABLE_DEPRECATION_WARNINGS

#endif 



    VAR_5     = FFMAX(VAR_4 / 50, 1); 

    VAR_1 = 0;



    VAR_3 = 0;

    for (VAR_7 = 0; VAR_7 < VAR_0->mb_height - 1; VAR_7++) {

        for (VAR_6 = 0; VAR_6 < VAR_0->mb_width; VAR_6++) {

            int error;

            const int mb_xy = VAR_6 + VAR_7 * VAR_0->mb_stride;



            error = VAR_0->error_status_table[mb_xy];

            if ((error & ER_DC_ERROR) && (error & ER_MV_ERROR))

                continue; 



            VAR_3++;

            

            if ((VAR_3 % VAR_5) != 0)

                continue;



            if (VAR_0->cur_pic.f->pict_type == AV_PICTURE_TYPE_I) {

                int *linesize = VAR_0->cur_pic.f->linesize;

                uint8_t *mb_ptr      = VAR_0->cur_pic.f->data[0] +

                                       VAR_6 * 16 + VAR_7 * 16 * linesize[0];

                uint8_t *last_mb_ptr = VAR_0->last_pic.f->data[0] +

                                       VAR_6 * 16 + VAR_7 * 16 * linesize[0];



                if (VAR_0->avctx->codec_id == AV_CODEC_ID_H264) {

                    

                } else {

                    ff_thread_await_progress(VAR_0->last_pic.tf, VAR_7, 0);

                }

                VAR_1 += VAR_0->mecc->sad[0](NULL, last_mb_ptr, mb_ptr,

                                                   linesize[0], 16);

                VAR_1 -= VAR_0->mecc->sad[0](NULL, last_mb_ptr,

                                                   last_mb_ptr + linesize[0] * 16,

                                                   linesize[0], 16);

            } else {

                if (IS_INTRA(VAR_0->cur_pic.mb_type[mb_xy]))

                   VAR_1++;

                else

                   VAR_1--;

            }

        }

    }

    return VAR_1 > 0;

}

static int FUNC_0(ERContext *VAR_0)
{ int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7; if (!VAR_0->last_pic.f || !VAR_0->last_pic.f->data[0])
return 1; VAR_4 = 0; for (VAR_2 = 0; VAR_2 < VAR_0->mb_num; VAR_2++) { const int mb_xy = VAR_0->mb_index2xy[VAR_2]; const int error = VAR_0->error_status_table[mb_xy]; if (!((error & ER_DC_ERROR) && (error & ER_MV_ERROR)))
VAR_4++; } if (VAR_0->avctx->codec_id == AV_CODEC_ID_H264 && VAR_0->ref_count <= 0)
return 1; if (VAR_4 < 5)
return 0; #if FF_API_XVMC
FF_DISABLE_DEPRECATION_WARNINGS
if (CONFIG_MPEG_XVMC_DECODER    &&
VAR_0->avctx->xvmc_acceleration &&
VAR_0->cur_pic.f->pict_type == AV_PICTURE_TYPE_I)
return 1; FF_ENABLE_DEPRECATION_WARNINGS
#endif
VAR_5     = FFMAX(VAR_4 / 50, 1); VAR_1 = 0; VAR_3 = 0; for (VAR_7 = 0; VAR_7 < VAR_0->mb_height - 1; VAR_7++) { for (VAR_6 = 0; VAR_6 < VAR_0->mb_width; VAR_6++) { int error; const int mb_xy = VAR_6 + VAR_7 * VAR_0->mb_stride; error = VAR_0->error_status_table[mb_xy]; if ((error & ER_DC_ERROR) && (error & ER_MV_ERROR))
continue; VAR_3++; if ((VAR_3 % VAR_5) != 0)
continue; if (VAR_0->cur_pic.f->pict_type == AV_PICTURE_TYPE_I) { int *linesize = VAR_0->cur_pic.f->linesize; uint8_t *mb_ptr      = VAR_0->cur_pic.f->data[0] +
VAR_6 * 16 + VAR_7 * 16 * linesize[0]; uint8_t *last_mb_ptr = VAR_0->last_pic.f->data[0] +
VAR_6 * 16 + VAR_7 * 16 * linesize[0]; if (VAR_0->avctx->codec_id == AV_CODEC_ID_H264) { } else { ff_thread_await_progress(VAR_0->last_pic.tf, VAR_7, 0); } VAR_1 += VAR_0->mecc->sad[0](NULL, last_mb_ptr, mb_ptr,
linesize[0], 16); VAR_1 -= VAR_0->mecc->sad[0](NULL, last_mb_ptr,
last_mb_ptr + linesize[0] * 16,
linesize[0], 16); } else { if (IS_INTRA(VAR_0->cur_pic.mb_type[mb_xy]))
VAR_1++; else
VAR_1--; } } } return VAR_1 > 0; }