static int svq1_encode_plane(SVQ1Context *s, int plane,

                             unsigned char *src_plane,

                             unsigned char *ref_plane,

                             unsigned char *decoded_plane,

                             int width, int height, int src_stride, int stride)

{

    const AVFrame *f = s->avctx->coded_frame;

    int x, y;

    int i;

    int block_width, block_height;

    int level;

    int threshold[6];

    uint8_t *src     = s->scratchbuf + stride * 16;

    const int lambda = (f->quality * f->quality) >>

                       (2 * FF_LAMBDA_SHIFT);



    /* figure out the acceptable level thresholds in advance */

    threshold[5] = QUALITY_THRESHOLD;

    for (level = 4; level >= 0; level--)

        threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;



    block_width  = (width  + 15) / 16;

    block_height = (height + 15) / 16;



    if (f->pict_type == AV_PICTURE_TYPE_P) {

        s->m.avctx                         = s->avctx;

        s->m.current_picture_ptr           = &s->m.current_picture;

        s->m.last_picture_ptr              = &s->m.last_picture;

        s->m.last_picture.f.data[0]        = ref_plane;

        s->m.linesize                      =

        s->m.last_picture.f.linesize[0]    =

        s->m.new_picture.f.linesize[0]     =

        s->m.current_picture.f.linesize[0] = stride;

        s->m.width                         = width;

        s->m.height                        = height;

        s->m.mb_width                      = block_width;

        s->m.mb_height                     = block_height;

        s->m.mb_stride                     = s->m.mb_width + 1;

        s->m.b8_stride                     = 2 * s->m.mb_width + 1;

        s->m.f_code                        = 1;

        s->m.pict_type                     = f->pict_type;

        s->m.me_method                     = s->avctx->me_method;

        s->m.me.scene_change_score         = 0;

        s->m.flags                         = s->avctx->flags;

        // s->m.out_format                    = FMT_H263;

        // s->m.unrestricted_mv               = 1;

        s->m.lambda                        = f->quality;

        s->m.qscale                        = s->m.lambda * 139 +

                                             FF_LAMBDA_SCALE * 64 >>

                                             FF_LAMBDA_SHIFT + 7;

        s->m.lambda2                       = s->m.lambda * s->m.lambda +

                                             FF_LAMBDA_SCALE / 2 >>

                                             FF_LAMBDA_SHIFT;



        if (!s->motion_val8[plane]) {

            s->motion_val8[plane]  = av_mallocz((s->m.b8_stride *

                                                 block_height * 2 + 2) *

                                                2 * sizeof(int16_t));

            s->motion_val16[plane] = av_mallocz((s->m.mb_stride *

                                                 (block_height + 2) + 1) *

                                                2 * sizeof(int16_t));

        }



        s->m.mb_type = s->mb_type;



        // dummies, to avoid segfaults

        s->m.current_picture.mb_mean   = (uint8_t *)s->dummy;

        s->m.current_picture.mb_var    = (uint16_t *)s->dummy;

        s->m.current_picture.mc_mb_var = (uint16_t *)s->dummy;

        s->m.current_picture.mb_type = s->dummy;



        s->m.current_picture.motion_val[0]   = s->motion_val8[plane] + 2;

        s->m.p_mv_table                      = s->motion_val16[plane] +

                                               s->m.mb_stride + 1;

        s->m.dsp                             = s->dsp; // move

        ff_init_me(&s->m);



        s->m.me.dia_size      = s->avctx->dia_size;

        s->m.first_slice_line = 1;

        for (y = 0; y < block_height; y++) {

            s->m.new_picture.f.data[0] = src - y * 16 * stride; // ugly

            s->m.mb_y                  = y;



            for (i = 0; i < 16 && i + 16 * y < height; i++) {

                memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],

                       width);

                for (x = width; x < 16 * block_width; x++)

                    src[i * stride + x] = src[i * stride + x - 1];

            }

            for (; i < 16 && i + 16 * y < 16 * block_height; i++)

                memcpy(&src[i * stride], &src[(i - 1) * stride],

                       16 * block_width);



            for (x = 0; x < block_width; x++) {

                s->m.mb_x = x;

                ff_init_block_index(&s->m);

                ff_update_block_index(&s->m);



                ff_estimate_p_frame_motion(&s->m, x, y);

            }

            s->m.first_slice_line = 0;

        }



        ff_fix_long_p_mvs(&s->m);

        ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code,

                        CANDIDATE_MB_TYPE_INTER, 0);

    }



    s->m.first_slice_line = 1;

    for (y = 0; y < block_height; y++) {

        for (i = 0; i < 16 && i + 16 * y < height; i++) {

            memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],

                   width);

            for (x = width; x < 16 * block_width; x++)

                src[i * stride + x] = src[i * stride + x - 1];

        }

        for (; i < 16 && i + 16 * y < 16 * block_height; i++)

            memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);



        s->m.mb_y = y;

        for (x = 0; x < block_width; x++) {

            uint8_t reorder_buffer[3][6][7 * 32];

            int count[3][6];

            int offset       = y * 16 * stride + x * 16;

            uint8_t *decoded = decoded_plane + offset;

            uint8_t *ref     = ref_plane + offset;

            int score[4]     = { 0, 0, 0, 0 }, best;

            uint8_t *temp    = s->scratchbuf;



            if (s->pb.buf_end - s->pb.buf -

                (put_bits_count(&s->pb) >> 3) < 3000) { // FIXME: check size

                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

                return -1;

            }



            s->m.mb_x = x;

            ff_init_block_index(&s->m);

            ff_update_block_index(&s->m);



            if (f->pict_type == AV_PICTURE_TYPE_I ||

                (s->m.mb_type[x + y * s->m.mb_stride] &

                 CANDIDATE_MB_TYPE_INTRA)) {

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

                    init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],

                                  7 * 32);

                if (f->pict_type == AV_PICTURE_TYPE_P) {

                    const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA];

                    put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);

                    score[0] = vlc[1] * lambda;

                }

                score[0] += encode_block(s, src + 16 * x, NULL, temp, stride,

                                         5, 64, lambda, 1);

                for (i = 0; i < 6; i++) {

                    count[0][i] = put_bits_count(&s->reorder_pb[i]);

                    flush_put_bits(&s->reorder_pb[i]);

                }

            } else

                score[0] = INT_MAX;



            best = 0;



            if (f->pict_type == AV_PICTURE_TYPE_P) {

                const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER];

                int mx, my, pred_x, pred_y, dxy;

                int16_t *motion_ptr;



                motion_ptr = ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);

                if (s->m.mb_type[x + y * s->m.mb_stride] &

                    CANDIDATE_MB_TYPE_INTER) {

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

                        init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],

                                      7 * 32);



                    put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);



                    s->m.pb = s->reorder_pb[5];

                    mx      = motion_ptr[0];

                    my      = motion_ptr[1];

                    assert(mx     >= -32 && mx     <= 31);

                    assert(my     >= -32 && my     <= 31);

                    assert(pred_x >= -32 && pred_x <= 31);

                    assert(pred_y >= -32 && pred_y <= 31);

                    ff_h263_encode_motion(&s->m, mx - pred_x, 1);

                    ff_h263_encode_motion(&s->m, my - pred_y, 1);

                    s->reorder_pb[5] = s->m.pb;

                    score[1]        += lambda * put_bits_count(&s->reorder_pb[5]);



                    dxy = (mx & 1) + 2 * (my & 1);



                    s->hdsp.put_pixels_tab[0][dxy](temp + 16,

                                                   ref + (mx >> 1) +

                                                   stride * (my >> 1),

                                                   stride, 16);



                    score[1] += encode_block(s, src + 16 * x, temp + 16,

                                             decoded, stride, 5, 64, lambda, 0);

                    best      = score[1] <= score[0];



                    vlc       = ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];

                    score[2]  = s->dsp.sse[0](NULL, src + 16 * x, ref,

                                              stride, 16);

                    score[2] += vlc[1] * lambda;

                    if (score[2] < score[best] && mx == 0 && my == 0) {

                        best = 2;

                        s->hdsp.put_pixels_tab[0][0](decoded, ref, stride, 16);

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

                            count[2][i] = 0;

                        put_bits(&s->pb, vlc[1], vlc[0]);

                    }

                }



                if (best == 1) {

                    for (i = 0; i < 6; i++) {

                        count[1][i] = put_bits_count(&s->reorder_pb[i]);

                        flush_put_bits(&s->reorder_pb[i]);

                    }

                } else {

                    motion_ptr[0]                      =

                    motion_ptr[1]                      =

                    motion_ptr[2]                      =

                    motion_ptr[3]                      =

                    motion_ptr[0 + 2 * s->m.b8_stride] =

                    motion_ptr[1 + 2 * s->m.b8_stride] =

                    motion_ptr[2 + 2 * s->m.b8_stride] =

                    motion_ptr[3 + 2 * s->m.b8_stride] = 0;

                }

            }



            s->rd_total += score[best];



            for (i = 5; i >= 0; i--)

                avpriv_copy_bits(&s->pb, reorder_buffer[best][i],

                                 count[best][i]);

            if (best == 0)

                s->hdsp.put_pixels_tab[0][0](decoded, temp, stride, 16);

        }

        s->m.first_slice_line = 0;

    }

    return 0;

}

static int svq1_encode_plane(SVQ1Context *s, int plane,

                             unsigned char *src_plane,

                             unsigned char *ref_plane,

                             unsigned char *decoded_plane,

                             int width, int height, int src_stride, int stride)

{

    const AVFrame *f = s->avctx->coded_frame;

    int x, y;

    int i;

    int block_width, block_height;

    int level;

    int threshold[6];

    uint8_t *src     = s->scratchbuf + stride * 16;

    const int lambda = (f->quality * f->quality) >>

                       (2 * FF_LAMBDA_SHIFT);



    

    threshold[5] = QUALITY_THRESHOLD;

    for (level = 4; level >= 0; level--)

        threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;



    block_width  = (width  + 15) / 16;

    block_height = (height + 15) / 16;



    if (f->pict_type == AV_PICTURE_TYPE_P) {

        s->m.avctx                         = s->avctx;

        s->m.current_picture_ptr           = &s->m.current_picture;

        s->m.last_picture_ptr              = &s->m.last_picture;

        s->m.last_picture.f.data[0]        = ref_plane;

        s->m.linesize                      =

        s->m.last_picture.f.linesize[0]    =

        s->m.new_picture.f.linesize[0]     =

        s->m.current_picture.f.linesize[0] = stride;

        s->m.width                         = width;

        s->m.height                        = height;

        s->m.mb_width                      = block_width;

        s->m.mb_height                     = block_height;

        s->m.mb_stride                     = s->m.mb_width + 1;

        s->m.b8_stride                     = 2 * s->m.mb_width + 1;

        s->m.f_code                        = 1;

        s->m.pict_type                     = f->pict_type;

        s->m.me_method                     = s->avctx->me_method;

        s->m.me.scene_change_score         = 0;

        s->m.flags                         = s->avctx->flags;

        

        

        s->m.lambda                        = f->quality;

        s->m.qscale                        = s->m.lambda * 139 +

                                             FF_LAMBDA_SCALE * 64 >>

                                             FF_LAMBDA_SHIFT + 7;

        s->m.lambda2                       = s->m.lambda * s->m.lambda +

                                             FF_LAMBDA_SCALE / 2 >>

                                             FF_LAMBDA_SHIFT;



        if (!s->motion_val8[plane]) {

            s->motion_val8[plane]  = av_mallocz((s->m.b8_stride *

                                                 block_height * 2 + 2) *

                                                2 * sizeof(int16_t));

            s->motion_val16[plane] = av_mallocz((s->m.mb_stride *

                                                 (block_height + 2) + 1) *

                                                2 * sizeof(int16_t));

        }



        s->m.mb_type = s->mb_type;



        

        s->m.current_picture.mb_mean   = (uint8_t *)s->dummy;

        s->m.current_picture.mb_var    = (uint16_t *)s->dummy;

        s->m.current_picture.mc_mb_var = (uint16_t *)s->dummy;

        s->m.current_picture.mb_type = s->dummy;



        s->m.current_picture.motion_val[0]   = s->motion_val8[plane] + 2;

        s->m.p_mv_table                      = s->motion_val16[plane] +

                                               s->m.mb_stride + 1;

        s->m.dsp                             = s->dsp; 

        ff_init_me(&s->m);



        s->m.me.dia_size      = s->avctx->dia_size;

        s->m.first_slice_line = 1;

        for (y = 0; y < block_height; y++) {

            s->m.new_picture.f.data[0] = src - y * 16 * stride; 

            s->m.mb_y                  = y;



            for (i = 0; i < 16 && i + 16 * y < height; i++) {

                memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],

                       width);

                for (x = width; x < 16 * block_width; x++)

                    src[i * stride + x] = src[i * stride + x - 1];

            }

            for (; i < 16 && i + 16 * y < 16 * block_height; i++)

                memcpy(&src[i * stride], &src[(i - 1) * stride],

                       16 * block_width);



            for (x = 0; x < block_width; x++) {

                s->m.mb_x = x;

                ff_init_block_index(&s->m);

                ff_update_block_index(&s->m);



                ff_estimate_p_frame_motion(&s->m, x, y);

            }

            s->m.first_slice_line = 0;

        }



        ff_fix_long_p_mvs(&s->m);

        ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code,

                        CANDIDATE_MB_TYPE_INTER, 0);

    }



    s->m.first_slice_line = 1;

    for (y = 0; y < block_height; y++) {

        for (i = 0; i < 16 && i + 16 * y < height; i++) {

            memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],

                   width);

            for (x = width; x < 16 * block_width; x++)

                src[i * stride + x] = src[i * stride + x - 1];

        }

        for (; i < 16 && i + 16 * y < 16 * block_height; i++)

            memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);



        s->m.mb_y = y;

        for (x = 0; x < block_width; x++) {

            uint8_t reorder_buffer[3][6][7 * 32];

            int count[3][6];

            int offset       = y * 16 * stride + x * 16;

            uint8_t *decoded = decoded_plane + offset;

            uint8_t *ref     = ref_plane + offset;

            int score[4]     = { 0, 0, 0, 0 }, best;

            uint8_t *temp    = s->scratchbuf;



            if (s->pb.buf_end - s->pb.buf -

                (put_bits_count(&s->pb) >> 3) < 3000) { 

                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

                return -1;

            }



            s->m.mb_x = x;

            ff_init_block_index(&s->m);

            ff_update_block_index(&s->m);



            if (f->pict_type == AV_PICTURE_TYPE_I ||

                (s->m.mb_type[x + y * s->m.mb_stride] &

                 CANDIDATE_MB_TYPE_INTRA)) {

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

                    init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],

                                  7 * 32);

                if (f->pict_type == AV_PICTURE_TYPE_P) {

                    const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA];

                    put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);

                    score[0] = vlc[1] * lambda;

                }

                score[0] += encode_block(s, src + 16 * x, NULL, temp, stride,

                                         5, 64, lambda, 1);

                for (i = 0; i < 6; i++) {

                    count[0][i] = put_bits_count(&s->reorder_pb[i]);

                    flush_put_bits(&s->reorder_pb[i]);

                }

            } else

                score[0] = INT_MAX;



            best = 0;



            if (f->pict_type == AV_PICTURE_TYPE_P) {

                const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER];

                int mx, my, pred_x, pred_y, dxy;

                int16_t *motion_ptr;



                motion_ptr = ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);

                if (s->m.mb_type[x + y * s->m.mb_stride] &

                    CANDIDATE_MB_TYPE_INTER) {

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

                        init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],

                                      7 * 32);



                    put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);



                    s->m.pb = s->reorder_pb[5];

                    mx      = motion_ptr[0];

                    my      = motion_ptr[1];

                    assert(mx     >= -32 && mx     <= 31);

                    assert(my     >= -32 && my     <= 31);

                    assert(pred_x >= -32 && pred_x <= 31);

                    assert(pred_y >= -32 && pred_y <= 31);

                    ff_h263_encode_motion(&s->m, mx - pred_x, 1);

                    ff_h263_encode_motion(&s->m, my - pred_y, 1);

                    s->reorder_pb[5] = s->m.pb;

                    score[1]        += lambda * put_bits_count(&s->reorder_pb[5]);



                    dxy = (mx & 1) + 2 * (my & 1);



                    s->hdsp.put_pixels_tab[0][dxy](temp + 16,

                                                   ref + (mx >> 1) +

                                                   stride * (my >> 1),

                                                   stride, 16);



                    score[1] += encode_block(s, src + 16 * x, temp + 16,

                                             decoded, stride, 5, 64, lambda, 0);

                    best      = score[1] <= score[0];



                    vlc       = ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];

                    score[2]  = s->dsp.sse[0](NULL, src + 16 * x, ref,

                                              stride, 16);

                    score[2] += vlc[1] * lambda;

                    if (score[2] < score[best] && mx == 0 && my == 0) {

                        best = 2;

                        s->hdsp.put_pixels_tab[0][0](decoded, ref, stride, 16);

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

                            count[2][i] = 0;

                        put_bits(&s->pb, vlc[1], vlc[0]);

                    }

                }



                if (best == 1) {

                    for (i = 0; i < 6; i++) {

                        count[1][i] = put_bits_count(&s->reorder_pb[i]);

                        flush_put_bits(&s->reorder_pb[i]);

                    }

                } else {

                    motion_ptr[0]                      =

                    motion_ptr[1]                      =

                    motion_ptr[2]                      =

                    motion_ptr[3]                      =

                    motion_ptr[0 + 2 * s->m.b8_stride] =

                    motion_ptr[1 + 2 * s->m.b8_stride] =

                    motion_ptr[2 + 2 * s->m.b8_stride] =

                    motion_ptr[3 + 2 * s->m.b8_stride] = 0;

                }

            }



            s->rd_total += score[best];



            for (i = 5; i >= 0; i--)

                avpriv_copy_bits(&s->pb, reorder_buffer[best][i],

                                 count[best][i]);

            if (best == 0)

                s->hdsp.put_pixels_tab[0][0](decoded, temp, stride, 16);

        }

        s->m.first_slice_line = 0;

    }

    return 0;

}

        s->m.last_picture.f.data[0]        = ref_plane;         s->m.last_picture.f.linesize[0]    =         s->m.new_picture.f.linesize[0]     =         s->m.current_picture.f.linesize[0] = stride;
static int FUNC_0(SVQ1Context *VAR_0, int VAR_1,

                             unsigned char *VAR_2,

                             unsigned char *VAR_3,

                             unsigned char *VAR_4,

                             int VAR_5, int VAR_6, int VAR_7, int VAR_8)

{

    const AVFrame *VAR_9 = VAR_0->avctx->coded_frame;

    int VAR_10, VAR_11;

    int VAR_12;

    int VAR_13, VAR_14;

    int VAR_15;

    int VAR_16[6];

    uint8_t *src     = VAR_0->scratchbuf + VAR_8 * 16;

    const int VAR_17 = (VAR_9->quality * VAR_9->quality) >>

                       (2 * FF_LAMBDA_SHIFT);



    

    VAR_16[5] = QUALITY_THRESHOLD;

    for (VAR_15 = 4; VAR_15 >= 0; VAR_15--)

        VAR_16[VAR_15] = VAR_16[VAR_15 + 1] * THRESHOLD_MULTIPLIER;



    VAR_13  = (VAR_5  + 15) / 16;

    VAR_14 = (VAR_6 + 15) / 16;



    if (VAR_9->pict_type == AV_PICTURE_TYPE_P) {

        VAR_0->m.avctx                         = VAR_0->avctx;

        VAR_0->m.current_picture_ptr           = &VAR_0->m.current_picture;

        VAR_0->m.last_picture_ptr              = &VAR_0->m.last_picture;

        VAR_0->m.last_picture.VAR_9.data[0]        = VAR_3;

        VAR_0->m.linesize                      =

        VAR_0->m.last_picture.VAR_9.linesize[0]    =

        VAR_0->m.new_picture.VAR_9.linesize[0]     =

        VAR_0->m.current_picture.VAR_9.linesize[0] = VAR_8;

        VAR_0->m.VAR_5                         = VAR_5;

        VAR_0->m.VAR_6                        = VAR_6;

        VAR_0->m.mb_width                      = VAR_13;

        VAR_0->m.mb_height                     = VAR_14;

        VAR_0->m.mb_stride                     = VAR_0->m.mb_width + 1;

        VAR_0->m.b8_stride                     = 2 * VAR_0->m.mb_width + 1;

        VAR_0->m.f_code                        = 1;

        VAR_0->m.pict_type                     = VAR_9->pict_type;

        VAR_0->m.me_method                     = VAR_0->avctx->me_method;

        VAR_0->m.me.scene_change_score         = 0;

        VAR_0->m.flags                         = VAR_0->avctx->flags;

        

        

        VAR_0->m.VAR_17                        = VAR_9->quality;

        VAR_0->m.qscale                        = VAR_0->m.VAR_17 * 139 +

                                             FF_LAMBDA_SCALE * 64 >>

                                             FF_LAMBDA_SHIFT + 7;

        VAR_0->m.lambda2                       = VAR_0->m.VAR_17 * VAR_0->m.VAR_17 +

                                             FF_LAMBDA_SCALE / 2 >>

                                             FF_LAMBDA_SHIFT;



        if (!VAR_0->motion_val8[VAR_1]) {

            VAR_0->motion_val8[VAR_1]  = av_mallocz((VAR_0->m.b8_stride *

                                                 VAR_14 * 2 + 2) *

                                                2 * sizeof(int16_t));

            VAR_0->motion_val16[VAR_1] = av_mallocz((VAR_0->m.mb_stride *

                                                 (VAR_14 + 2) + 1) *

                                                2 * sizeof(int16_t));

        }



        VAR_0->m.mb_type = VAR_0->mb_type;



        

        VAR_0->m.current_picture.mb_mean   = (uint8_t *)VAR_0->dummy;

        VAR_0->m.current_picture.mb_var    = (uint16_t *)VAR_0->dummy;

        VAR_0->m.current_picture.mc_mb_var = (uint16_t *)VAR_0->dummy;

        VAR_0->m.current_picture.mb_type = VAR_0->dummy;



        VAR_0->m.current_picture.motion_val[0]   = VAR_0->motion_val8[VAR_1] + 2;

        VAR_0->m.p_mv_table                      = VAR_0->motion_val16[VAR_1] +

                                               VAR_0->m.mb_stride + 1;

        VAR_0->m.dsp                             = VAR_0->dsp; 

        ff_init_me(&VAR_0->m);



        VAR_0->m.me.dia_size      = VAR_0->avctx->dia_size;

        VAR_0->m.first_slice_line = 1;

        for (VAR_11 = 0; VAR_11 < VAR_14; VAR_11++) {

            VAR_0->m.new_picture.VAR_9.data[0] = src - VAR_11 * 16 * VAR_8; 

            VAR_0->m.mb_y                  = VAR_11;



            for (VAR_12 = 0; VAR_12 < 16 && VAR_12 + 16 * VAR_11 < VAR_6; VAR_12++) {

                memcpy(&src[VAR_12 * VAR_8], &VAR_2[(VAR_12 + 16 * VAR_11) * VAR_7],

                       VAR_5);

                for (VAR_10 = VAR_5; VAR_10 < 16 * VAR_13; VAR_10++)

                    src[VAR_12 * VAR_8 + VAR_10] = src[VAR_12 * VAR_8 + VAR_10 - 1];

            }

            for (; VAR_12 < 16 && VAR_12 + 16 * VAR_11 < 16 * VAR_14; VAR_12++)

                memcpy(&src[VAR_12 * VAR_8], &src[(VAR_12 - 1) * VAR_8],

                       16 * VAR_13);



            for (VAR_10 = 0; VAR_10 < VAR_13; VAR_10++) {

                VAR_0->m.mb_x = VAR_10;

                ff_init_block_index(&VAR_0->m);

                ff_update_block_index(&VAR_0->m);



                ff_estimate_p_frame_motion(&VAR_0->m, VAR_10, VAR_11);

            }

            VAR_0->m.first_slice_line = 0;

        }



        ff_fix_long_p_mvs(&VAR_0->m);

        ff_fix_long_mvs(&VAR_0->m, NULL, 0, VAR_0->m.p_mv_table, VAR_0->m.f_code,

                        CANDIDATE_MB_TYPE_INTER, 0);

    }



    VAR_0->m.first_slice_line = 1;

    for (VAR_11 = 0; VAR_11 < VAR_14; VAR_11++) {

        for (VAR_12 = 0; VAR_12 < 16 && VAR_12 + 16 * VAR_11 < VAR_6; VAR_12++) {

            memcpy(&src[VAR_12 * VAR_8], &VAR_2[(VAR_12 + 16 * VAR_11) * VAR_7],

                   VAR_5);

            for (VAR_10 = VAR_5; VAR_10 < 16 * VAR_13; VAR_10++)

                src[VAR_12 * VAR_8 + VAR_10] = src[VAR_12 * VAR_8 + VAR_10 - 1];

        }

        for (; VAR_12 < 16 && VAR_12 + 16 * VAR_11 < 16 * VAR_14; VAR_12++)

            memcpy(&src[VAR_12 * VAR_8], &src[(VAR_12 - 1) * VAR_8], 16 * VAR_13);



        VAR_0->m.mb_y = VAR_11;

        for (VAR_10 = 0; VAR_10 < VAR_13; VAR_10++) {

            uint8_t reorder_buffer[3][6][7 * 32];

            int VAR_18[3][6];

            int VAR_19       = VAR_11 * 16 * VAR_8 + VAR_10 * 16;

            uint8_t *decoded = VAR_4 + VAR_19;

            uint8_t *ref     = VAR_3 + VAR_19;

            int VAR_20[4]     = { 0, 0, 0, 0 }, VAR_21;

            uint8_t *temp    = VAR_0->scratchbuf;



            if (VAR_0->pb.buf_end - VAR_0->pb.buf -

                (put_bits_count(&VAR_0->pb) >> 3) < 3000) { 

                av_log(VAR_0->avctx, AV_LOG_ERROR, "encoded frame too large\n");

                return -1;

            }



            VAR_0->m.mb_x = VAR_10;

            ff_init_block_index(&VAR_0->m);

            ff_update_block_index(&VAR_0->m);



            if (VAR_9->pict_type == AV_PICTURE_TYPE_I ||

                (VAR_0->m.mb_type[VAR_10 + VAR_11 * VAR_0->m.mb_stride] &

                 CANDIDATE_MB_TYPE_INTRA)) {

                for (VAR_12 = 0; VAR_12 < 6; VAR_12++)

                    init_put_bits(&VAR_0->reorder_pb[VAR_12], reorder_buffer[0][VAR_12],

                                  7 * 32);

                if (VAR_9->pict_type == AV_PICTURE_TYPE_P) {

                    const uint8_t *VAR_23 = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA];

                    put_bits(&VAR_0->reorder_pb[5], VAR_23[1], VAR_23[0]);

                    VAR_20[0] = VAR_23[1] * VAR_17;

                }

                VAR_20[0] += encode_block(VAR_0, src + 16 * VAR_10, NULL, temp, VAR_8,

                                         5, 64, VAR_17, 1);

                for (VAR_12 = 0; VAR_12 < 6; VAR_12++) {

                    VAR_18[0][VAR_12] = put_bits_count(&VAR_0->reorder_pb[VAR_12]);

                    flush_put_bits(&VAR_0->reorder_pb[VAR_12]);

                }

            } else

                VAR_20[0] = INT_MAX;



            VAR_21 = 0;



            if (VAR_9->pict_type == AV_PICTURE_TYPE_P) {

                const uint8_t *VAR_23 = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER];

                int VAR_23, VAR_24, VAR_25, VAR_26, VAR_27;

                int16_t *motion_ptr;



                motion_ptr = ff_h263_pred_motion(&VAR_0->m, 0, 0, &VAR_25, &VAR_26);

                if (VAR_0->m.mb_type[VAR_10 + VAR_11 * VAR_0->m.mb_stride] &

                    CANDIDATE_MB_TYPE_INTER) {

                    for (VAR_12 = 0; VAR_12 < 6; VAR_12++)

                        init_put_bits(&VAR_0->reorder_pb[VAR_12], reorder_buffer[1][VAR_12],

                                      7 * 32);



                    put_bits(&VAR_0->reorder_pb[5], VAR_23[1], VAR_23[0]);



                    VAR_0->m.pb = VAR_0->reorder_pb[5];

                    VAR_23      = motion_ptr[0];

                    VAR_24      = motion_ptr[1];

                    assert(VAR_23     >= -32 && VAR_23     <= 31);

                    assert(VAR_24     >= -32 && VAR_24     <= 31);

                    assert(VAR_25 >= -32 && VAR_25 <= 31);

                    assert(VAR_26 >= -32 && VAR_26 <= 31);

                    ff_h263_encode_motion(&VAR_0->m, VAR_23 - VAR_25, 1);

                    ff_h263_encode_motion(&VAR_0->m, VAR_24 - VAR_26, 1);

                    VAR_0->reorder_pb[5] = VAR_0->m.pb;

                    VAR_20[1]        += VAR_17 * put_bits_count(&VAR_0->reorder_pb[5]);



                    VAR_27 = (VAR_23 & 1) + 2 * (VAR_24 & 1);



                    VAR_0->hdsp.put_pixels_tab[0][VAR_27](temp + 16,

                                                   ref + (VAR_23 >> 1) +

                                                   VAR_8 * (VAR_24 >> 1),

                                                   VAR_8, 16);



                    VAR_20[1] += encode_block(VAR_0, src + 16 * VAR_10, temp + 16,

                                             decoded, VAR_8, 5, 64, VAR_17, 0);

                    VAR_21      = VAR_20[1] <= VAR_20[0];



                    VAR_23       = ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];

                    VAR_20[2]  = VAR_0->dsp.sse[0](NULL, src + 16 * VAR_10, ref,

                                              VAR_8, 16);

                    VAR_20[2] += VAR_23[1] * VAR_17;

                    if (VAR_20[2] < VAR_20[VAR_21] && VAR_23 == 0 && VAR_24 == 0) {

                        VAR_21 = 2;

                        VAR_0->hdsp.put_pixels_tab[0][0](decoded, ref, VAR_8, 16);

                        for (VAR_12 = 0; VAR_12 < 6; VAR_12++)

                            VAR_18[2][VAR_12] = 0;

                        put_bits(&VAR_0->pb, VAR_23[1], VAR_23[0]);

                    }

                }



                if (VAR_21 == 1) {

                    for (VAR_12 = 0; VAR_12 < 6; VAR_12++) {

                        VAR_18[1][VAR_12] = put_bits_count(&VAR_0->reorder_pb[VAR_12]);

                        flush_put_bits(&VAR_0->reorder_pb[VAR_12]);

                    }

                } else {

                    motion_ptr[0]                      =

                    motion_ptr[1]                      =

                    motion_ptr[2]                      =

                    motion_ptr[3]                      =

                    motion_ptr[0 + 2 * VAR_0->m.b8_stride] =

                    motion_ptr[1 + 2 * VAR_0->m.b8_stride] =

                    motion_ptr[2 + 2 * VAR_0->m.b8_stride] =

                    motion_ptr[3 + 2 * VAR_0->m.b8_stride] = 0;

                }

            }



            VAR_0->rd_total += VAR_20[VAR_21];



            for (VAR_12 = 5; VAR_12 >= 0; VAR_12--)

                avpriv_copy_bits(&VAR_0->pb, reorder_buffer[VAR_21][VAR_12],

                                 VAR_18[VAR_21][VAR_12]);

            if (VAR_21 == 0)

                VAR_0->hdsp.put_pixels_tab[0][0](decoded, temp, VAR_8, 16);

        }

        VAR_0->m.first_slice_line = 0;

    }

    return 0;

}

static int FUNC_0(SVQ1Context *VAR_0, int VAR_1,
unsigned char *VAR_2,
unsigned char *VAR_3,
unsigned char *VAR_4,
int VAR_5, int VAR_6, int VAR_7, int VAR_8)
{ const AVFrame *VAR_9 = VAR_0->avctx->coded_frame; int VAR_10, VAR_11; int VAR_12; int VAR_13, VAR_14; int VAR_15; int VAR_16[6]; uint8_t *src     = VAR_0->scratchbuf + VAR_8 * 16; const int VAR_17 = (VAR_9->quality * VAR_9->quality) >>
(2 * FF_LAMBDA_SHIFT); VAR_16[5] = QUALITY_THRESHOLD; for (VAR_15 = 4; VAR_15 >= 0; VAR_15--) VAR_16[VAR_15] = VAR_16[VAR_15 + 1] * THRESHOLD_MULTIPLIER; VAR_13  = (VAR_5  + 15) / 16; VAR_14 = (VAR_6 + 15) / 16; if (VAR_9->pict_type == AV_PICTURE_TYPE_P) { VAR_0->m.avctx                         = VAR_0->avctx; VAR_0->m.current_picture_ptr           = &VAR_0->m.current_picture; VAR_0->m.last_picture_ptr              = &VAR_0->m.last_picture; VAR_0->m.last_picture.VAR_9.data[0]        = VAR_3; VAR_0->m.linesize                      =
VAR_0->m.last_picture.VAR_9.linesize[0]    =
VAR_0->m.new_picture.VAR_9.linesize[0]     =
VAR_0->m.current_picture.VAR_9.linesize[0] = VAR_8; VAR_0->m.VAR_5                         = VAR_5; VAR_0->m.VAR_6                        = VAR_6; VAR_0->m.mb_width                      = VAR_13; VAR_0->m.mb_height                     = VAR_14; VAR_0->m.mb_stride                     = VAR_0->m.mb_width + 1; VAR_0->m.b8_stride                     = 2 * VAR_0->m.mb_width + 1; VAR_0->m.f_code                        = 1; VAR_0->m.pict_type                     = VAR_9->pict_type; VAR_0->m.me_method                     = VAR_0->avctx->me_method; VAR_0->m.me.scene_change_score         = 0; VAR_0->m.flags                         = VAR_0->avctx->flags; VAR_0->m.VAR_17                        = VAR_9->quality; VAR_0->m.qscale                        = VAR_0->m.VAR_17 * 139 +
FF_LAMBDA_SCALE * 64 >>
FF_LAMBDA_SHIFT + 7; VAR_0->m.lambda2                       = VAR_0->m.VAR_17 * VAR_0->m.VAR_17 +
FF_LAMBDA_SCALE / 2 >>
FF_LAMBDA_SHIFT; if (!VAR_0->motion_val8[VAR_1]) { VAR_0->motion_val8[VAR_1]  = av_mallocz((VAR_0->m.b8_stride *
VAR_14 * 2 + 2) *
2 * sizeof(int16_t)); VAR_0->motion_val16[VAR_1] = av_mallocz((VAR_0->m.mb_stride *
(VAR_14 + 2) + 1) *
2 * sizeof(int16_t)); } VAR_0->m.mb_type = VAR_0->mb_type; VAR_0->m.current_picture.mb_mean   = (uint8_t *)VAR_0->dummy; VAR_0->m.current_picture.mb_var    = (uint16_t *)VAR_0->dummy; VAR_0->m.current_picture.mc_mb_var = (uint16_t *)VAR_0->dummy; VAR_0->m.current_picture.mb_type = VAR_0->dummy; VAR_0->m.current_picture.motion_val[0]   = VAR_0->motion_val8[VAR_1] + 2; VAR_0->m.p_mv_table                      = VAR_0->motion_val16[VAR_1] +
VAR_0->m.mb_stride + 1; VAR_0->m.dsp                             = VAR_0->dsp; ff_init_me(&VAR_0->m); VAR_0->m.me.dia_size      = VAR_0->avctx->dia_size; VAR_0->m.first_slice_line = 1; for (VAR_11 = 0; VAR_11 < VAR_14; VAR_11++) { VAR_0->m.new_picture.VAR_9.data[0] = src - VAR_11 * 16 * VAR_8; VAR_0->m.mb_y                  = VAR_11; for (VAR_12 = 0; VAR_12 < 16 && VAR_12 + 16 * VAR_11 < VAR_6; VAR_12++) { memcpy(&src[VAR_12 * VAR_8], &VAR_2[(VAR_12 + 16 * VAR_11) * VAR_7],
VAR_5); for (VAR_10 = VAR_5; VAR_10 < 16 * VAR_13; VAR_10++) src[VAR_12 * VAR_8 + VAR_10] = src[VAR_12 * VAR_8 + VAR_10 - 1]; } for (; VAR_12 < 16 && VAR_12 + 16 * VAR_11 < 16 * VAR_14; VAR_12++) memcpy(&src[VAR_12 * VAR_8], &src[(VAR_12 - 1) * VAR_8],
16 * VAR_13); for (VAR_10 = 0; VAR_10 < VAR_13; VAR_10++) { VAR_0->m.mb_x = VAR_10; ff_init_block_index(&VAR_0->m); ff_update_block_index(&VAR_0->m); ff_estimate_p_frame_motion(&VAR_0->m, VAR_10, VAR_11); } VAR_0->m.first_slice_line = 0; } ff_fix_long_p_mvs(&VAR_0->m); ff_fix_long_mvs(&VAR_0->m, NULL, 0, VAR_0->m.p_mv_table, VAR_0->m.f_code,
CANDIDATE_MB_TYPE_INTER, 0); } VAR_0->m.first_slice_line = 1; for (VAR_11 = 0; VAR_11 < VAR_14; VAR_11++) { for (VAR_12 = 0; VAR_12 < 16 && VAR_12 + 16 * VAR_11 < VAR_6; VAR_12++) { memcpy(&src[VAR_12 * VAR_8], &VAR_2[(VAR_12 + 16 * VAR_11) * VAR_7],
VAR_5); for (VAR_10 = VAR_5; VAR_10 < 16 * VAR_13; VAR_10++) src[VAR_12 * VAR_8 + VAR_10] = src[VAR_12 * VAR_8 + VAR_10 - 1]; } for (; VAR_12 < 16 && VAR_12 + 16 * VAR_11 < 16 * VAR_14; VAR_12++) memcpy(&src[VAR_12 * VAR_8], &src[(VAR_12 - 1) * VAR_8], 16 * VAR_13); VAR_0->m.mb_y = VAR_11; for (VAR_10 = 0; VAR_10 < VAR_13; VAR_10++) { uint8_t reorder_buffer[3][6][7 * 32]; int VAR_18[3][6]; int VAR_19       = VAR_11 * 16 * VAR_8 + VAR_10 * 16; uint8_t *decoded = VAR_4 + VAR_19; uint8_t *ref     = VAR_3 + VAR_19; int VAR_20[4]     = { 0, 0, 0, 0 }, VAR_21; uint8_t *temp    = VAR_0->scratchbuf; if (VAR_0->pb.buf_end - VAR_0->pb.buf -
(put_bits_count(&VAR_0->pb) >> 3) < 3000) { av_log(VAR_0->avctx, AV_LOG_ERROR, "encoded frame too large\n"); return -1; } VAR_0->m.mb_x = VAR_10; ff_init_block_index(&VAR_0->m); ff_update_block_index(&VAR_0->m); if (VAR_9->pict_type == AV_PICTURE_TYPE_I ||
(VAR_0->m.mb_type[VAR_10 + VAR_11 * VAR_0->m.mb_stride] &
CANDIDATE_MB_TYPE_INTRA)) { for (VAR_12 = 0; VAR_12 < 6; VAR_12++) init_put_bits(&VAR_0->reorder_pb[VAR_12], reorder_buffer[0][VAR_12],
7 * 32); if (VAR_9->pict_type == AV_PICTURE_TYPE_P) { const uint8_t *VAR_23 = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA]; put_bits(&VAR_0->reorder_pb[5], VAR_23[1], VAR_23[0]); VAR_20[0] = VAR_23[1] * VAR_17; } VAR_20[0] += encode_block(VAR_0, src + 16 * VAR_10, NULL, temp, VAR_8,
5, 64, VAR_17, 1); for (VAR_12 = 0; VAR_12 < 6; VAR_12++) { VAR_18[0][VAR_12] = put_bits_count(&VAR_0->reorder_pb[VAR_12]); flush_put_bits(&VAR_0->reorder_pb[VAR_12]); } } else VAR_20[0] = INT_MAX; VAR_21 = 0; if (VAR_9->pict_type == AV_PICTURE_TYPE_P) { const uint8_t *VAR_23 = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER]; int VAR_23, VAR_24, VAR_25, VAR_26, VAR_27; int16_t *motion_ptr; motion_ptr = ff_h263_pred_motion(&VAR_0->m, 0, 0, &VAR_25, &VAR_26); if (VAR_0->m.mb_type[VAR_10 + VAR_11 * VAR_0->m.mb_stride] &
CANDIDATE_MB_TYPE_INTER) { for (VAR_12 = 0; VAR_12 < 6; VAR_12++) init_put_bits(&VAR_0->reorder_pb[VAR_12], reorder_buffer[1][VAR_12],
7 * 32); put_bits(&VAR_0->reorder_pb[5], VAR_23[1], VAR_23[0]); VAR_0->m.pb = VAR_0->reorder_pb[5]; VAR_23      = motion_ptr[0]; VAR_24      = motion_ptr[1]; assert(VAR_23     >= -32 && VAR_23     <= 31); assert(VAR_24     >= -32 && VAR_24     <= 31); assert(VAR_25 >= -32 && VAR_25 <= 31); assert(VAR_26 >= -32 && VAR_26 <= 31); ff_h263_encode_motion(&VAR_0->m, VAR_23 - VAR_25, 1); ff_h263_encode_motion(&VAR_0->m, VAR_24 - VAR_26, 1); VAR_0->reorder_pb[5] = VAR_0->m.pb; VAR_20[1]        += VAR_17 * put_bits_count(&VAR_0->reorder_pb[5]); VAR_27 = (VAR_23 & 1) + 2 * (VAR_24 & 1); VAR_0->hdsp.put_pixels_tab[0][VAR_27](temp + 16,
ref + (VAR_23 >> 1) +
VAR_8 * (VAR_24 >> 1),
VAR_8, 16); VAR_20[1] += encode_block(VAR_0, src + 16 * VAR_10, temp + 16,
decoded, VAR_8, 5, 64, VAR_17, 0); VAR_21      = VAR_20[1] <= VAR_20[0]; VAR_23       = ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP]; VAR_20[2]  = VAR_0->dsp.sse[0](NULL, src + 16 * VAR_10, ref,
VAR_8, 16); VAR_20[2] += VAR_23[1] * VAR_17; if (VAR_20[2] < VAR_20[VAR_21] && VAR_23 == 0 && VAR_24 == 0) { VAR_21 = 2; VAR_0->hdsp.put_pixels_tab[0][0](decoded, ref, VAR_8, 16); for (VAR_12 = 0; VAR_12 < 6; VAR_12++) VAR_18[2][VAR_12] = 0; put_bits(&VAR_0->pb, VAR_23[1], VAR_23[0]); } } if (VAR_21 == 1) { for (VAR_12 = 0; VAR_12 < 6; VAR_12++) { VAR_18[1][VAR_12] = put_bits_count(&VAR_0->reorder_pb[VAR_12]); flush_put_bits(&VAR_0->reorder_pb[VAR_12]); } } else { motion_ptr[0]                      =
motion_ptr[1]                      =
motion_ptr[2]                      =
motion_ptr[3]                      =
motion_ptr[0 + 2 * VAR_0->m.b8_stride] =
motion_ptr[1 + 2 * VAR_0->m.b8_stride] =
motion_ptr[2 + 2 * VAR_0->m.b8_stride] =
motion_ptr[3 + 2 * VAR_0->m.b8_stride] = 0; } } VAR_0->rd_total += VAR_20[VAR_21]; for (VAR_12 = 5; VAR_12 >= 0; VAR_12--) avpriv_copy_bits(&VAR_0->pb, reorder_buffer[VAR_21][VAR_12],
VAR_18[VAR_21][VAR_12]); if (VAR_21 == 0)
VAR_0->hdsp.put_pixels_tab[0][0](decoded, temp, VAR_8, 16); } VAR_0->m.first_slice_line = 0; } return 0; }