static void guess_mv(MpegEncContext *s)

{

    uint8_t *fixed = av_malloc(s->mb_stride * s->mb_height);

#define MV_FROZEN    3

#define MV_CHANGED   2

#define MV_UNCHANGED 1

    const int mb_stride = s->mb_stride;

    const int mb_width  = s->mb_width;

    const int mb_height = s->mb_height;

    int i, depth, num_avail;

    int mb_x, mb_y, mot_step, mot_stride;



    set_mv_strides(s, &mot_step, &mot_stride);



    num_avail = 0;

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

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

        int f = 0;

        int error = s->error_status_table[mb_xy];



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

            f = MV_FROZEN; // intra // FIXME check

        if (!(error & ER_MV_ERROR))

            f = MV_FROZEN; // inter with undamaged MV



        fixed[mb_xy] = f;

        if (f == MV_FROZEN)

            num_avail++;

        else if(s->last_picture.f.data[0] && s->last_picture.f.motion_val[0]){

            const int mb_y= mb_xy / s->mb_stride;

            const int mb_x= mb_xy % s->mb_stride;

            const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;

            s->current_picture.f.motion_val[0][mot_index][0]= s->last_picture.f.motion_val[0][mot_index][0];

            s->current_picture.f.motion_val[0][mot_index][1]= s->last_picture.f.motion_val[0][mot_index][1];

            s->current_picture.f.ref_index[0][4*mb_xy]      = s->last_picture.f.ref_index[0][4*mb_xy];

        }

    }



    if ((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) ||

        num_avail <= mb_width / 2) {

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

            s->mb_x = 0;

            s->mb_y = mb_y;

            ff_init_block_index(s);

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

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



                ff_update_block_index(s);



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

                    continue;

                if (!(s->error_status_table[mb_xy] & ER_MV_ERROR))

                    continue;



                s->mv_dir     = s->last_picture.f.data[0] ? MV_DIR_FORWARD

                                                          : MV_DIR_BACKWARD;

                s->mb_intra   = 0;

                s->mv_type    = MV_TYPE_16X16;

                s->mb_skipped = 0;



                s->dsp.clear_blocks(s->block[0]);



                s->mb_x        = mb_x;

                s->mb_y        = mb_y;

                s->mv[0][0][0] = 0;

                s->mv[0][0][1] = 0;

                decode_mb(s, 0);

            }

        }

        goto end;

    }



    for (depth = 0; ; depth++) {

        int changed, pass, none_left;



        none_left = 1;

        changed   = 1;

        for (pass = 0; (changed || pass < 2) && pass < 10; pass++) {

            int mb_x, mb_y;

            int score_sum = 0;



            changed = 0;

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

                s->mb_x = 0;

                s->mb_y = mb_y;

                ff_init_block_index(s);

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

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

                    int mv_predictor[8][2] = { { 0 } };

                    int ref[8]             = { 0 };

                    int pred_count         = 0;

                    int j;

                    int best_score         = 256 * 256 * 256 * 64;

                    int best_pred          = 0;

                    const int mot_index    = (mb_x + mb_y * mot_stride) * mot_step;

                    int prev_x, prev_y, prev_ref;



                    ff_update_block_index(s);



                    if ((mb_x ^ mb_y ^ pass) & 1)

                        continue;



                    if (fixed[mb_xy] == MV_FROZEN)

                        continue;

                    assert(!IS_INTRA(s->current_picture.f.mb_type[mb_xy]));

                    assert(s->last_picture_ptr && s->last_picture_ptr->f.data[0]);



                    j = 0;

                    if (mb_x > 0             && fixed[mb_xy - 1]         == MV_FROZEN)

                        j = 1;

                    if (mb_x + 1 < mb_width  && fixed[mb_xy + 1]         == MV_FROZEN)

                        j = 1;

                    if (mb_y > 0             && fixed[mb_xy - mb_stride] == MV_FROZEN)

                        j = 1;

                    if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] == MV_FROZEN)

                        j = 1;

                    if (j == 0)

                        continue;



                    j = 0;

                    if (mb_x > 0             && fixed[mb_xy - 1        ] == MV_CHANGED)

                        j = 1;

                    if (mb_x + 1 < mb_width  && fixed[mb_xy + 1        ] == MV_CHANGED)

                        j = 1;

                    if (mb_y > 0             && fixed[mb_xy - mb_stride] == MV_CHANGED)

                        j = 1;

                    if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] == MV_CHANGED)

                        j = 1;

                    if (j == 0 && pass > 1)

                        continue;



                    none_left = 0;



                    if (mb_x > 0 && fixed[mb_xy - 1]) {

                        mv_predictor[pred_count][0] =

                            s->current_picture.f.motion_val[0][mot_index - mot_step][0];

                        mv_predictor[pred_count][1] =

                            s->current_picture.f.motion_val[0][mot_index - mot_step][1];

                        ref[pred_count] =

                            s->current_picture.f.ref_index[0][4 * (mb_xy - 1)];

                        pred_count++;

                    }

                    if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {

                        mv_predictor[pred_count][0] =

                            s->current_picture.f.motion_val[0][mot_index + mot_step][0];

                        mv_predictor[pred_count][1] =

                            s->current_picture.f.motion_val[0][mot_index + mot_step][1];

                        ref[pred_count] =

                            s->current_picture.f.ref_index[0][4 * (mb_xy + 1)];

                        pred_count++;

                    }

                    if (mb_y > 0 && fixed[mb_xy - mb_stride]) {

                        mv_predictor[pred_count][0] =

                            s->current_picture.f.motion_val[0][mot_index - mot_stride * mot_step][0];

                        mv_predictor[pred_count][1] =

                            s->current_picture.f.motion_val[0][mot_index - mot_stride * mot_step][1];

                        ref[pred_count] =

                            s->current_picture.f.ref_index[0][4 * (mb_xy - s->mb_stride)];

                        pred_count++;

                    }

                    if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride]) {

                        mv_predictor[pred_count][0] =

                            s->current_picture.f.motion_val[0][mot_index + mot_stride * mot_step][0];

                        mv_predictor[pred_count][1] =

                            s->current_picture.f.motion_val[0][mot_index + mot_stride * mot_step][1];

                        ref[pred_count] =

                            s->current_picture.f.ref_index[0][4 * (mb_xy + s->mb_stride)];

                        pred_count++;

                    }

                    if (pred_count == 0)

                        continue;



                    if (pred_count > 1) {

                        int sum_x = 0, sum_y = 0, sum_r = 0;

                        int max_x, max_y, min_x, min_y, max_r, min_r;



                        for (j = 0; j < pred_count; j++) {

                            sum_x += mv_predictor[j][0];

                            sum_y += mv_predictor[j][1];

                            sum_r += ref[j];

                            if (j && ref[j] != ref[j - 1])

                                goto skip_mean_and_median;

                        }



                        /* mean */

                        mv_predictor[pred_count][0] = sum_x / j;

                        mv_predictor[pred_count][1] = sum_y / j;

                                 ref[pred_count]    = sum_r / j;



                        /* median */

                        if (pred_count >= 3) {

                            min_y = min_x = min_r =  99999;

                            max_y = max_x = max_r = -99999;

                        } else {

                            min_x = min_y = max_x = max_y = min_r = max_r = 0;

                        }

                        for (j = 0; j < pred_count; j++) {

                            max_x = FFMAX(max_x, mv_predictor[j][0]);

                            max_y = FFMAX(max_y, mv_predictor[j][1]);

                            max_r = FFMAX(max_r, ref[j]);

                            min_x = FFMIN(min_x, mv_predictor[j][0]);

                            min_y = FFMIN(min_y, mv_predictor[j][1]);

                            min_r = FFMIN(min_r, ref[j]);

                        }

                        mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;

                        mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;

                                 ref[pred_count + 1]    = sum_r - max_r - min_r;



                        if (pred_count == 4) {

                            mv_predictor[pred_count + 1][0] /= 2;

                            mv_predictor[pred_count + 1][1] /= 2;

                                     ref[pred_count + 1]    /= 2;

                        }

                        pred_count += 2;

                    }



skip_mean_and_median:

                    /* zero MV */

                    pred_count++;



                    if (!fixed[mb_xy] && 0) {

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

                            // FIXME

                        } else {

                            ff_thread_await_progress(&s->last_picture_ptr->f,

                                                     mb_y, 0);

                        }

                        if (!s->last_picture.f.motion_val[0] ||

                            !s->last_picture.f.ref_index[0])

                            goto skip_last_mv;

                        prev_x   = s->last_picture.f.motion_val[0][mot_index][0];

                        prev_y   = s->last_picture.f.motion_val[0][mot_index][1];

                        prev_ref = s->last_picture.f.ref_index[0][4 * mb_xy];

                    } else {

                        prev_x   = s->current_picture.f.motion_val[0][mot_index][0];

                        prev_y   = s->current_picture.f.motion_val[0][mot_index][1];

                        prev_ref = s->current_picture.f.ref_index[0][4 * mb_xy];

                    }



                    /* last MV */

                    mv_predictor[pred_count][0] = prev_x;

                    mv_predictor[pred_count][1] = prev_y;

                             ref[pred_count]    = prev_ref;

                    pred_count++;



skip_last_mv:

                    s->mv_dir     = MV_DIR_FORWARD;

                    s->mb_intra   = 0;

                    s->mv_type    = MV_TYPE_16X16;

                    s->mb_skipped = 0;



                    s->dsp.clear_blocks(s->block[0]);



                    s->mb_x = mb_x;

                    s->mb_y = mb_y;



                    for (j = 0; j < pred_count; j++) {

                        int score = 0;

                        uint8_t *src = s->current_picture.f.data[0] +

                                       mb_x * 16 + mb_y * 16 * s->linesize;



                        s->current_picture.f.motion_val[0][mot_index][0] =

                            s->mv[0][0][0] = mv_predictor[j][0];

                        s->current_picture.f.motion_val[0][mot_index][1] =

                            s->mv[0][0][1] = mv_predictor[j][1];



                        // predictor intra or otherwise not available

                        if (ref[j] < 0)

                            continue;



                        decode_mb(s, ref[j]);



                        if (mb_x > 0 && fixed[mb_xy - 1]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k * s->linesize - 1] -

                                               src[k * s->linesize]);

                        }

                        if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k * s->linesize + 15] -

                                               src[k * s->linesize + 16]);

                        }

                        if (mb_y > 0 && fixed[mb_xy - mb_stride]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k - s->linesize] - src[k]);

                        }

                        if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k + s->linesize * 15] -

                                               src[k + s->linesize * 16]);

                        }



                        if (score <= best_score) { // <= will favor the last MV

                            best_score = score;

                            best_pred  = j;

                        }

                    }

                    score_sum += best_score;

                    s->mv[0][0][0] = mv_predictor[best_pred][0];

                    s->mv[0][0][1] = mv_predictor[best_pred][1];



                    for (i = 0; i < mot_step; i++)

                        for (j = 0; j < mot_step; j++) {

                            s->current_picture.f.motion_val[0][mot_index + i + j * mot_stride][0] = s->mv[0][0][0];

                            s->current_picture.f.motion_val[0][mot_index + i + j * mot_stride][1] = s->mv[0][0][1];

                        }



                    decode_mb(s, ref[best_pred]);





                    if (s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y) {

                        fixed[mb_xy] = MV_CHANGED;

                        changed++;

                    } else

                        fixed[mb_xy] = MV_UNCHANGED;

                }

            }



            // printf(".%d/%d", changed, score_sum); fflush(stdout);

        }



        if (none_left)

            goto end;



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

            int mb_xy = s->mb_index2xy[i];

            if (fixed[mb_xy])

                fixed[mb_xy] = MV_FROZEN;

        }

        // printf(":"); fflush(stdout);

    }

end:

    av_free(fixed);

}

static void guess_mv(MpegEncContext *s)

{

    uint8_t *fixed = av_malloc(s->mb_stride * s->mb_height);

#define MV_FROZEN    3

#define MV_CHANGED   2

#define MV_UNCHANGED 1

    const int mb_stride = s->mb_stride;

    const int mb_width  = s->mb_width;

    const int mb_height = s->mb_height;

    int i, depth, num_avail;

    int mb_x, mb_y, mot_step, mot_stride;



    set_mv_strides(s, &mot_step, &mot_stride);



    num_avail = 0;

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

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

        int f = 0;

        int error = s->error_status_table[mb_xy];



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

            f = MV_FROZEN; 

        if (!(error & ER_MV_ERROR))

            f = MV_FROZEN; 



        fixed[mb_xy] = f;

        if (f == MV_FROZEN)

            num_avail++;

        else if(s->last_picture.f.data[0] && s->last_picture.f.motion_val[0]){

            const int mb_y= mb_xy / s->mb_stride;

            const int mb_x= mb_xy % s->mb_stride;

            const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;

            s->current_picture.f.motion_val[0][mot_index][0]= s->last_picture.f.motion_val[0][mot_index][0];

            s->current_picture.f.motion_val[0][mot_index][1]= s->last_picture.f.motion_val[0][mot_index][1];

            s->current_picture.f.ref_index[0][4*mb_xy]      = s->last_picture.f.ref_index[0][4*mb_xy];

        }

    }



    if ((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) ||

        num_avail <= mb_width / 2) {

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

            s->mb_x = 0;

            s->mb_y = mb_y;

            ff_init_block_index(s);

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

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



                ff_update_block_index(s);



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

                    continue;

                if (!(s->error_status_table[mb_xy] & ER_MV_ERROR))

                    continue;



                s->mv_dir     = s->last_picture.f.data[0] ? MV_DIR_FORWARD

                                                          : MV_DIR_BACKWARD;

                s->mb_intra   = 0;

                s->mv_type    = MV_TYPE_16X16;

                s->mb_skipped = 0;



                s->dsp.clear_blocks(s->block[0]);



                s->mb_x        = mb_x;

                s->mb_y        = mb_y;

                s->mv[0][0][0] = 0;

                s->mv[0][0][1] = 0;

                decode_mb(s, 0);

            }

        }

        goto end;

    }



    for (depth = 0; ; depth++) {

        int changed, pass, none_left;



        none_left = 1;

        changed   = 1;

        for (pass = 0; (changed || pass < 2) && pass < 10; pass++) {

            int mb_x, mb_y;

            int score_sum = 0;



            changed = 0;

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

                s->mb_x = 0;

                s->mb_y = mb_y;

                ff_init_block_index(s);

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

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

                    int mv_predictor[8][2] = { { 0 } };

                    int ref[8]             = { 0 };

                    int pred_count         = 0;

                    int j;

                    int best_score         = 256 * 256 * 256 * 64;

                    int best_pred          = 0;

                    const int mot_index    = (mb_x + mb_y * mot_stride) * mot_step;

                    int prev_x, prev_y, prev_ref;



                    ff_update_block_index(s);



                    if ((mb_x ^ mb_y ^ pass) & 1)

                        continue;



                    if (fixed[mb_xy] == MV_FROZEN)

                        continue;

                    assert(!IS_INTRA(s->current_picture.f.mb_type[mb_xy]));

                    assert(s->last_picture_ptr && s->last_picture_ptr->f.data[0]);



                    j = 0;

                    if (mb_x > 0             && fixed[mb_xy - 1]         == MV_FROZEN)

                        j = 1;

                    if (mb_x + 1 < mb_width  && fixed[mb_xy + 1]         == MV_FROZEN)

                        j = 1;

                    if (mb_y > 0             && fixed[mb_xy - mb_stride] == MV_FROZEN)

                        j = 1;

                    if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] == MV_FROZEN)

                        j = 1;

                    if (j == 0)

                        continue;



                    j = 0;

                    if (mb_x > 0             && fixed[mb_xy - 1        ] == MV_CHANGED)

                        j = 1;

                    if (mb_x + 1 < mb_width  && fixed[mb_xy + 1        ] == MV_CHANGED)

                        j = 1;

                    if (mb_y > 0             && fixed[mb_xy - mb_stride] == MV_CHANGED)

                        j = 1;

                    if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] == MV_CHANGED)

                        j = 1;

                    if (j == 0 && pass > 1)

                        continue;



                    none_left = 0;



                    if (mb_x > 0 && fixed[mb_xy - 1]) {

                        mv_predictor[pred_count][0] =

                            s->current_picture.f.motion_val[0][mot_index - mot_step][0];

                        mv_predictor[pred_count][1] =

                            s->current_picture.f.motion_val[0][mot_index - mot_step][1];

                        ref[pred_count] =

                            s->current_picture.f.ref_index[0][4 * (mb_xy - 1)];

                        pred_count++;

                    }

                    if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {

                        mv_predictor[pred_count][0] =

                            s->current_picture.f.motion_val[0][mot_index + mot_step][0];

                        mv_predictor[pred_count][1] =

                            s->current_picture.f.motion_val[0][mot_index + mot_step][1];

                        ref[pred_count] =

                            s->current_picture.f.ref_index[0][4 * (mb_xy + 1)];

                        pred_count++;

                    }

                    if (mb_y > 0 && fixed[mb_xy - mb_stride]) {

                        mv_predictor[pred_count][0] =

                            s->current_picture.f.motion_val[0][mot_index - mot_stride * mot_step][0];

                        mv_predictor[pred_count][1] =

                            s->current_picture.f.motion_val[0][mot_index - mot_stride * mot_step][1];

                        ref[pred_count] =

                            s->current_picture.f.ref_index[0][4 * (mb_xy - s->mb_stride)];

                        pred_count++;

                    }

                    if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride]) {

                        mv_predictor[pred_count][0] =

                            s->current_picture.f.motion_val[0][mot_index + mot_stride * mot_step][0];

                        mv_predictor[pred_count][1] =

                            s->current_picture.f.motion_val[0][mot_index + mot_stride * mot_step][1];

                        ref[pred_count] =

                            s->current_picture.f.ref_index[0][4 * (mb_xy + s->mb_stride)];

                        pred_count++;

                    }

                    if (pred_count == 0)

                        continue;



                    if (pred_count > 1) {

                        int sum_x = 0, sum_y = 0, sum_r = 0;

                        int max_x, max_y, min_x, min_y, max_r, min_r;



                        for (j = 0; j < pred_count; j++) {

                            sum_x += mv_predictor[j][0];

                            sum_y += mv_predictor[j][1];

                            sum_r += ref[j];

                            if (j && ref[j] != ref[j - 1])

                                goto skip_mean_and_median;

                        }



                        

                        mv_predictor[pred_count][0] = sum_x / j;

                        mv_predictor[pred_count][1] = sum_y / j;

                                 ref[pred_count]    = sum_r / j;



                        

                        if (pred_count >= 3) {

                            min_y = min_x = min_r =  99999;

                            max_y = max_x = max_r = -99999;

                        } else {

                            min_x = min_y = max_x = max_y = min_r = max_r = 0;

                        }

                        for (j = 0; j < pred_count; j++) {

                            max_x = FFMAX(max_x, mv_predictor[j][0]);

                            max_y = FFMAX(max_y, mv_predictor[j][1]);

                            max_r = FFMAX(max_r, ref[j]);

                            min_x = FFMIN(min_x, mv_predictor[j][0]);

                            min_y = FFMIN(min_y, mv_predictor[j][1]);

                            min_r = FFMIN(min_r, ref[j]);

                        }

                        mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;

                        mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;

                                 ref[pred_count + 1]    = sum_r - max_r - min_r;



                        if (pred_count == 4) {

                            mv_predictor[pred_count + 1][0] /= 2;

                            mv_predictor[pred_count + 1][1] /= 2;

                                     ref[pred_count + 1]    /= 2;

                        }

                        pred_count += 2;

                    }



skip_mean_and_median:

                    

                    pred_count++;



                    if (!fixed[mb_xy] && 0) {

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

                            

                        } else {

                            ff_thread_await_progress(&s->last_picture_ptr->f,

                                                     mb_y, 0);

                        }

                        if (!s->last_picture.f.motion_val[0] ||

                            !s->last_picture.f.ref_index[0])

                            goto skip_last_mv;

                        prev_x   = s->last_picture.f.motion_val[0][mot_index][0];

                        prev_y   = s->last_picture.f.motion_val[0][mot_index][1];

                        prev_ref = s->last_picture.f.ref_index[0][4 * mb_xy];

                    } else {

                        prev_x   = s->current_picture.f.motion_val[0][mot_index][0];

                        prev_y   = s->current_picture.f.motion_val[0][mot_index][1];

                        prev_ref = s->current_picture.f.ref_index[0][4 * mb_xy];

                    }



                    

                    mv_predictor[pred_count][0] = prev_x;

                    mv_predictor[pred_count][1] = prev_y;

                             ref[pred_count]    = prev_ref;

                    pred_count++;



skip_last_mv:

                    s->mv_dir     = MV_DIR_FORWARD;

                    s->mb_intra   = 0;

                    s->mv_type    = MV_TYPE_16X16;

                    s->mb_skipped = 0;



                    s->dsp.clear_blocks(s->block[0]);



                    s->mb_x = mb_x;

                    s->mb_y = mb_y;



                    for (j = 0; j < pred_count; j++) {

                        int score = 0;

                        uint8_t *src = s->current_picture.f.data[0] +

                                       mb_x * 16 + mb_y * 16 * s->linesize;



                        s->current_picture.f.motion_val[0][mot_index][0] =

                            s->mv[0][0][0] = mv_predictor[j][0];

                        s->current_picture.f.motion_val[0][mot_index][1] =

                            s->mv[0][0][1] = mv_predictor[j][1];



                        

                        if (ref[j] < 0)

                            continue;



                        decode_mb(s, ref[j]);



                        if (mb_x > 0 && fixed[mb_xy - 1]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k * s->linesize - 1] -

                                               src[k * s->linesize]);

                        }

                        if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k * s->linesize + 15] -

                                               src[k * s->linesize + 16]);

                        }

                        if (mb_y > 0 && fixed[mb_xy - mb_stride]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k - s->linesize] - src[k]);

                        }

                        if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k + s->linesize * 15] -

                                               src[k + s->linesize * 16]);

                        }



                        if (score <= best_score) { 

                            best_score = score;

                            best_pred  = j;

                        }

                    }

                    score_sum += best_score;

                    s->mv[0][0][0] = mv_predictor[best_pred][0];

                    s->mv[0][0][1] = mv_predictor[best_pred][1];



                    for (i = 0; i < mot_step; i++)

                        for (j = 0; j < mot_step; j++) {

                            s->current_picture.f.motion_val[0][mot_index + i + j * mot_stride][0] = s->mv[0][0][0];

                            s->current_picture.f.motion_val[0][mot_index + i + j * mot_stride][1] = s->mv[0][0][1];

                        }



                    decode_mb(s, ref[best_pred]);





                    if (s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y) {

                        fixed[mb_xy] = MV_CHANGED;

                        changed++;

                    } else

                        fixed[mb_xy] = MV_UNCHANGED;

                }

            }



            

        }



        if (none_left)

            goto end;



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

            int mb_xy = s->mb_index2xy[i];

            if (fixed[mb_xy])

                fixed[mb_xy] = MV_FROZEN;

        }

        

    }

end:

    av_free(fixed);

}

static void FUNC_0(MpegEncContext *VAR_0)

{

    uint8_t *fixed = av_malloc(VAR_0->VAR_1 * VAR_0->VAR_3);

#define MV_FROZEN    3

#define MV_CHANGED   2

#define MV_UNCHANGED 1

    const int VAR_1 = VAR_0->VAR_1;

    const int VAR_2  = VAR_0->VAR_2;

    const int VAR_3 = VAR_0->VAR_3;

    int VAR_4, VAR_5, VAR_6;

    int VAR_14, VAR_14, VAR_9, VAR_10;



    set_mv_strides(VAR_0, &VAR_9, &VAR_10);



    VAR_6 = 0;

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

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

        int f = 0;

        int error = VAR_0->error_status_table[mb_xy];



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

            f = MV_FROZEN; 

        if (!(error & ER_MV_ERROR))

            f = MV_FROZEN; 



        fixed[mb_xy] = f;

        if (f == MV_FROZEN)

            VAR_6++;

        else if(VAR_0->last_picture.f.data[0] && VAR_0->last_picture.f.motion_val[0]){

            const int VAR_14= mb_xy / VAR_0->VAR_1;

            const int VAR_14= mb_xy % VAR_0->VAR_1;

            const int mot_index= (VAR_14 + VAR_14*VAR_10) * VAR_9;

            VAR_0->current_picture.f.motion_val[0][mot_index][0]= VAR_0->last_picture.f.motion_val[0][mot_index][0];

            VAR_0->current_picture.f.motion_val[0][mot_index][1]= VAR_0->last_picture.f.motion_val[0][mot_index][1];

            VAR_0->current_picture.f.ref_index[0][4*mb_xy]      = VAR_0->last_picture.f.ref_index[0][4*mb_xy];

        }

    }



    if ((!(VAR_0->avctx->error_concealment&FF_EC_GUESS_MVS)) ||

        VAR_6 <= VAR_2 / 2) {

        for (VAR_14 = 0; VAR_14 < VAR_0->VAR_3; VAR_14++) {

            VAR_0->VAR_14 = 0;

            VAR_0->VAR_14 = VAR_14;

            ff_init_block_index(VAR_0);

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

                const int mb_xy = VAR_14 + VAR_14 * VAR_0->VAR_1;



                ff_update_block_index(VAR_0);



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

                    continue;

                if (!(VAR_0->error_status_table[mb_xy] & ER_MV_ERROR))

                    continue;



                VAR_0->mv_dir     = VAR_0->last_picture.f.data[0] ? MV_DIR_FORWARD

                                                          : MV_DIR_BACKWARD;

                VAR_0->mb_intra   = 0;

                VAR_0->mv_type    = MV_TYPE_16X16;

                VAR_0->mb_skipped = 0;



                VAR_0->dsp.clear_blocks(VAR_0->block[0]);



                VAR_0->VAR_14        = VAR_14;

                VAR_0->VAR_14        = VAR_14;

                VAR_0->mv[0][0][0] = 0;

                VAR_0->mv[0][0][1] = 0;

                decode_mb(VAR_0, 0);

            }

        }

        goto end;

    }



    for (VAR_5 = 0; ; VAR_5++) {

        int VAR_11, VAR_12, VAR_13;



        VAR_13 = 1;

        VAR_11   = 1;

        for (VAR_12 = 0; (VAR_11 || VAR_12 < 2) && VAR_12 < 10; VAR_12++) {

            int VAR_14, VAR_14;

            int VAR_14 = 0;



            VAR_11 = 0;

            for (VAR_14 = 0; VAR_14 < VAR_0->VAR_3; VAR_14++) {

                VAR_0->VAR_14 = 0;

                VAR_0->VAR_14 = VAR_14;

                ff_init_block_index(VAR_0);

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

                    const int mb_xy        = VAR_14 + VAR_14 * VAR_0->VAR_1;

                    int mv_predictor[8][2] = { { 0 } };

                    int ref[8]             = { 0 };

                    int pred_count         = 0;

                    int j;

                    int best_score         = 256 * 256 * 256 * 64;

                    int best_pred          = 0;

                    const int mot_index    = (VAR_14 + VAR_14 * VAR_10) * VAR_9;

                    int prev_x, prev_y, prev_ref;



                    ff_update_block_index(VAR_0);



                    if ((VAR_14 ^ VAR_14 ^ VAR_12) & 1)

                        continue;



                    if (fixed[mb_xy] == MV_FROZEN)

                        continue;

                    assert(!IS_INTRA(VAR_0->current_picture.f.mb_type[mb_xy]));

                    assert(VAR_0->last_picture_ptr && VAR_0->last_picture_ptr->f.data[0]);



                    j = 0;

                    if (VAR_14 > 0             && fixed[mb_xy - 1]         == MV_FROZEN)

                        j = 1;

                    if (VAR_14 + 1 < VAR_2  && fixed[mb_xy + 1]         == MV_FROZEN)

                        j = 1;

                    if (VAR_14 > 0             && fixed[mb_xy - VAR_1] == MV_FROZEN)

                        j = 1;

                    if (VAR_14 + 1 < VAR_3 && fixed[mb_xy + VAR_1] == MV_FROZEN)

                        j = 1;

                    if (j == 0)

                        continue;



                    j = 0;

                    if (VAR_14 > 0             && fixed[mb_xy - 1        ] == MV_CHANGED)

                        j = 1;

                    if (VAR_14 + 1 < VAR_2  && fixed[mb_xy + 1        ] == MV_CHANGED)

                        j = 1;

                    if (VAR_14 > 0             && fixed[mb_xy - VAR_1] == MV_CHANGED)

                        j = 1;

                    if (VAR_14 + 1 < VAR_3 && fixed[mb_xy + VAR_1] == MV_CHANGED)

                        j = 1;

                    if (j == 0 && VAR_12 > 1)

                        continue;



                    VAR_13 = 0;



                    if (VAR_14 > 0 && fixed[mb_xy - 1]) {

                        mv_predictor[pred_count][0] =

                            VAR_0->current_picture.f.motion_val[0][mot_index - VAR_9][0];

                        mv_predictor[pred_count][1] =

                            VAR_0->current_picture.f.motion_val[0][mot_index - VAR_9][1];

                        ref[pred_count] =

                            VAR_0->current_picture.f.ref_index[0][4 * (mb_xy - 1)];

                        pred_count++;

                    }

                    if (VAR_14 + 1 < VAR_2 && fixed[mb_xy + 1]) {

                        mv_predictor[pred_count][0] =

                            VAR_0->current_picture.f.motion_val[0][mot_index + VAR_9][0];

                        mv_predictor[pred_count][1] =

                            VAR_0->current_picture.f.motion_val[0][mot_index + VAR_9][1];

                        ref[pred_count] =

                            VAR_0->current_picture.f.ref_index[0][4 * (mb_xy + 1)];

                        pred_count++;

                    }

                    if (VAR_14 > 0 && fixed[mb_xy - VAR_1]) {

                        mv_predictor[pred_count][0] =

                            VAR_0->current_picture.f.motion_val[0][mot_index - VAR_10 * VAR_9][0];

                        mv_predictor[pred_count][1] =

                            VAR_0->current_picture.f.motion_val[0][mot_index - VAR_10 * VAR_9][1];

                        ref[pred_count] =

                            VAR_0->current_picture.f.ref_index[0][4 * (mb_xy - VAR_0->VAR_1)];

                        pred_count++;

                    }

                    if (VAR_14 + 1<VAR_3 && fixed[mb_xy + VAR_1]) {

                        mv_predictor[pred_count][0] =

                            VAR_0->current_picture.f.motion_val[0][mot_index + VAR_10 * VAR_9][0];

                        mv_predictor[pred_count][1] =

                            VAR_0->current_picture.f.motion_val[0][mot_index + VAR_10 * VAR_9][1];

                        ref[pred_count] =

                            VAR_0->current_picture.f.ref_index[0][4 * (mb_xy + VAR_0->VAR_1)];

                        pred_count++;

                    }

                    if (pred_count == 0)

                        continue;



                    if (pred_count > 1) {

                        int sum_x = 0, sum_y = 0, sum_r = 0;

                        int max_x, max_y, min_x, min_y, max_r, min_r;



                        for (j = 0; j < pred_count; j++) {

                            sum_x += mv_predictor[j][0];

                            sum_y += mv_predictor[j][1];

                            sum_r += ref[j];

                            if (j && ref[j] != ref[j - 1])

                                goto skip_mean_and_median;

                        }



                        

                        mv_predictor[pred_count][0] = sum_x / j;

                        mv_predictor[pred_count][1] = sum_y / j;

                                 ref[pred_count]    = sum_r / j;



                        

                        if (pred_count >= 3) {

                            min_y = min_x = min_r =  99999;

                            max_y = max_x = max_r = -99999;

                        } else {

                            min_x = min_y = max_x = max_y = min_r = max_r = 0;

                        }

                        for (j = 0; j < pred_count; j++) {

                            max_x = FFMAX(max_x, mv_predictor[j][0]);

                            max_y = FFMAX(max_y, mv_predictor[j][1]);

                            max_r = FFMAX(max_r, ref[j]);

                            min_x = FFMIN(min_x, mv_predictor[j][0]);

                            min_y = FFMIN(min_y, mv_predictor[j][1]);

                            min_r = FFMIN(min_r, ref[j]);

                        }

                        mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;

                        mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;

                                 ref[pred_count + 1]    = sum_r - max_r - min_r;



                        if (pred_count == 4) {

                            mv_predictor[pred_count + 1][0] /= 2;

                            mv_predictor[pred_count + 1][1] /= 2;

                                     ref[pred_count + 1]    /= 2;

                        }

                        pred_count += 2;

                    }



skip_mean_and_median:

                    

                    pred_count++;



                    if (!fixed[mb_xy] && 0) {

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

                            

                        } else {

                            ff_thread_await_progress(&VAR_0->last_picture_ptr->f,

                                                     VAR_14, 0);

                        }

                        if (!VAR_0->last_picture.f.motion_val[0] ||

                            !VAR_0->last_picture.f.ref_index[0])

                            goto skip_last_mv;

                        prev_x   = VAR_0->last_picture.f.motion_val[0][mot_index][0];

                        prev_y   = VAR_0->last_picture.f.motion_val[0][mot_index][1];

                        prev_ref = VAR_0->last_picture.f.ref_index[0][4 * mb_xy];

                    } else {

                        prev_x   = VAR_0->current_picture.f.motion_val[0][mot_index][0];

                        prev_y   = VAR_0->current_picture.f.motion_val[0][mot_index][1];

                        prev_ref = VAR_0->current_picture.f.ref_index[0][4 * mb_xy];

                    }



                    

                    mv_predictor[pred_count][0] = prev_x;

                    mv_predictor[pred_count][1] = prev_y;

                             ref[pred_count]    = prev_ref;

                    pred_count++;



skip_last_mv:

                    VAR_0->mv_dir     = MV_DIR_FORWARD;

                    VAR_0->mb_intra   = 0;

                    VAR_0->mv_type    = MV_TYPE_16X16;

                    VAR_0->mb_skipped = 0;



                    VAR_0->dsp.clear_blocks(VAR_0->block[0]);



                    VAR_0->VAR_14 = VAR_14;

                    VAR_0->VAR_14 = VAR_14;



                    for (j = 0; j < pred_count; j++) {

                        int score = 0;

                        uint8_t *src = VAR_0->current_picture.f.data[0] +

                                       VAR_14 * 16 + VAR_14 * 16 * VAR_0->linesize;



                        VAR_0->current_picture.f.motion_val[0][mot_index][0] =

                            VAR_0->mv[0][0][0] = mv_predictor[j][0];

                        VAR_0->current_picture.f.motion_val[0][mot_index][1] =

                            VAR_0->mv[0][0][1] = mv_predictor[j][1];



                        

                        if (ref[j] < 0)

                            continue;



                        decode_mb(VAR_0, ref[j]);



                        if (VAR_14 > 0 && fixed[mb_xy - 1]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k * VAR_0->linesize - 1] -

                                               src[k * VAR_0->linesize]);

                        }

                        if (VAR_14 + 1 < VAR_2 && fixed[mb_xy + 1]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k * VAR_0->linesize + 15] -

                                               src[k * VAR_0->linesize + 16]);

                        }

                        if (VAR_14 > 0 && fixed[mb_xy - VAR_1]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k - VAR_0->linesize] - src[k]);

                        }

                        if (VAR_14 + 1 < VAR_3 && fixed[mb_xy + VAR_1]) {

                            int k;

                            for (k = 0; k < 16; k++)

                                score += FFABS(src[k + VAR_0->linesize * 15] -

                                               src[k + VAR_0->linesize * 16]);

                        }



                        if (score <= best_score) { 

                            best_score = score;

                            best_pred  = j;

                        }

                    }

                    VAR_14 += best_score;

                    VAR_0->mv[0][0][0] = mv_predictor[best_pred][0];

                    VAR_0->mv[0][0][1] = mv_predictor[best_pred][1];



                    for (VAR_4 = 0; VAR_4 < VAR_9; VAR_4++)

                        for (j = 0; j < VAR_9; j++) {

                            VAR_0->current_picture.f.motion_val[0][mot_index + VAR_4 + j * VAR_10][0] = VAR_0->mv[0][0][0];

                            VAR_0->current_picture.f.motion_val[0][mot_index + VAR_4 + j * VAR_10][1] = VAR_0->mv[0][0][1];

                        }



                    decode_mb(VAR_0, ref[best_pred]);





                    if (VAR_0->mv[0][0][0] != prev_x || VAR_0->mv[0][0][1] != prev_y) {

                        fixed[mb_xy] = MV_CHANGED;

                        VAR_11++;

                    } else

                        fixed[mb_xy] = MV_UNCHANGED;

                }

            }



            

        }



        if (VAR_13)

            goto end;



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

            int mb_xy = VAR_0->mb_index2xy[VAR_4];

            if (fixed[mb_xy])

                fixed[mb_xy] = MV_FROZEN;

        }

        

    }

end:

    av_free(fixed);

}

static void FUNC_0(MpegEncContext *VAR_0)
{ uint8_t *fixed = av_malloc(VAR_0->VAR_1 * VAR_0->VAR_3); #define MV_FROZEN    3
#define MV_CHANGED   2
#define MV_UNCHANGED 1
const int VAR_1 = VAR_0->VAR_1; const int VAR_2  = VAR_0->VAR_2; const int VAR_3 = VAR_0->VAR_3; int VAR_4, VAR_5, VAR_6; int VAR_14, VAR_14, VAR_9, VAR_10; set_mv_strides(VAR_0, &VAR_9, &VAR_10); VAR_6 = 0; for (VAR_4 = 0; VAR_4 < VAR_0->mb_num; VAR_4++) { const int mb_xy = VAR_0->mb_index2xy[VAR_4]; int f = 0; int error = VAR_0->error_status_table[mb_xy]; if (IS_INTRA(VAR_0->current_picture.f.mb_type[mb_xy]))
f = MV_FROZEN; if (!(error & ER_MV_ERROR))
f = MV_FROZEN; fixed[mb_xy] = f; if (f == MV_FROZEN)
VAR_6++; else if(VAR_0->last_picture.f.data[0] && VAR_0->last_picture.f.motion_val[0]){ const int VAR_14= mb_xy / VAR_0->VAR_1; const int VAR_14= mb_xy % VAR_0->VAR_1; const int mot_index= (VAR_14 + VAR_14*VAR_10) * VAR_9; VAR_0->current_picture.f.motion_val[0][mot_index][0]= VAR_0->last_picture.f.motion_val[0][mot_index][0]; VAR_0->current_picture.f.motion_val[0][mot_index][1]= VAR_0->last_picture.f.motion_val[0][mot_index][1]; VAR_0->current_picture.f.ref_index[0][4*mb_xy]      = VAR_0->last_picture.f.ref_index[0][4*mb_xy]; } } if ((!(VAR_0->avctx->error_concealment&FF_EC_GUESS_MVS)) ||
VAR_6 <= VAR_2 / 2) { for (VAR_14 = 0; VAR_14 < VAR_0->VAR_3; VAR_14++) { VAR_0->VAR_14 = 0; VAR_0->VAR_14 = VAR_14; ff_init_block_index(VAR_0); for (VAR_14 = 0; VAR_14 < VAR_0->VAR_2; VAR_14++) { const int mb_xy = VAR_14 + VAR_14 * VAR_0->VAR_1; ff_update_block_index(VAR_0); if (IS_INTRA(VAR_0->current_picture.f.mb_type[mb_xy]))
continue; if (!(VAR_0->error_status_table[mb_xy] & ER_MV_ERROR))
continue; VAR_0->mv_dir     = VAR_0->last_picture.f.data[0] ? MV_DIR_FORWARD
: MV_DIR_BACKWARD; VAR_0->mb_intra   = 0; VAR_0->mv_type    = MV_TYPE_16X16; VAR_0->mb_skipped = 0; VAR_0->dsp.clear_blocks(VAR_0->block[0]); VAR_0->VAR_14        = VAR_14; VAR_0->VAR_14        = VAR_14; VAR_0->mv[0][0][0] = 0; VAR_0->mv[0][0][1] = 0; decode_mb(VAR_0, 0); } } goto end; } for (VAR_5 = 0; ; VAR_5++) { int VAR_11, VAR_12, VAR_13; VAR_13 = 1; VAR_11   = 1; for (VAR_12 = 0; (VAR_11 || VAR_12 < 2) && VAR_12 < 10; VAR_12++) { int VAR_14, VAR_14; int VAR_14 = 0; VAR_11 = 0; for (VAR_14 = 0; VAR_14 < VAR_0->VAR_3; VAR_14++) { VAR_0->VAR_14 = 0; VAR_0->VAR_14 = VAR_14; ff_init_block_index(VAR_0); for (VAR_14 = 0; VAR_14 < VAR_0->VAR_2; VAR_14++) { const int mb_xy        = VAR_14 + VAR_14 * VAR_0->VAR_1; int mv_predictor[8][2] = { { 0 } }; int ref[8]             = { 0 }; int pred_count         = 0; int j; int best_score         = 256 * 256 * 256 * 64; int best_pred          = 0; const int mot_index    = (VAR_14 + VAR_14 * VAR_10) * VAR_9; int prev_x, prev_y, prev_ref; ff_update_block_index(VAR_0); if ((VAR_14 ^ VAR_14 ^ VAR_12) & 1)
continue; if (fixed[mb_xy] == MV_FROZEN)
continue; assert(!IS_INTRA(VAR_0->current_picture.f.mb_type[mb_xy])); assert(VAR_0->last_picture_ptr && VAR_0->last_picture_ptr->f.data[0]); j = 0; if (VAR_14 > 0             && fixed[mb_xy - 1]         == MV_FROZEN)
j = 1; if (VAR_14 + 1 < VAR_2  && fixed[mb_xy + 1]         == MV_FROZEN)
j = 1; if (VAR_14 > 0             && fixed[mb_xy - VAR_1] == MV_FROZEN)
j = 1; if (VAR_14 + 1 < VAR_3 && fixed[mb_xy + VAR_1] == MV_FROZEN)
j = 1; if (j == 0)
continue; j = 0; if (VAR_14 > 0             && fixed[mb_xy - 1        ] == MV_CHANGED)
j = 1; if (VAR_14 + 1 < VAR_2  && fixed[mb_xy + 1        ] == MV_CHANGED)
j = 1; if (VAR_14 > 0             && fixed[mb_xy - VAR_1] == MV_CHANGED)
j = 1; if (VAR_14 + 1 < VAR_3 && fixed[mb_xy + VAR_1] == MV_CHANGED)
j = 1; if (j == 0 && VAR_12 > 1)
continue; VAR_13 = 0; if (VAR_14 > 0 && fixed[mb_xy - 1]) { mv_predictor[pred_count][0] =
VAR_0->current_picture.f.motion_val[0][mot_index - VAR_9][0]; mv_predictor[pred_count][1] =
VAR_0->current_picture.f.motion_val[0][mot_index - VAR_9][1]; ref[pred_count] =
VAR_0->current_picture.f.ref_index[0][4 * (mb_xy - 1)]; pred_count++; } if (VAR_14 + 1 < VAR_2 && fixed[mb_xy + 1]) { mv_predictor[pred_count][0] =
VAR_0->current_picture.f.motion_val[0][mot_index + VAR_9][0]; mv_predictor[pred_count][1] =
VAR_0->current_picture.f.motion_val[0][mot_index + VAR_9][1]; ref[pred_count] =
VAR_0->current_picture.f.ref_index[0][4 * (mb_xy + 1)]; pred_count++; } if (VAR_14 > 0 && fixed[mb_xy - VAR_1]) { mv_predictor[pred_count][0] =
VAR_0->current_picture.f.motion_val[0][mot_index - VAR_10 * VAR_9][0]; mv_predictor[pred_count][1] =
VAR_0->current_picture.f.motion_val[0][mot_index - VAR_10 * VAR_9][1]; ref[pred_count] =
VAR_0->current_picture.f.ref_index[0][4 * (mb_xy - VAR_0->VAR_1)]; pred_count++; } if (VAR_14 + 1<VAR_3 && fixed[mb_xy + VAR_1]) { mv_predictor[pred_count][0] =
VAR_0->current_picture.f.motion_val[0][mot_index + VAR_10 * VAR_9][0]; mv_predictor[pred_count][1] =
VAR_0->current_picture.f.motion_val[0][mot_index + VAR_10 * VAR_9][1]; ref[pred_count] =
VAR_0->current_picture.f.ref_index[0][4 * (mb_xy + VAR_0->VAR_1)]; pred_count++; } if (pred_count == 0)
continue; if (pred_count > 1) { int sum_x = 0, sum_y = 0, sum_r = 0; int max_x, max_y, min_x, min_y, max_r, min_r; for (j = 0; j < pred_count; j++) { sum_x += mv_predictor[j][0]; sum_y += mv_predictor[j][1]; sum_r += ref[j]; if (j && ref[j] != ref[j - 1])
goto skip_mean_and_median; } mv_predictor[pred_count][0] = sum_x / j; mv_predictor[pred_count][1] = sum_y / j; ref[pred_count]    = sum_r / j; if (pred_count >= 3) { min_y = min_x = min_r =  99999; max_y = max_x = max_r = -99999; } else { min_x = min_y = max_x = max_y = min_r = max_r = 0; } for (j = 0; j < pred_count; j++) { max_x = FFMAX(max_x, mv_predictor[j][0]); max_y = FFMAX(max_y, mv_predictor[j][1]); max_r = FFMAX(max_r, ref[j]); min_x = FFMIN(min_x, mv_predictor[j][0]); min_y = FFMIN(min_y, mv_predictor[j][1]); min_r = FFMIN(min_r, ref[j]); } mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x; mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y; ref[pred_count + 1]    = sum_r - max_r - min_r; if (pred_count == 4) { mv_predictor[pred_count + 1][0] /= 2; mv_predictor[pred_count + 1][1] /= 2; ref[pred_count + 1]    /= 2; } pred_count += 2; } skip_mean_and_median:
pred_count++; if (!fixed[mb_xy] && 0) { if (VAR_0->avctx->codec_id == CODEC_ID_H264) { } else { ff_thread_await_progress(&VAR_0->last_picture_ptr->f,
VAR_14, 0); } if (!VAR_0->last_picture.f.motion_val[0] ||
!VAR_0->last_picture.f.ref_index[0])
goto skip_last_mv; prev_x   = VAR_0->last_picture.f.motion_val[0][mot_index][0]; prev_y   = VAR_0->last_picture.f.motion_val[0][mot_index][1]; prev_ref = VAR_0->last_picture.f.ref_index[0][4 * mb_xy]; } else { prev_x   = VAR_0->current_picture.f.motion_val[0][mot_index][0]; prev_y   = VAR_0->current_picture.f.motion_val[0][mot_index][1]; prev_ref = VAR_0->current_picture.f.ref_index[0][4 * mb_xy]; } mv_predictor[pred_count][0] = prev_x; mv_predictor[pred_count][1] = prev_y; ref[pred_count]    = prev_ref; pred_count++; skip_last_mv:
VAR_0->mv_dir     = MV_DIR_FORWARD; VAR_0->mb_intra   = 0; VAR_0->mv_type    = MV_TYPE_16X16; VAR_0->mb_skipped = 0; VAR_0->dsp.clear_blocks(VAR_0->block[0]); VAR_0->VAR_14 = VAR_14; VAR_0->VAR_14 = VAR_14; for (j = 0; j < pred_count; j++) { int score = 0; uint8_t *src = VAR_0->current_picture.f.data[0] +
VAR_14 * 16 + VAR_14 * 16 * VAR_0->linesize; VAR_0->current_picture.f.motion_val[0][mot_index][0] =
VAR_0->mv[0][0][0] = mv_predictor[j][0]; VAR_0->current_picture.f.motion_val[0][mot_index][1] =
VAR_0->mv[0][0][1] = mv_predictor[j][1]; if (ref[j] < 0)
continue; decode_mb(VAR_0, ref[j]); if (VAR_14 > 0 && fixed[mb_xy - 1]) { int k; for (k = 0; k < 16; k++) score += FFABS(src[k * VAR_0->linesize - 1] -
src[k * VAR_0->linesize]); } if (VAR_14 + 1 < VAR_2 && fixed[mb_xy + 1]) { int k; for (k = 0; k < 16; k++) score += FFABS(src[k * VAR_0->linesize + 15] -
src[k * VAR_0->linesize + 16]); } if (VAR_14 > 0 && fixed[mb_xy - VAR_1]) { int k; for (k = 0; k < 16; k++) score += FFABS(src[k - VAR_0->linesize] - src[k]); } if (VAR_14 + 1 < VAR_3 && fixed[mb_xy + VAR_1]) { int k; for (k = 0; k < 16; k++) score += FFABS(src[k + VAR_0->linesize * 15] -
src[k + VAR_0->linesize * 16]); } if (score <= best_score) { best_score = score; best_pred  = j; } } VAR_14 += best_score; VAR_0->mv[0][0][0] = mv_predictor[best_pred][0]; VAR_0->mv[0][0][1] = mv_predictor[best_pred][1]; for (VAR_4 = 0; VAR_4 < VAR_9; VAR_4++) for (j = 0; j < VAR_9; j++) { VAR_0->current_picture.f.motion_val[0][mot_index + VAR_4 + j * VAR_10][0] = VAR_0->mv[0][0][0]; VAR_0->current_picture.f.motion_val[0][mot_index + VAR_4 + j * VAR_10][1] = VAR_0->mv[0][0][1]; } decode_mb(VAR_0, ref[best_pred]); if (VAR_0->mv[0][0][0] != prev_x || VAR_0->mv[0][0][1] != prev_y) { fixed[mb_xy] = MV_CHANGED; VAR_11++; } else fixed[mb_xy] = MV_UNCHANGED; } } } if (VAR_13)
goto end; for (VAR_4 = 0; VAR_4 < VAR_0->mb_num; VAR_4++) { int mb_xy = VAR_0->mb_index2xy[VAR_4]; if (fixed[mb_xy])
fixed[mb_xy] = MV_FROZEN; } } end:
av_free(fixed); }