Subversion Repositories Kolibri OS

/*

 * Copyright (C) 2004 Michael Niedermayer 

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

#include "libavutil/intmath.h"

#include "libavutil/log.h"

#include "libavutil/opt.h"

#include "avcodec.h"

#include "dsputil.h"

#include "internal.h"

#include "snow_dwt.h"

#include "snow.h"

#include "rangecoder.h"

#include "mathops.h"

#include "mpegvideo.h"

#include "h263.h"

static av_cold int encode_init(AVCodecContext *avctx)

{

    SnowContext *s = avctx->priv_data;

    int plane_index, ret;

    if(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){

        av_log(avctx, AV_LOG_ERROR, "This codec is under development, files encoded with it may not be decodable with future versions!!!\n"

               "Use vstrict=-2 / -strict -2 to use it anyway.\n");

        return -1;

    }

    if(avctx->prediction_method == DWT_97

       && (avctx->flags & CODEC_FLAG_QSCALE)

       && avctx->global_quality == 0){

        av_log(avctx, AV_LOG_ERROR, "The 9/7 wavelet is incompatible with lossless mode.\n");

        return -1;

    }

    s->spatial_decomposition_type= avctx->prediction_method; //FIXME add decorrelator type r transform_type

    s->mv_scale       = (avctx->flags & CODEC_FLAG_QPEL) ? 2 : 4;

    s->block_max_depth= (avctx->flags & CODEC_FLAG_4MV ) ? 1 : 0;

    for(plane_index=0; plane_index<3; plane_index++){

        s->plane[plane_index].diag_mc= 1;

        s->plane[plane_index].htaps= 6;

        s->plane[plane_index].hcoeff[0]=  40;

        s->plane[plane_index].hcoeff[1]= -10;

        s->plane[plane_index].hcoeff[2]=   2;

        s->plane[plane_index].fast_mc= 1;

    }

    if ((ret = ff_snow_common_init(avctx)) < 0) {

        ff_snow_common_end(avctx->priv_data);

        return ret;

    }

    ff_snow_alloc_blocks(s);

    s->version=0;

    s->m.avctx   = avctx;

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

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

    s->m.me.temp      =

    s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));

    s->m.me.map       = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));

    s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));

    s->m.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));

    if (!s->m.me.scratchpad || !s->m.me.map || !s->m.me.score_map || !s->m.obmc_scratchpad)

        return AVERROR(ENOMEM);

    ff_h263_encode_init(&s->m); //mv_penalty

    s->max_ref_frames = FFMAX(FFMIN(avctx->refs, MAX_REF_FRAMES), 1);

    if(avctx->flags&CODEC_FLAG_PASS1){

        if(!avctx->stats_out)

            avctx->stats_out = av_mallocz(256);

        if (!avctx->stats_out)

            return AVERROR(ENOMEM);

    }

    if((avctx->flags&CODEC_FLAG_PASS2) || !(avctx->flags&CODEC_FLAG_QSCALE)){

        if(ff_rate_control_init(&s->m) < 0)

            return -1;

    }

    s->pass1_rc= !(avctx->flags & (CODEC_FLAG_QSCALE|CODEC_FLAG_PASS2));

    switch(avctx->pix_fmt){

    case AV_PIX_FMT_YUV444P:

//    case AV_PIX_FMT_YUV422P:

    case AV_PIX_FMT_YUV420P:

//    case AV_PIX_FMT_YUV411P:

    case AV_PIX_FMT_YUV410P:

        s->nb_planes = 3;

        s->colorspace_type= 0;

        break;

    case AV_PIX_FMT_GRAY8:

        s->nb_planes = 1;

        s->colorspace_type = 1;

        break;

/*    case AV_PIX_FMT_RGB32:

        s->colorspace= 1;

        break;*/

    default:

        av_log(avctx, AV_LOG_ERROR, "pixel format not supported\n");

        return -1;

    }

    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);

    ff_set_cmp(&s->dsp, s->dsp.me_cmp, s->avctx->me_cmp);

    ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, s->avctx->me_sub_cmp);

    s->input_picture = av_frame_alloc();

    if (!s->input_picture)

        return AVERROR(ENOMEM);

    if ((ret = ff_get_buffer(s->avctx, s->input_picture, AV_GET_BUFFER_FLAG_REF)) < 0)

        return ret;

    if(s->avctx->me_method == ME_ITER){

        int i;

        int size= s->b_width * s->b_height << 2*s->block_max_depth;

        for(i=0; imax_ref_frames; i++){

            s->ref_mvs[i]= av_mallocz(size*sizeof(int16_t[2]));

            s->ref_scores[i]= av_mallocz(size*sizeof(uint32_t));

            if (!s->ref_mvs[i] || !s->ref_scores[i])

                return AVERROR(ENOMEM);

        }

    }

    return 0;

}

//near copy & paste from dsputil, FIXME

static int pix_sum(uint8_t * pix, int line_size, int w, int h)

{

    int s, i, j;

    s = 0;

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

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

            s += pix[0];

            pix ++;

        }

        pix += line_size - w;

    }

    return s;

}

//near copy & paste from dsputil, FIXME

static int pix_norm1(uint8_t * pix, int line_size, int w)

{

    int s, i, j;

    uint32_t *sq = ff_squareTbl + 256;

    s = 0;

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

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

            s += sq[pix[0]];

            pix ++;

        }

        pix += line_size - w;

    }

    return s;

}

static inline int get_penalty_factor(int lambda, int lambda2, int type){

    switch(type&0xFF){

    default:

    case FF_CMP_SAD:

        return lambda>>FF_LAMBDA_SHIFT;

    case FF_CMP_DCT:

        return (3*lambda)>>(FF_LAMBDA_SHIFT+1);

    case FF_CMP_W53:

        return (4*lambda)>>(FF_LAMBDA_SHIFT);

    case FF_CMP_W97:

        return (2*lambda)>>(FF_LAMBDA_SHIFT);

    case FF_CMP_SATD:

    case FF_CMP_DCT264:

        return (2*lambda)>>FF_LAMBDA_SHIFT;

    case FF_CMP_RD:

    case FF_CMP_PSNR:

    case FF_CMP_SSE:

    case FF_CMP_NSSE:

        return lambda2>>FF_LAMBDA_SHIFT;

    case FF_CMP_BIT:

        return 1;

    }

}

//FIXME copy&paste

#define P_LEFT P[1]

#define P_TOP P[2]

#define P_TOPRIGHT P[3]

#define P_MEDIAN P[4]

#define P_MV1 P[9]

#define FLAG_QPEL   1 //must be 1

static int encode_q_branch(SnowContext *s, int level, int x, int y){

    uint8_t p_buffer[1024];

    uint8_t i_buffer[1024];

    uint8_t p_state[sizeof(s->block_state)];

    uint8_t i_state[sizeof(s->block_state)];

    RangeCoder pc, ic;

    uint8_t *pbbak= s->c.bytestream;

    uint8_t *pbbak_start= s->c.bytestream_start;

    int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;

    const int w= s->b_width  << s->block_max_depth;

    const int h= s->b_height << s->block_max_depth;

    const int rem_depth= s->block_max_depth - level;

    const int index= (x + y*w) << rem_depth;

    const int block_w= 1<<(LOG2_MB_SIZE - level);

    int trx= (x+1)<

    int try= (y+1)<

    const BlockNode *left  = x ? &s->block[index-1] : &null_block;

    const BlockNode *top   = y ? &s->block[index-w] : &null_block;

    const BlockNode *right = trxblock[index+1] : &null_block;

    const BlockNode *bottom= tryblock[index+w] : &null_block;

    const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;

    const BlockNode *tr    = y && trxblock[index-w+(1<

    int pl = left->color[0];

    int pcb= left->color[1];

    int pcr= left->color[2];

    int pmx, pmy;

    int mx=0, my=0;

    int l,cr,cb;

    const int stride= s->current_picture->linesize[0];

    const int uvstride= s->current_picture->linesize[1];

    uint8_t *current_data[3]= { s->input_picture->data[0] + (x + y*  stride)*block_w,

                                s->input_picture->data[1] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift),

                                s->input_picture->data[2] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift)};

    int P[10][2];

    int16_t last_mv[3][2];

    int qpel= !!(s->avctx->flags & CODEC_FLAG_QPEL); //unused

    const int shift= 1+qpel;

    MotionEstContext *c= &s->m.me;

    int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);

    int mx_context= av_log2(2*FFABS(left->mx - top->mx));

    int my_context= av_log2(2*FFABS(left->my - top->my));

    int s_context= 2*left->level + 2*top->level + tl->level + tr->level;

    int ref, best_ref, ref_score, ref_mx, ref_my;

    av_assert0(sizeof(s->block_state) >= 256);

    if(s->keyframe){

        set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);

        return 0;

    }

//    clip predictors / edge ?

    P_LEFT[0]= left->mx;

    P_LEFT[1]= left->my;

    P_TOP [0]= top->mx;

    P_TOP [1]= top->my;

    P_TOPRIGHT[0]= tr->mx;

    P_TOPRIGHT[1]= tr->my;

    last_mv[0][0]= s->block[index].mx;

    last_mv[0][1]= s->block[index].my;

    last_mv[1][0]= right->mx;

    last_mv[1][1]= right->my;

    last_mv[2][0]= bottom->mx;

    last_mv[2][1]= bottom->my;

    s->m.mb_stride=2;

    s->m.mb_x=

    s->m.mb_y= 0;

    c->skip= 0;

    av_assert1(c->  stride ==   stride);

    av_assert1(c->uvstride == uvstride);

    c->penalty_factor    = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);

    c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);

    c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);

    c->current_mv_penalty= c->mv_penalty[s->m.f_code=1] + MAX_MV;

    c->xmin = - x*block_w - 16+3;

    c->ymin = - y*block_w - 16+3;

    c->xmax = - (x+1)*block_w + (w<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;

    c->ymax = - (y+1)*block_w + (h<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;

    if(P_LEFT[0]     > (c->xmax<xmax<

    if(P_LEFT[1]     > (c->ymax<ymax<

    if(P_TOP[0]      > (c->xmax<xmax<

    if(P_TOP[1]      > (c->ymax<ymax<

    if(P_TOPRIGHT[0] < (c->xmin<xmin<

    if(P_TOPRIGHT[0] > (c->xmax<xmax<

    if(P_TOPRIGHT[1] > (c->ymax<ymax<

    P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);

    P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);

    if (!y) {

        c->pred_x= P_LEFT[0];

        c->pred_y= P_LEFT[1];

    } else {

        c->pred_x = P_MEDIAN[0];

        c->pred_y = P_MEDIAN[1];

    }

    score= INT_MAX;

    best_ref= 0;

    for(ref=0; refref_frames; ref++){

        init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0);

        ref_score= ff_epzs_motion_search(&s->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,

                                         (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);

        av_assert2(ref_mx >= c->xmin);

        av_assert2(ref_mx <= c->xmax);

        av_assert2(ref_my >= c->ymin);

        av_assert2(ref_my <= c->ymax);

        ref_score= c->sub_motion_search(&s->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);

        ref_score= ff_get_mb_score(&s->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);

        ref_score+= 2*av_log2(2*ref)*c->penalty_factor;

        if(s->ref_mvs[ref]){

            s->ref_mvs[ref][index][0]= ref_mx;

            s->ref_mvs[ref][index][1]= ref_my;

            s->ref_scores[ref][index]= ref_score;

        }

        if(score > ref_score){

            score= ref_score;

            best_ref= ref;

            mx= ref_mx;

            my= ref_my;

        }

    }

    //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2

  //  subpel search

    base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);

    pc= s->c;

    pc.bytestream_start=

    pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo

    memcpy(p_state, s->block_state, sizeof(s->block_state));

    if(level!=s->block_max_depth)

        put_rac(&pc, &p_state[4 + s_context], 1);

    put_rac(&pc, &p_state[1 + left->type + top->type], 0);

    if(s->ref_frames > 1)

        put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);

    pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);

    put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);

    put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);

    p_len= pc.bytestream - pc.bytestream_start;

    score += (s->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;

    block_s= block_w*block_w;

    sum = pix_sum(current_data[0], stride, block_w, block_w);

    l= (sum + block_s/2)/block_s;

    iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;

    if (s->nb_planes > 2) {

        block_s= block_w*block_w>>(s->chroma_h_shift + s->chroma_v_shift);

        sum = pix_sum(current_data[1], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);

        cb= (sum + block_s/2)/block_s;

    //    iscore += pix_norm1(¤t_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;

        sum = pix_sum(current_data[2], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);

        cr= (sum + block_s/2)/block_s;

    //    iscore += pix_norm1(¤t_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;

    }else

        cb = cr = 0;

    ic= s->c;

    ic.bytestream_start=

    ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo

    memcpy(i_state, s->block_state, sizeof(s->block_state));

    if(level!=s->block_max_depth)

        put_rac(&ic, &i_state[4 + s_context], 1);

    put_rac(&ic, &i_state[1 + left->type + top->type], 1);

    put_symbol(&ic, &i_state[32],  l-pl , 1);

    if (s->nb_planes > 2) {

        put_symbol(&ic, &i_state[64], cb-pcb, 1);

        put_symbol(&ic, &i_state[96], cr-pcr, 1);

    }

    i_len= ic.bytestream - ic.bytestream_start;

    iscore += (s->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;

//    assert(score==256*256*256*64-1);

    av_assert1(iscore < 255*255*256 + s->lambda2*10);

    av_assert1(iscore >= 0);

    av_assert1(l>=0 && l<=255);

    av_assert1(pl>=0 && pl<=255);

    if(level==0){

        int varc= iscore >> 8;

        int vard= score >> 8;

        if (vard <= 64 || vard < varc)

            c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);

        else

            c->scene_change_score+= s->m.qscale;

    }

    if(level!=s->block_max_depth){

        put_rac(&s->c, &s->block_state[4 + s_context], 0);

        score2 = encode_q_branch(s, level+1, 2*x+0, 2*y+0);

        score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+0);

        score2+= encode_q_branch(s, level+1, 2*x+0, 2*y+1);

        score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+1);

        score2+= s->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead

        if(score2 < score && score2 < iscore)

            return score2;

    }

    if(iscore < score){

        pred_mv(s, &pmx, &pmy, 0, left, top, tr);

        memcpy(pbbak, i_buffer, i_len);

        s->c= ic;

        s->c.bytestream_start= pbbak_start;

        s->c.bytestream= pbbak + i_len;

        set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0, BLOCK_INTRA);

        memcpy(s->block_state, i_state, sizeof(s->block_state));

        return iscore;

    }else{

        memcpy(pbbak, p_buffer, p_len);

        s->c= pc;

        s->c.bytestream_start= pbbak_start;

        s->c.bytestream= pbbak + p_len;

        set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);

        memcpy(s->block_state, p_state, sizeof(s->block_state));

        return score;

    }

}

static void encode_q_branch2(SnowContext *s, int level, int x, int y){

    const int w= s->b_width  << s->block_max_depth;

    const int rem_depth= s->block_max_depth - level;

    const int index= (x + y*w) << rem_depth;

    int trx= (x+1)<

    BlockNode *b= &s->block[index];

    const BlockNode *left  = x ? &s->block[index-1] : &null_block;

    const BlockNode *top   = y ? &s->block[index-w] : &null_block;

    const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;

    const BlockNode *tr    = y && trxblock[index-w+(1<

    int pl = left->color[0];

    int pcb= left->color[1];

    int pcr= left->color[2];

    int pmx, pmy;

    int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);

    int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 16*!!b->ref;

    int my_context= av_log2(2*FFABS(left->my - top->my)) + 16*!!b->ref;

    int s_context= 2*left->level + 2*top->level + tl->level + tr->level;

    if(s->keyframe){

        set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);

        return;

    }

    if(level!=s->block_max_depth){

        if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){

            put_rac(&s->c, &s->block_state[4 + s_context], 1);

        }else{

            put_rac(&s->c, &s->block_state[4 + s_context], 0);

            encode_q_branch2(s, level+1, 2*x+0, 2*y+0);

            encode_q_branch2(s, level+1, 2*x+1, 2*y+0);

            encode_q_branch2(s, level+1, 2*x+0, 2*y+1);

            encode_q_branch2(s, level+1, 2*x+1, 2*y+1);

            return;

        }

    }

    if(b->type & BLOCK_INTRA){

        pred_mv(s, &pmx, &pmy, 0, left, top, tr);

        put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);

        put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);

        if (s->nb_planes > 2) {

            put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);

            put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);

        }

        set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0, BLOCK_INTRA);

    }else{

        pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);

        put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);

        if(s->ref_frames > 1)

            put_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], b->ref, 0);

        put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);

        put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);

        set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, b->ref, 0);

    }

}

static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index){

    int i, x2, y2;

    Plane *p= &s->plane[plane_index];

    const int block_size = MB_SIZE >> s->block_max_depth;

    const int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;

    const int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;

    const uint8_t *obmc  = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];

    const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;

    const int ref_stride= s->current_picture->linesize[plane_index];

    uint8_t *src= s-> input_picture->data[plane_index];

    IDWTELEM *dst= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned

    const int b_stride = s->b_width << s->block_max_depth;

    const int w= p->width;

    const int h= p->height;

    int index= mb_x + mb_y*b_stride;

    BlockNode *b= &s->block[index];

    BlockNode backup= *b;

    int ab=0;

    int aa=0;

    av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc stuff above

    b->type|= BLOCK_INTRA;

    b->color[plane_index]= 0;

    memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));

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

        int mb_x2= mb_x + (i &1) - 1;

        int mb_y2= mb_y + (i>>1) - 1;

        int x= block_w*mb_x2 + block_w/2;

        int y= block_h*mb_y2 + block_h/2;

        add_yblock(s, 0, NULL, dst + (i&1)*block_w + (i>>1)*obmc_stride*block_h, NULL, obmc,

                    x, y, block_w, block_h, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);

        for(y2= FFMAX(y, 0); y2

            for(x2= FFMAX(x, 0); x2

                int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;

                int obmc_v= obmc[index];

                int d;

                if(y<0) obmc_v += obmc[index + block_h*obmc_stride];

                if(x<0) obmc_v += obmc[index + block_w];

                if(y+block_h>h) obmc_v += obmc[index - block_h*obmc_stride];

                if(x+block_w>w) obmc_v += obmc[index - block_w];

                //FIXME precalculate this or simplify it somehow else

                d = -dst[index] + (1<<(FRAC_BITS-1));

                dst[index] = d;

                ab += (src[x2 + y2*ref_stride] - (d>>FRAC_BITS)) * obmc_v;

                aa += obmc_v * obmc_v; //FIXME precalculate this

            }

        }

    }

    *b= backup;

    return av_clip( ROUNDED_DIV(ab<

}

static inline int get_block_bits(SnowContext *s, int x, int y, int w){

    const int b_stride = s->b_width << s->block_max_depth;

    const int b_height = s->b_height<< s->block_max_depth;

    int index= x + y*b_stride;

    const BlockNode *b     = &s->block[index];

    const BlockNode *left  = x ? &s->block[index-1] : &null_block;

    const BlockNode *top   = y ? &s->block[index-b_stride] : &null_block;

    const BlockNode *tl    = y && x ? &s->block[index-b_stride-1] : left;

    const BlockNode *tr    = y && x+wblock[index-b_stride+w] : tl;

    int dmx, dmy;

//  int mx_context= av_log2(2*FFABS(left->mx - top->mx));

//  int my_context= av_log2(2*FFABS(left->my - top->my));

    if(x<0 || x>=b_stride || y>=b_height)

        return 0;

/*

1            0      0

01X          1-2    1

001XX        3-6    2-3

0001XXX      7-14   4-7

00001XXXX   15-30   8-15

*/

//FIXME try accurate rate

//FIXME intra and inter predictors if surrounding blocks are not the same type

    if(b->type & BLOCK_INTRA){

        return 3+2*( av_log2(2*FFABS(left->color[0] - b->color[0]))

                   + av_log2(2*FFABS(left->color[1] - b->color[1]))

                   + av_log2(2*FFABS(left->color[2] - b->color[2])));

    }else{

        pred_mv(s, &dmx, &dmy, b->ref, left, top, tr);

        dmx-= b->mx;

        dmy-= b->my;

        return 2*(1 + av_log2(2*FFABS(dmx)) //FIXME kill the 2* can be merged in lambda

                    + av_log2(2*FFABS(dmy))

                    + av_log2(2*b->ref));

    }

}

static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t (*obmc_edged)[MB_SIZE * 2]){

    Plane *p= &s->plane[plane_index];

    const int block_size = MB_SIZE >> s->block_max_depth;

    const int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;

    const int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;

    const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;

    const int ref_stride= s->current_picture->linesize[plane_index];

    uint8_t *dst= s->current_picture->data[plane_index];

    uint8_t *src= s->  input_picture->data[plane_index];

    IDWTELEM *pred= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4;

    uint8_t *cur = s->scratchbuf;

    uint8_t *tmp = s->emu_edge_buffer;

    const int b_stride = s->b_width << s->block_max_depth;

    const int b_height = s->b_height<< s->block_max_depth;

    const int w= p->width;

    const int h= p->height;

    int distortion;

    int rate= 0;

    const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);

    int sx= block_w*mb_x - block_w/2;

    int sy= block_h*mb_y - block_h/2;

    int x0= FFMAX(0,-sx);

    int y0= FFMAX(0,-sy);

    int x1= FFMIN(block_w*2, w-sx);

    int y1= FFMIN(block_h*2, h-sy);

    int i,x,y;

    av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below chckinhg only block_w

    ff_snow_pred_block(s, cur, tmp, ref_stride, sx, sy, block_w*2, block_h*2, &s->block[mb_x + mb_y*b_stride], plane_index, w, h);

    for(y=y0; y

        const uint8_t *obmc1= obmc_edged[y];

        const IDWTELEM *pred1 = pred + y*obmc_stride;

        uint8_t *cur1 = cur + y*ref_stride;

        uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;

        for(x=x0; x

#if FRAC_BITS >= LOG2_OBMC_MAX

            int v = (cur1[x] * obmc1[x]) << (FRAC_BITS - LOG2_OBMC_MAX);

#else

            int v = (cur1[x] * obmc1[x] + (1<<(LOG2_OBMC_MAX - FRAC_BITS-1))) >> (LOG2_OBMC_MAX - FRAC_BITS);

#endif

            v = (v + pred1[x]) >> FRAC_BITS;

            if(v&(~255)) v= ~(v>>31);

            dst1[x] = v;

        }

    }

    /* copy the regions where obmc[] = (uint8_t)256 */

    if(LOG2_OBMC_MAX == 8

        && (mb_x == 0 || mb_x == b_stride-1)

        && (mb_y == 0 || mb_y == b_height-1)){

        if(mb_x == 0)

            x1 = block_w;

        else

            x0 = block_w;

        if(mb_y == 0)

            y1 = block_h;

        else

            y0 = block_h;

        for(y=y0; y

            memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);

    }

    if(block_w==16){

        /* FIXME rearrange dsputil to fit 32x32 cmp functions */

        /* FIXME check alignment of the cmp wavelet vs the encoding wavelet */

        /* FIXME cmps overlap but do not cover the wavelet's whole support.

         * So improving the score of one block is not strictly guaranteed

         * to improve the score of the whole frame, thus iterative motion

         * estimation does not always converge. */

        if(s->avctx->me_cmp == FF_CMP_W97)

            distortion = ff_w97_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);

        else if(s->avctx->me_cmp == FF_CMP_W53)

            distortion = ff_w53_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);

        else{

            distortion = 0;

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

                int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;

                distortion += s->dsp.me_cmp[0](&s->m, src + off, dst + off, ref_stride, 16);

            }

        }

    }else{

        av_assert2(block_w==8);

        distortion = s->dsp.me_cmp[0](&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);

    }

    if(plane_index==0){

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

/* ..RRr

 * .RXx.

 * rxx..

 */

            rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);

        }

        if(mb_x == b_stride-2)

            rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);

    }

    return distortion + rate*penalty_factor;

}

static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){

    int i, y2;

    Plane *p= &s->plane[plane_index];

    const int block_size = MB_SIZE >> s->block_max_depth;

    const int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;

    const int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;

    const uint8_t *obmc  = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];

    const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;

    const int ref_stride= s->current_picture->linesize[plane_index];

    uint8_t *dst= s->current_picture->data[plane_index];

    uint8_t *src= s-> input_picture->data[plane_index];

    //FIXME zero_dst is const but add_yblock changes dst if add is 0 (this is never the case for dst=zero_dst

    // const has only been removed from zero_dst to suppress a warning

    static IDWTELEM zero_dst[4096]; //FIXME

    const int b_stride = s->b_width << s->block_max_depth;

    const int w= p->width;

    const int h= p->height;

    int distortion= 0;

    int rate= 0;

    const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);

    av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below

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

        int mb_x2= mb_x + (i%3) - 1;

        int mb_y2= mb_y + (i/3) - 1;

        int x= block_w*mb_x2 + block_w/2;

        int y= block_h*mb_y2 + block_h/2;

        add_yblock(s, 0, NULL, zero_dst, dst, obmc,

                   x, y, block_w, block_h, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);

        //FIXME find a cleaner/simpler way to skip the outside stuff

        for(y2= y; y2<0; y2++)

            memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);

        for(y2= h; y2

            memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);

        if(x<0){

            for(y2= y; y2

                memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);

        }

        if(x+block_w > w){

            for(y2= y; y2

                memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);

        }

        av_assert1(block_w== 8 || block_w==16);

        distortion += s->dsp.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);

    }

    if(plane_index==0){

        BlockNode *b= &s->block[mb_x+mb_y*b_stride];

        int merged= same_block(b,b+1) && same_block(b,b+b_stride) && same_block(b,b+b_stride+1);

/* ..RRRr

 * .RXXx.

 * .RXXx.

 * rxxx.

 */

        if(merged)

            rate = get_block_bits(s, mb_x, mb_y, 2);

        for(i=merged?4:0; i<9; i++){

            static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};

            rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);

        }

    }

    return distortion + rate*penalty_factor;

}

static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){

    const int w= b->width;

    const int h= b->height;

    int x, y;

    if(1){

        int run=0;

        int *runs = s->run_buffer;

        int run_index=0;

        int max_index;

        for(y=0; y

            for(x=0; x

                int v, p=0;

                int /*ll=0, */l=0, lt=0, t=0, rt=0;

                v= src[x + y*stride];

                if(y){

                    t= src[x + (y-1)*stride];

                    if(x){

                        lt= src[x - 1 + (y-1)*stride];

                    }

                    if(x + 1 < w){

                        rt= src[x + 1 + (y-1)*stride];

                    }

                }

                if(x){

                    l= src[x - 1 + y*stride];

                    /*if(x > 1){

                        if(orientation==1) ll= src[y + (x-2)*stride];

                        else               ll= src[x - 2 + y*stride];

                    }*/

                }

                if(parent){

                    int px= x>>1;

                    int py= y>>1;

                    if(pxparent->width && pyparent->height)

                        p= parent[px + py*2*stride];

                }

                if(!(/*ll|*/l|lt|t|rt|p)){

                    if(v){

                        runs[run_index++]= run;

                        run=0;

                    }else{

                        run++;

                    }

                }

            }

        }

        max_index= run_index;

        runs[run_index++]= run;

        run_index=0;

        run= runs[run_index++];

        put_symbol2(&s->c, b->state[30], max_index, 0);

        if(run_index <= max_index)

            put_symbol2(&s->c, b->state[1], run, 3);

        for(y=0; y

            if(s->c.bytestream_end - s->c.bytestream < w*40){

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

                return -1;

            }

            for(x=0; x

                int v, p=0;

                int /*ll=0, */l=0, lt=0, t=0, rt=0;

                v= src[x + y*stride];

                if(y){

                    t= src[x + (y-1)*stride];

                    if(x){

                        lt= src[x - 1 + (y-1)*stride];

                    }

                    if(x + 1 < w){

                        rt= src[x + 1 + (y-1)*stride];

                    }

                }

                if(x){

                    l= src[x - 1 + y*stride];

                    /*if(x > 1){

                        if(orientation==1) ll= src[y + (x-2)*stride];

                        else               ll= src[x - 2 + y*stride];

                    }*/

                }

                if(parent){

                    int px= x>>1;

                    int py= y>>1;

                    if(pxparent->width && pyparent->height)

                        p= parent[px + py*2*stride];

                }

                if(/*ll|*/l|lt|t|rt|p){

                    int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));

                    put_rac(&s->c, &b->state[0][context], !!v);

                }else{

                    if(!run){

                        run= runs[run_index++];

                        if(run_index <= max_index)

                            put_symbol2(&s->c, b->state[1], run, 3);

                        av_assert2(v);

                    }else{

                        run--;

                        av_assert2(!v);

                    }

                }

                if(v){

                    int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));

                    int l2= 2*FFABS(l) + (l<0);

                    int t2= 2*FFABS(t) + (t<0);

                    put_symbol2(&s->c, b->state[context + 2], FFABS(v)-1, context-4);

                    put_rac(&s->c, &b->state[0][16 + 1 + 3 + ff_quant3bA[l2&0xFF] + 3*ff_quant3bA[t2&0xFF]], v<0);

                }

            }

        }

    }

    return 0;

}

static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){

//    encode_subband_qtree(s, b, src, parent, stride, orientation);

//    encode_subband_z0run(s, b, src, parent, stride, orientation);

    return encode_subband_c0run(s, b, src, parent, stride, orientation);

//    encode_subband_dzr(s, b, src, parent, stride, orientation);

}

static av_always_inline int check_block(SnowContext *s, int mb_x, int mb_y, int p[3], int intra, uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd){

    const int b_stride= s->b_width << s->block_max_depth;

    BlockNode *block= &s->block[mb_x + mb_y * b_stride];

    BlockNode backup= *block;

    unsigned value;

    int rd, index;

    av_assert2(mb_x>=0 && mb_y>=0);

    av_assert2(mb_x

    if(intra){

        block->color[0] = p[0];

        block->color[1] = p[1];

        block->color[2] = p[2];

        block->type |= BLOCK_INTRA;

    }else{

        index= (p[0] + 31*p[1]) & (ME_CACHE_SIZE-1);

        value= s->me_cache_generation + (p[0]>>10) + (p[1]<<6) + (block->ref<<12);

        if(s->me_cache[index] == value)

            return 0;

        s->me_cache[index]= value;

        block->mx= p[0];

        block->my= p[1];

        block->type &= ~BLOCK_INTRA;

    }

    rd= get_block_rd(s, mb_x, mb_y, 0, obmc_edged);

//FIXME chroma

    if(rd < *best_rd){

        *best_rd= rd;

        return 1;

    }else{

        *block= backup;

        return 0;

    }

}

/* special case for int[2] args we discard afterwards,

 * fixes compilation problem with gcc 2.95 */

static av_always_inline int check_block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd){

    int p[2] = {p0, p1};

    return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);

}

static av_always_inline int check_4block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, int ref, int *best_rd){

    const int b_stride= s->b_width << s->block_max_depth;

    BlockNode *block= &s->block[mb_x + mb_y * b_stride];

    BlockNode backup[4];

    unsigned value;

    int rd, index;

    /* We don't initialize backup[] during variable declaration, because

     * that fails to compile on MSVC: "cannot convert from 'BlockNode' to

     * 'int16_t'". */

    backup[0] = block[0];

    backup[1] = block[1];

    backup[2] = block[b_stride];

    backup[3] = block[b_stride + 1];

    av_assert2(mb_x>=0 && mb_y>=0);

    av_assert2(mb_x

    av_assert2(((mb_x|mb_y)&1) == 0);

    index= (p0 + 31*p1) & (ME_CACHE_SIZE-1);

    value= s->me_cache_generation + (p0>>10) + (p1<<6) + (block->ref<<12);

    if(s->me_cache[index] == value)

        return 0;

    s->me_cache[index]= value;

    block->mx= p0;

    block->my= p1;

    block->ref= ref;

    block->type &= ~BLOCK_INTRA;

    block[1]= block[b_stride]= block[b_stride+1]= *block;

    rd= get_4block_rd(s, mb_x, mb_y, 0);

//FIXME chroma

    if(rd < *best_rd){

        *best_rd= rd;

        return 1;

    }else{

        block[0]= backup[0];

        block[1]= backup[1];

        block[b_stride]= backup[2];

        block[b_stride+1]= backup[3];

        return 0;

    }

}

static void iterative_me(SnowContext *s){

    int pass, mb_x, mb_y;

    const int b_width = s->b_width  << s->block_max_depth;

    const int b_height= s->b_height << s->block_max_depth;

    const int b_stride= b_width;

    int color[3];

    {

        RangeCoder r = s->c;

        uint8_t state[sizeof(s->block_state)];

        memcpy(state, s->block_state, sizeof(s->block_state));

        for(mb_y= 0; mb_yb_height; mb_y++)

            for(mb_x= 0; mb_xb_width; mb_x++)

                encode_q_branch(s, 0, mb_x, mb_y);

        s->c = r;

        memcpy(s->block_state, state, sizeof(s->block_state));

    }

    for(pass=0; pass<25; pass++){

        int change= 0;

        for(mb_y= 0; mb_y

            for(mb_x= 0; mb_x

                int dia_change, i, j, ref;

                int best_rd= INT_MAX, ref_rd;

                BlockNode backup, ref_b;

                const int index= mb_x + mb_y * b_stride;

                BlockNode *block= &s->block[index];

                BlockNode *tb =                   mb_y            ? &s->block[index-b_stride  ] : NULL;

                BlockNode *lb = mb_x                              ? &s->block[index         -1] : NULL;

                BlockNode *rb = mb_x+1block[index         +1] : NULL;

                BlockNode *bb =                   mb_y+1block[index+b_stride  ] : NULL;

                BlockNode *tlb= mb_x           && mb_y            ? &s->block[index-b_stride-1] : NULL;

                BlockNode *trb= mb_x+1block[index-b_stride+1] : NULL;

                BlockNode *blb= mb_x           && mb_y+1block[index+b_stride-1] : NULL;

                BlockNode *brb= mb_x+1block[index+b_stride+1] : NULL;

                const int b_w= (MB_SIZE >> s->block_max_depth);

                uint8_t obmc_edged[MB_SIZE * 2][MB_SIZE * 2];

                if(pass && (block->type & BLOCK_OPT))

                    continue;

                block->type |= BLOCK_OPT;

                backup= *block;

                if(!s->me_cache_generation)

                    memset(s->me_cache, 0, sizeof(s->me_cache));

                s->me_cache_generation += 1<<22;

                //FIXME precalculate

                {

                    int x, y;

                    for (y = 0; y < b_w * 2; y++)

                        memcpy(obmc_edged[y], ff_obmc_tab[s->block_max_depth] + y * b_w * 2, b_w * 2);

                    if(mb_x==0)

                        for(y=0; y

                            memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);

                    if(mb_x==b_stride-1)

                        for(y=0; y

                            memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);

                    if(mb_y==0){

                        for(x=0; x

                            obmc_edged[0][x] += obmc_edged[b_w-1][x];

                        for(y=1; y

                            memcpy(obmc_edged[y], obmc_edged[0], b_w*2);

                    }

                    if(mb_y==b_height-1){

                        for(x=0; x

                            obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];

                        for(y=b_w; y

                            memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);

                    }

                }

                //skip stuff outside the picture

                if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){

                    uint8_t *src= s->  input_picture->data[0];

                    uint8_t *dst= s->current_picture->data[0];

                    const int stride= s->current_picture->linesize[0];

                    const int block_w= MB_SIZE >> s->block_max_depth;

                    const int block_h= MB_SIZE >> s->block_max_depth;

                    const int sx= block_w*mb_x - block_w/2;

                    const int sy= block_h*mb_y - block_h/2;

                    const int w= s->plane[0].width;

                    const int h= s->plane[0].height;

                    int y;

                    for(y=sy; y<0; y++)

                        memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);

                    for(y=h; y

                        memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);

                    if(sx<0){

                        for(y=sy; y

                            memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);

                    }

                    if(sx+block_w*2 > w){

                        for(y=sy; y

                            memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);

                    }

                }

                // intra(black) = neighbors' contribution to the current block

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

                    color[i]= get_dc(s, mb_x, mb_y, i);

                // get previous score (cannot be cached due to OBMC)

                if(pass > 0 && (block->type&BLOCK_INTRA)){

                    int color0[3]= {block->color[0], block->color[1], block->color[2]};

                    check_block(s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);

                }else

                    check_block_inter(s, mb_x, mb_y, block->mx, block->my, obmc_edged, &best_rd);

                ref_b= *block;

                ref_rd= best_rd;

                for(ref=0; ref < s->ref_frames; ref++){

                    int16_t (*mvr)[2]= &s->ref_mvs[ref][index];

                    if(s->ref_scores[ref][index] > s->ref_scores[ref_b.ref][index]*3/2) //FIXME tune threshold

                        continue;

                    block->ref= ref;

                    best_rd= INT_MAX;

                    check_block_inter(s, mb_x, mb_y, mvr[0][0], mvr[0][1], obmc_edged, &best_rd);

                    check_block_inter(s, mb_x, mb_y, 0, 0, obmc_edged, &best_rd);

                    if(tb)

                        check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);

                    if(lb)

                        check_block_inter(s, mb_x, mb_y, mvr[-1][0], mvr[-1][1], obmc_edged, &best_rd);

                    if(rb)

                        check_block_inter(s, mb_x, mb_y, mvr[1][0], mvr[1][1], obmc_edged, &best_rd);

                    if(bb)

                        check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);

                    /* fullpel ME */

                    //FIXME avoid subpel interpolation / round to nearest integer

                    do{

                        dia_change=0;

                        for(i=0; iavctx->dia_size, 1); i++){