X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fmotion_est_template.c;h=7228744756bd1f89ff59a26f54a7b9d8381faf68;hb=6a8475dc4f10d65edb7faa8df6e035af0ddcce19;hp=45b23ce173e8fdba358a5dcd29b1341a8c7cc9b6;hpb=1457ab523343e94e094ad1c60de37077f8dc5589;p=ffmpeg diff --git a/libavcodec/motion_est_template.c b/libavcodec/motion_est_template.c index 45b23ce173e..7228744756b 100644 --- a/libavcodec/motion_est_template.c +++ b/libavcodec/motion_est_template.c @@ -1,184 +1,107 @@ /* - * Motion estimation - * Copyright (c) 2002 Michael Niedermayer + * Motion estimation + * Copyright (c) 2002-2004 Michael Niedermayer * - * This library is free software; you can redistribute it and/or + * This file is part of Libav. + * + * Libav 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 of the License, or (at your option) any later version. + * version 2.1 of the License, or (at your option) any later version. * - * This library is distributed in the hope that it will be useful, + * Libav 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 this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with Libav; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -//lets hope gcc will remove the unused vars ...(gcc 3.2.2 seems to do it ...) -//Note, the last line is there to kill these ugly unused var warnings -#define LOAD_COMMON(x, y)\ - uint32_t * const score_map= s->me.score_map;\ - const int stride= s->linesize;\ - const int uvstride= s->uvlinesize;\ - const int time_pp= s->pp_time;\ - const int time_pb= s->pb_time;\ - uint8_t * const src_y= s->new_picture.data[0] + ((y) * stride) + (x);\ - uint8_t * const src_u= s->new_picture.data[1] + (((y)>>1) * uvstride) + ((x)>>1);\ - uint8_t * const src_v= s->new_picture.data[2] + (((y)>>1) * uvstride) + ((x)>>1);\ - uint8_t * const ref_y= ref_picture->data[0] + ((y) * stride) + (x);\ - uint8_t * const ref_u= ref_picture->data[1] + (((y)>>1) * uvstride) + ((x)>>1);\ - uint8_t * const ref_v= ref_picture->data[2] + (((y)>>1) * uvstride) + ((x)>>1);\ - uint8_t * const ref2_y= s->next_picture.data[0] + ((y) * stride) + (x);\ - op_pixels_func (*hpel_put)[4];\ - op_pixels_func (*hpel_avg)[4]= &s->dsp.avg_pixels_tab[size];\ - op_pixels_func (*chroma_hpel_put)[4];\ - qpel_mc_func (*qpel_put)[16];\ - qpel_mc_func (*qpel_avg)[16]= &s->dsp.avg_qpel_pixels_tab[size];\ - const __attribute__((unused)) int unu= time_pp + time_pb + (int)src_u + (int)src_v + (int)ref_u + (int)ref_v\ - + (int)ref2_y + (int)hpel_avg + (int)qpel_avg;\ - if(s->no_rounding /*FIXME b_type*/){\ - hpel_put= &s->dsp.put_no_rnd_pixels_tab[size];\ - chroma_hpel_put= &s->dsp.put_no_rnd_pixels_tab[size+1];\ - qpel_put= &s->dsp.put_no_rnd_qpel_pixels_tab[size];\ - }else{\ - hpel_put=& s->dsp.put_pixels_tab[size];\ - chroma_hpel_put= &s->dsp.put_pixels_tab[size+1];\ - qpel_put= &s->dsp.put_qpel_pixels_tab[size];\ - } +/** + * @file + * Motion estimation template. + */ +//Let us hope gcc will remove the unused vars ...(gcc 3.2.2 seems to do it ...) +#define LOAD_COMMON\ + uint32_t av_unused * const score_map= c->score_map;\ + const int av_unused xmin= c->xmin;\ + const int av_unused ymin= c->ymin;\ + const int av_unused xmax= c->xmax;\ + const int av_unused ymax= c->ymax;\ + uint8_t *mv_penalty= c->current_mv_penalty;\ + const int pred_x= c->pred_x;\ + const int pred_y= c->pred_y;\ -#ifdef CMP_HPEL - #define CHECK_HALF_MV(dx, dy, x, y)\ {\ const int hx= 2*(x)+(dx);\ const int hy= 2*(y)+(dy);\ - CMP_HPEL(d, dx, dy, x, y, size);\ + d= cmp_hpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);\ d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\ COPY3_IF_LT(dmin, d, bx, hx, by, hy)\ } -#if 0 -static int RENAME(hpel_motion_search)(MpegEncContext * s, - int *mx_ptr, int *my_ptr, int dmin, - int xmin, int ymin, int xmax, int ymax, - int pred_x, int pred_y, Picture *ref_picture, - int n, int size) +static int hpel_motion_search(MpegEncContext * s, + int *mx_ptr, int *my_ptr, int dmin, + int src_index, int ref_index, + int size, int h) { - UINT8 *ptr; - - const int xx = 16 * s->mb_x + 8*(n&1); - const int yy = 16 * s->mb_y + 8*(n>>1); + MotionEstContext * const c= &s->me; const int mx = *mx_ptr; const int my = *my_ptr; - - LOAD_COMMON(xx, yy); - - // INIT; - //FIXME factorize - me_cmp_func cmp, chroma_cmp, cmp_sub, chroma_cmp_sub; - - if(s->no_rounding /*FIXME b_type*/){ - hpel_put= &s->dsp.put_no_rnd_pixels_tab[size]; - chroma_hpel_put= &s->dsp.put_no_rnd_pixels_tab[size+1]; - }else{ - hpel_put=& s->dsp.put_pixels_tab[size]; - chroma_hpel_put= &s->dsp.put_pixels_tab[size+1]; - } - cmp= s->dsp.me_cmp[size]; - chroma_cmp= s->dsp.me_cmp[size+1]; - cmp_sub= s->dsp.me_sub_cmp[size]; - chroma_cmp_sub= s->dsp.me_sub_cmp[size+1]; - - if(s->me.skip){ //FIXME somehow move up (benchmark) - *mx_ptr = 0; - *my_ptr = 0; - return dmin; - } - - if(s->avctx->me_cmp != s->avctx->me_sub_cmp){ - CMP_HPEL(dmin, 0, 0, mx, my, size); - if(mx || my) - dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor; - } - - if (mx > xmin && mx < xmax && - my > ymin && my < ymax) { - int bx=2*mx, by=2*my; - int d= dmin; - - CHECK_HALF_MV(1, 1, mx-1, my-1) - CHECK_HALF_MV(0, 1, mx , my-1) - CHECK_HALF_MV(1, 1, mx , my-1) - CHECK_HALF_MV(1, 0, mx-1, my ) - CHECK_HALF_MV(1, 0, mx , my ) - CHECK_HALF_MV(1, 1, mx-1, my ) - CHECK_HALF_MV(0, 1, mx , my ) - CHECK_HALF_MV(1, 1, mx , my ) - - assert(bx < xmin*2 || bx > xmax*2 || by < ymin*2 || by > ymax*2); - - *mx_ptr = bx; - *my_ptr = by; - }else{ - *mx_ptr =2*mx; - *my_ptr =2*my; - } - - return dmin; -} - -#else -static int RENAME(hpel_motion_search)(MpegEncContext * s, - int *mx_ptr, int *my_ptr, int dmin, - int xmin, int ymin, int xmax, int ymax, - int pred_x, int pred_y, Picture *ref_picture, - int n, int size, uint16_t * const mv_penalty) -{ - const int xx = 16 * s->mb_x + 8*(n&1); - const int yy = 16 * s->mb_y + 8*(n>>1); - const int mx = *mx_ptr; - const int my = *my_ptr; - const int penalty_factor= s->me.sub_penalty_factor; + const int penalty_factor= c->sub_penalty_factor; me_cmp_func cmp_sub, chroma_cmp_sub; + int bx=2*mx, by=2*my; + + LOAD_COMMON + int flags= c->sub_flags; - LOAD_COMMON(xx, yy); - //FIXME factorize cmp_sub= s->dsp.me_sub_cmp[size]; chroma_cmp_sub= s->dsp.me_sub_cmp[size+1]; - if(s->me.skip){ //FIXME move out of hpel? + if(c->skip){ //FIXME move out of hpel? *mx_ptr = 0; *my_ptr = 0; return dmin; } - - if(s->avctx->me_cmp != s->avctx->me_sub_cmp){ - CMP_HPEL(dmin, 0, 0, mx, my, size); - if(mx || my) + + if(c->avctx->me_cmp != c->avctx->me_sub_cmp){ + dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags); + if(mx || my || size>0) dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor; } - - if (mx > xmin && mx < xmax && + + if (mx > xmin && mx < xmax && my > ymin && my < ymax) { - int bx=2*mx, by=2*my; int d= dmin; const int index= (my<penalty_factor; const int l= score_map[(index- 1 )&(ME_MAP_SIZE-1)] - + (mv_penalty[bx-2 - pred_x] + mv_penalty[by - pred_y])*penalty_factor; + + (mv_penalty[bx-2 - pred_x] + mv_penalty[by - pred_y])*c->penalty_factor; const int r= score_map[(index+ 1 )&(ME_MAP_SIZE-1)] - + (mv_penalty[bx+2 - pred_x] + mv_penalty[by - pred_y])*penalty_factor; + + (mv_penalty[bx+2 - pred_x] + mv_penalty[by - pred_y])*c->penalty_factor; const int b= score_map[(index+(1<penalty_factor; + + unsigned key; + unsigned map_generation= c->map_generation; +#ifndef NDEBUG + uint32_t *map= c->map; +#endif + key= ((my-1)<= xmin*2 && bx <= xmax*2 && by >= ymin*2 && by <= ymax*2); - - *mx_ptr = bx; - *my_ptr = by; - }else{ - *mx_ptr =2*mx; - *my_ptr =2*my; } + *mx_ptr = bx; + *my_ptr = by; + return dmin; } -#endif -#endif /* CMP_HPEL */ +static int no_sub_motion_search(MpegEncContext * s, + int *mx_ptr, int *my_ptr, int dmin, + int src_index, int ref_index, + int size, int h) +{ + (*mx_ptr)<<=1; + (*my_ptr)<<=1; + return dmin; +} + +static inline int get_mb_score(MpegEncContext *s, int mx, int my, + int src_index, int ref_index, int size, + int h, int add_rate) +{ +// const int check_luma= s->dsp.me_sub_cmp != s->dsp.mb_cmp; + MotionEstContext * const c= &s->me; + const int penalty_factor= c->mb_penalty_factor; + const int flags= c->mb_flags; + const int qpel= flags & FLAG_QPEL; + const int mask= 1+2*qpel; + me_cmp_func cmp_sub, chroma_cmp_sub; + int d; + + LOAD_COMMON -#ifdef CMP_QPEL + //FIXME factorize + + cmp_sub= s->dsp.mb_cmp[size]; + chroma_cmp_sub= s->dsp.mb_cmp[size+1]; + +// assert(!c->skip); +// assert(c->avctx->me_sub_cmp != c->avctx->mb_cmp); + + d= cmp(s, mx>>(qpel+1), my>>(qpel+1), mx&mask, my&mask, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags); + //FIXME check cbp before adding penalty for (0,0) vector + if(add_rate && (mx || my || size>0)) + d += (mv_penalty[mx - pred_x] + mv_penalty[my - pred_y])*penalty_factor; + + return d; +} + +int ff_get_mb_score(MpegEncContext *s, int mx, int my, int src_index, + int ref_index, int size, int h, int add_rate) +{ + return get_mb_score(s, mx, my, src_index, ref_index, size, h, add_rate); +} #define CHECK_QUARTER_MV(dx, dy, x, y)\ {\ const int hx= 4*(x)+(dx);\ const int hy= 4*(y)+(dy);\ - CMP_QPEL(d, dx, dy, x, y, size);\ + d= cmp_qpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\ d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\ COPY3_IF_LT(dmin, d, bx, hx, by, hy)\ } -static int RENAME(qpel_motion_search)(MpegEncContext * s, - int *mx_ptr, int *my_ptr, int dmin, - int xmin, int ymin, int xmax, int ymax, - int pred_x, int pred_y, Picture *ref_picture, - int n, int size, uint16_t * const mv_penalty) +static int qpel_motion_search(MpegEncContext * s, + int *mx_ptr, int *my_ptr, int dmin, + int src_index, int ref_index, + int size, int h) { - const int xx = 16 * s->mb_x + 8*(n&1); - const int yy = 16 * s->mb_y + 8*(n>>1); + MotionEstContext * const c= &s->me; const int mx = *mx_ptr; - const int my = *my_ptr; - const int penalty_factor= s->me.sub_penalty_factor; - const int map_generation= s->me.map_generation; - uint32_t *map= s->me.map; - me_cmp_func cmp, chroma_cmp; + const int my = *my_ptr; + const int penalty_factor= c->sub_penalty_factor; + const unsigned map_generation = c->map_generation; + const int subpel_quality= c->avctx->me_subpel_quality; + uint32_t *map= c->map; + me_cmp_func cmpf, chroma_cmpf; me_cmp_func cmp_sub, chroma_cmp_sub; - LOAD_COMMON(xx, yy); - - cmp= s->dsp.me_cmp[size]; - chroma_cmp= s->dsp.me_cmp[size+1]; //factorize FIXME + LOAD_COMMON + int flags= c->sub_flags; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; //factorize FIXME //FIXME factorize cmp_sub= s->dsp.me_sub_cmp[size]; chroma_cmp_sub= s->dsp.me_sub_cmp[size+1]; - if(s->me.skip){ //FIXME somehow move up (benchmark) + if(c->skip){ //FIXME somehow move up (benchmark) *mx_ptr = 0; *my_ptr = 0; return dmin; } - - if(s->avctx->me_cmp != s->avctx->me_sub_cmp){ - CMP_QPEL(dmin, 0, 0, mx, my, size); - if(mx || my) + + if(c->avctx->me_cmp != c->avctx->me_sub_cmp){ + dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags); + if(mx || my || size>0) dmin += (mv_penalty[4*mx - pred_x] + mv_penalty[4*my - pred_y])*penalty_factor; } - - if (mx > xmin && mx < xmax && + + if (mx > xmin && mx < xmax && my > ymin && my < ymax) { int bx=4*mx, by=4*my; int d= dmin; @@ -294,10 +256,9 @@ static int RENAME(qpel_motion_search)(MpegEncContext * s, const int c= score_map[(index )&(ME_MAP_SIZE-1)]; int best[8]; int best_pos[8][2]; - + memset(best, 64, sizeof(int)*8); -#if 1 - if(s->avctx->dia_size>=2){ + if(s->me.dia_size>=2){ const int tl= score_map[(index-(1<>10; int i; - + if((nx&3)==0 && (ny&3)==0) continue; - - score += 1024*(mv_penalty[4*mx + nx - pred_x] + mv_penalty[4*my + ny - pred_y])*penalty_factor; - -// if(nx&1) score-=1024*s->me.penalty_factor; -// if(ny&1) score-=1024*s->me.penalty_factor; - + + score += (mv_penalty[4*mx + nx - pred_x] + mv_penalty[4*my + ny - pred_y])*penalty_factor; + +// if(nx&1) score-=1024*c->penalty_factor; +// if(ny&1) score-=1024*c->penalty_factor; + for(i=0; i<8; i++){ if(score < best[i]){ memmove(&best[i+1], &best[i], sizeof(int)*(7-i)); @@ -332,37 +294,39 @@ static int RENAME(qpel_motion_search)(MpegEncContext * s, } }else{ int tl; + //FIXME this could overflow (unlikely though) const int cx = 4*(r - l); - const int cx2= r + l - 2*c; + const int cx2= r + l - 2*c; const int cy = 4*(b - t); const int cy2= b + t - 2*c; int cxy; - + if(map[(index-(1<me.penalty_factor; - // if(ny&1) score-=32*s->me.penalty_factor; - +// if(nx&1) score-=32*c->penalty_factor; + // if(ny&1) score-=32*c->penalty_factor; + for(i=0; i<8; i++){ if(score < best[i]){ memmove(&best[i+1], &best[i], sizeof(int)*(7-i)); @@ -374,74 +338,14 @@ static int RENAME(qpel_motion_search)(MpegEncContext * s, } } } - } + } } - for(i=0; i<8; i++){ + for(i=0; i>2, ny>>2) } -#if 0 - nx= FFMAX(4*mx - bx, bx - 4*mx); - ny= FFMAX(4*my - by, by - 4*my); - - static int stats[4][4]; - stats[nx][ny]++; - if(256*256*256*64 % (stats[0][0]+1) ==0){ - for(i=0; i<16; i++){ - if((i&3)==0) printf("\n"); - printf("%6d ", stats[0][i]); - } - printf("\n"); - } -#endif -#else - - CHECK_QUARTER_MV(2, 2, mx-1, my-1) - CHECK_QUARTER_MV(0, 2, mx , my-1) - CHECK_QUARTER_MV(2, 2, mx , my-1) - CHECK_QUARTER_MV(2, 0, mx , my ) - CHECK_QUARTER_MV(2, 2, mx , my ) - CHECK_QUARTER_MV(0, 2, mx , my ) - CHECK_QUARTER_MV(2, 2, mx-1, my ) - CHECK_QUARTER_MV(2, 0, mx-1, my ) - - nx= bx; - ny= by; - - for(i=0; i<8; i++){ - int ox[8]= {0, 1, 1, 1, 0,-1,-1,-1}; - int oy[8]= {1, 1, 0,-1,-1,-1, 0, 1}; - CHECK_QUARTER_MV((nx + ox[i])&3, (ny + oy[i])&3, (nx + ox[i])>>2, (ny + oy[i])>>2) - } -#endif -#if 0 - //outer ring - CHECK_QUARTER_MV(1, 3, mx-1, my-1) - CHECK_QUARTER_MV(1, 2, mx-1, my-1) - CHECK_QUARTER_MV(1, 1, mx-1, my-1) - CHECK_QUARTER_MV(2, 1, mx-1, my-1) - CHECK_QUARTER_MV(3, 1, mx-1, my-1) - CHECK_QUARTER_MV(0, 1, mx , my-1) - CHECK_QUARTER_MV(1, 1, mx , my-1) - CHECK_QUARTER_MV(2, 1, mx , my-1) - CHECK_QUARTER_MV(3, 1, mx , my-1) - CHECK_QUARTER_MV(3, 2, mx , my-1) - CHECK_QUARTER_MV(3, 3, mx , my-1) - CHECK_QUARTER_MV(3, 0, mx , my ) - CHECK_QUARTER_MV(3, 1, mx , my ) - CHECK_QUARTER_MV(3, 2, mx , my ) - CHECK_QUARTER_MV(3, 3, mx , my ) - CHECK_QUARTER_MV(2, 3, mx , my ) - CHECK_QUARTER_MV(1, 3, mx , my ) - CHECK_QUARTER_MV(0, 3, mx , my ) - CHECK_QUARTER_MV(3, 3, mx-1, my ) - CHECK_QUARTER_MV(2, 3, mx-1, my ) - CHECK_QUARTER_MV(1, 3, mx-1, my ) - CHECK_QUARTER_MV(1, 2, mx-1, my ) - CHECK_QUARTER_MV(1, 1, mx-1, my ) - CHECK_QUARTER_MV(1, 0, mx-1, my ) -#endif + assert(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4); *mx_ptr = bx; @@ -454,14 +358,17 @@ static int RENAME(qpel_motion_search)(MpegEncContext * s, return dmin; } -#endif /* CMP_QPEL */ #define CHECK_MV(x,y)\ {\ - const int key= ((y)<= xmin);\ + assert((x) <= xmax);\ + assert((y) >= ymin);\ + assert((y) <= ymax);\ if(map[index]!=key){\ - CMP(d, x, y, size);\ + d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\ map[index]= key;\ score_map[index]= d;\ d += (mv_penalty[((x)<(xmax<<(S)) ) printf("%d %d %d %d %d xmax" #v, xmax, (x), (y), s->mb_x, if( (y)<(ymin<<(S)) ) printf("%d %d %d %d %d ymin" #v, ymin, (x), (y), s->mb_x, s->mb_y);\ if( (y)>(ymax<<(S)) ) printf("%d %d %d %d %d ymax" #v, ymax, (x), (y), s->mb_x, s->mb_y);\ +#define LOAD_COMMON2\ + uint32_t *map= c->map;\ + const int qpel= flags&FLAG_QPEL;\ + const int shift= 1+qpel;\ -static inline int RENAME(small_diamond_search)(MpegEncContext * s, int *best, int dmin, - Picture *ref_picture, - int const pred_x, int const pred_y, int const penalty_factor, - int const xmin, int const ymin, int const xmax, int const ymax, int const shift, - uint32_t *map, int map_generation, int size, uint16_t * const mv_penalty - ) +static av_always_inline int small_diamond_search(MpegEncContext * s, int *best, int dmin, + int src_index, int ref_index, int const penalty_factor, + int size, int h, int flags) { - me_cmp_func cmp, chroma_cmp; + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; int next_dir=-1; - LOAD_COMMON(s->mb_x*16, s->mb_y*16); - - cmp= s->dsp.me_cmp[size]; - chroma_cmp= s->dsp.me_cmp[size+1]; + LOAD_COMMON + LOAD_COMMON2 + unsigned map_generation = c->map_generation; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + { /* ensure that the best point is in the MAP as h/qpel refinement needs it */ + const unsigned key = (best[1]<xmin) CHECK_MV_DIR(x-1, y , 0) if(dir!=3 && y>ymin) CHECK_MV_DIR(x , y-1, 1) if(dir!=0 && xmb_x*16, s->mb_y*16); - - cmp= s->dsp.me_cmp[size]; - chroma_cmp= s->dsp.me_cmp[size+1]; - - for(dia_size=1; dia_size<=s->avctx->dia_size; dia_size++){ + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; + int dia_size; + LOAD_COMMON + LOAD_COMMON2 + unsigned map_generation = c->map_generation; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + for(dia_size=1; dia_size<=4; dia_size++){ + int dir; + const int x= best[0]; + const int y= best[1]; + + if(dia_size&(dia_size-1)) continue; + + if( x + dia_size > xmax + || x - dia_size < xmin + || y + dia_size > ymax + || y - dia_size < ymin) + continue; + + for(dir= 0; dirme; + me_cmp_func cmpf, chroma_cmpf; + LOAD_COMMON + LOAD_COMMON2 + unsigned map_generation = c->map_generation; + int x,y,d; + const int dec= dia_size & (dia_size-1); + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){ + do{ + x= best[0]; + y= best[1]; + + CHECK_CLIPPED_MV(x -dia_size , y); + CHECK_CLIPPED_MV(x+ dia_size , y); + CHECK_CLIPPED_MV(x+( dia_size>>1), y+dia_size); + CHECK_CLIPPED_MV(x+( dia_size>>1), y-dia_size); + if(dia_size>1){ + CHECK_CLIPPED_MV(x+(-dia_size>>1), y+dia_size); + CHECK_CLIPPED_MV(x+(-dia_size>>1), y-dia_size); + } + }while(best[0] != x || best[1] != y); + } + + return dmin; +} + +static int l2s_dia_search(MpegEncContext * s, int *best, int dmin, + int src_index, int ref_index, int const penalty_factor, + int size, int h, int flags) +{ + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; + LOAD_COMMON + LOAD_COMMON2 + unsigned map_generation = c->map_generation; + int x,y,i,d; + int dia_size= c->dia_size&0xFF; + const int dec= dia_size & (dia_size-1); + static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1}, + { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}}; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){ + do{ + x= best[0]; + y= best[1]; + for(i=0; i<8; i++){ + CHECK_CLIPPED_MV(x+hex[i][0]*dia_size, y+hex[i][1]*dia_size); + } + }while(best[0] != x || best[1] != y); + } + + x= best[0]; + y= best[1]; + CHECK_CLIPPED_MV(x+1, y); + CHECK_CLIPPED_MV(x, y+1); + CHECK_CLIPPED_MV(x-1, y); + CHECK_CLIPPED_MV(x, y-1); + + return dmin; +} + +static int umh_search(MpegEncContext * s, int *best, int dmin, + int src_index, int ref_index, int const penalty_factor, + int size, int h, int flags) +{ + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; + LOAD_COMMON + LOAD_COMMON2 + unsigned map_generation = c->map_generation; + int x,y,x2,y2, i, j, d; + const int dia_size= c->dia_size&0xFE; + static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2}, + { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2}, + {-2, 3}, { 0, 4}, { 2, 3}, + {-2,-3}, { 0,-4}, { 2,-3},}; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + x= best[0]; + y= best[1]; + for(x2=FFMAX(x-dia_size+1, xmin); x2<=FFMIN(x+dia_size-1,xmax); x2+=2){ + CHECK_MV(x2, y); + } + for(y2=FFMAX(y-dia_size/2+1, ymin); y2<=FFMIN(y+dia_size/2-1,ymax); y2+=2){ + CHECK_MV(x, y2); + } + + x= best[0]; + y= best[1]; + for(y2=FFMAX(y-2, ymin); y2<=FFMIN(y+2,ymax); y2++){ + for(x2=FFMAX(x-2, xmin); x2<=FFMIN(x+2,xmax); x2++){ + CHECK_MV(x2, y2); + } + } + +//FIXME prevent the CLIP stuff + + for(j=1; j<=dia_size/4; j++){ + for(i=0; i<16; i++){ + CHECK_CLIPPED_MV(x+hex[i][0]*j, y+hex[i][1]*j); + } + } + + return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2); +} + +static int full_search(MpegEncContext * s, int *best, int dmin, + int src_index, int ref_index, int const penalty_factor, + int size, int h, int flags) +{ + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; + LOAD_COMMON + LOAD_COMMON2 + unsigned map_generation = c->map_generation; + int x,y, d; + const int dia_size= c->dia_size&0xFF; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + for(y=FFMAX(-dia_size, ymin); y<=FFMIN(dia_size,ymax); y++){ + for(x=FFMAX(-dia_size, xmin); x<=FFMIN(dia_size,xmax); x++){ + CHECK_MV(x, y); + } + } + + x= best[0]; + y= best[1]; + d= dmin; + CHECK_CLIPPED_MV(x , y); + CHECK_CLIPPED_MV(x+1, y); + CHECK_CLIPPED_MV(x, y+1); + CHECK_CLIPPED_MV(x-1, y); + CHECK_CLIPPED_MV(x, y-1); + best[0]= x; + best[1]= y; + + return d; +} + +#define SAB_CHECK_MV(ax,ay)\ +{\ + const unsigned key = ((ay)<= minima[j].height) j++;\ +\ + memmove(&minima [j+1], &minima [j], (minima_count - j - 1)*sizeof(Minima));\ +\ + minima[j].checked= 0;\ + minima[j].height= d;\ + minima[j].x= ax;\ + minima[j].y= ay;\ + \ + i=-1;\ + continue;\ + }\ + }\ +} + +#define MAX_SAB_SIZE ME_MAP_SIZE +static int sab_diamond_search(MpegEncContext * s, int *best, int dmin, + int src_index, int ref_index, int const penalty_factor, + int size, int h, int flags) +{ + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; + Minima minima[MAX_SAB_SIZE]; + const int minima_count= FFABS(c->dia_size); + int i, j; + LOAD_COMMON + LOAD_COMMON2 + unsigned map_generation = c->map_generation; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + /*Note j>=ME_MAP_MV_BITS; + minima[j].y= key & ((1< xmax || minima[j].x < xmin + || minima[j].y > ymax || minima[j].y < ymin) + continue; + + minima[j].checked=0; + if(minima[j].x || minima[j].y) + minima[j].height+= (mv_penalty[((minima[j].x)<= xmax || x <= xmin + || y >= ymax || y <= ymin) + continue; + + SAB_CHECK_MV(x-1, y) + SAB_CHECK_MV(x+1, y) + SAB_CHECK_MV(x , y-1) + SAB_CHECK_MV(x , y+1) + + minima[i].checked= 1; + } + + best[0]= minima[0].x; + best[1]= minima[0].y; + dmin= minima[0].height; + + if( best[0] < xmax && best[0] > xmin + && best[1] < ymax && best[1] > ymin){ + int d; + //ensure that the refernece samples for hpel refinement are in the map + CHECK_MV(best[0]-1, best[1]) + CHECK_MV(best[0]+1, best[1]) + CHECK_MV(best[0], best[1]-1) + CHECK_MV(best[0], best[1]+1) + } + return dmin; +} + +static int var_diamond_search(MpegEncContext * s, int *best, int dmin, + int src_index, int ref_index, int const penalty_factor, + int size, int h, int flags) +{ + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; + int dia_size; + LOAD_COMMON + LOAD_COMMON2 + unsigned map_generation = c->map_generation; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + for(dia_size=1; dia_size<=c->dia_size; dia_size++){ int dir, start, end; const int x= best[0]; const int y= best[1]; start= FFMAX(0, y + dia_size - ymax); - end = FFMIN(dia_size, xmax - x); + end = FFMIN(dia_size, xmax - x + 1); for(dir= start; dirme; + if(c->dia_size==-1) + return funny_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + else if(c->dia_size<-1) + return sab_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + else if(c->dia_size<2) + return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + else if(c->dia_size>1024) + return full_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + else if(c->dia_size>768) + return umh_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + else if(c->dia_size>512) + return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, c->dia_size&0xFF); + else if(c->dia_size>256) + return l2s_dia_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + else + return var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); } -static int RENAME(epzs_motion_search)(MpegEncContext * s, int block, - int *mx_ptr, int *my_ptr, - int P[10][2], int pred_x, int pred_y, - int xmin, int ymin, int xmax, int ymax, Picture *ref_picture, uint16_t * const mv_penalty) +/** + @param P a list of candidate mvs to check before starting the + iterative search. If one of the candidates is close to the optimal mv, then + it takes fewer iterations. And it increases the chance that we find the + optimal mv. + */ +static av_always_inline int epzs_motion_search_internal(MpegEncContext * s, int *mx_ptr, int *my_ptr, + int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2], + int ref_mv_scale, int flags, int size, int h) { - int best[2]={0, 0}; - int d, dmin; - const int shift= 1+s->quarter_sample; - uint32_t *map= s->me.map; - int map_generation; - const int penalty_factor= s->me.penalty_factor; - const int size=0; - me_cmp_func cmp, chroma_cmp; - LOAD_COMMON(s->mb_x*16, s->mb_y*16); - - cmp= s->dsp.me_cmp[size]; - chroma_cmp= s->dsp.me_cmp[size+1]; - - map_generation= update_map_generation(s); - - CMP(dmin, 0, 0, size); + MotionEstContext * const c= &s->me; + int best[2]={0, 0}; /**< x and y coordinates of the best motion vector. + i.e. the difference between the position of the + block currently being encoded and the position of + the block chosen to predict it from. */ + int d; ///< the score (cmp + penalty) of any given mv + int dmin; /**< the best value of d, i.e. the score + corresponding to the mv stored in best[]. */ + unsigned map_generation; + int penalty_factor; + const int ref_mv_stride= s->mb_stride; //pass as arg FIXME + const int ref_mv_xy= s->mb_x + s->mb_y*ref_mv_stride; //add to last_mv beforepassing FIXME + me_cmp_func cmpf, chroma_cmpf; + + LOAD_COMMON + LOAD_COMMON2 + + if(c->pre_pass){ + penalty_factor= c->pre_penalty_factor; + cmpf= s->dsp.me_pre_cmp[size]; + chroma_cmpf= s->dsp.me_pre_cmp[size+1]; + }else{ + penalty_factor= c->penalty_factor; + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + } + + map_generation= update_map_generation(c); + + assert(cmpf); + dmin= cmp(s, 0, 0, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags); map[0]= map_generation; score_map[0]= dmin; + //FIXME precalc first term below? + if((s->pict_type == AV_PICTURE_TYPE_B && !(c->flags & FLAG_DIRECT)) || s->flags&CODEC_FLAG_MV0) + dmin += (mv_penalty[pred_x] + mv_penalty[pred_y])*penalty_factor; + /* first line */ - if ((s->mb_y == 0 || s->first_slice_line)) { + if (s->first_slice_line) { CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) - CHECK_MV(P_LAST[0]>>shift, P_LAST[1]>>shift) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) }else{ - if(dmin<256 && ( P_LEFT[0] |P_LEFT[1] + if(dmin<((h*h*s->avctx->mv0_threshold)>>8) + && ( P_LEFT[0] |P_LEFT[1] |P_TOP[0] |P_TOP[1] - |P_TOPRIGHT[0]|P_TOPRIGHT[1])==0 && s->avctx->dia_size==0){ + |P_TOPRIGHT[0]|P_TOPRIGHT[1])==0){ *mx_ptr= 0; *my_ptr= 0; - s->me.skip=1; + c->skip=1; return dmin; } - CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift) - if(dmin>256*2){ - CHECK_MV(P_LAST[0] >>shift, P_LAST[1] >>shift) - CHECK_MV(P_LEFT[0] >>shift, P_LEFT[1] >>shift) - CHECK_MV(P_TOP[0] >>shift, P_TOP[1] >>shift) - CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) - } + CHECK_MV( P_MEDIAN[0] >>shift , P_MEDIAN[1] >>shift) + CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift) , (P_MEDIAN[1]>>shift)-1) + CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift) , (P_MEDIAN[1]>>shift)+1) + CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)-1, (P_MEDIAN[1]>>shift) ) + CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)+1, (P_MEDIAN[1]>>shift) ) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) + CHECK_MV(P_LEFT[0] >>shift, P_LEFT[1] >>shift) + CHECK_MV(P_TOP[0] >>shift, P_TOP[1] >>shift) + CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) } - if(dmin>256*4){ - CHECK_MV(P_LAST_RIGHT[0] >>shift, P_LAST_RIGHT[1] >>shift) - CHECK_MV(P_LAST_BOTTOM[0]>>shift, P_LAST_BOTTOM[1]>>shift) + if(dmin>h*h*4){ + if(c->pre_pass){ + CHECK_CLIPPED_MV((last_mv[ref_mv_xy-1][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy-1][1]*ref_mv_scale + (1<<15))>>16) + if(!s->first_slice_line) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy-ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16) + }else{ + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16) + if(s->mb_y+1end_mb_y) //FIXME replace at least with last_slice_line + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16) + } } -#if 0 //doest only slow things down - if(dmin>512*3){ - int step; - dmin= score_map[0]; - best[0]= best[1]=0; - for(step=128; step>0; step>>=1){ - const int step2= step; - int y; - for(y=-step2+best[1]; y<=step2+best[1]; y+=step){ - int x; - if(yymax) continue; - - for(x=-step2+best[0]; x<=step2+best[0]; x+=step){ - if(xxmax) continue; - if(x==best[0] && y==best[1]) continue; - CHECK_MV(x,y) - } + + if(c->avctx->last_predictor_count){ + const int count= c->avctx->last_predictor_count; + const int xstart= FFMAX(0, s->mb_x - count); + const int ystart= FFMAX(0, s->mb_y - count); + const int xend= FFMIN(s->mb_width , s->mb_x + count + 1); + const int yend= FFMIN(s->mb_height, s->mb_y + count + 1); + int mb_y; + + for(mb_y=ystart; mb_y>16; + int my= (last_mv[xy][1]*ref_mv_scale + (1<<15))>>16; + + if(mx>xmax || mxymax || myavctx->dia_size<2) - dmin= RENAME(small_diamond_search)(s, best, dmin, ref_picture, - pred_x, pred_y, penalty_factor, xmin, ymin, xmax, ymax, - shift, map, map_generation, size, mv_penalty); - else - dmin= RENAME(var_diamond_search)(s, best, dmin, ref_picture, - pred_x, pred_y, penalty_factor, xmin, ymin, xmax, ymax, - shift, map, map_generation, size, mv_penalty); + dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); //check(best[0],best[1],0, b1) *mx_ptr= best[0]; - *my_ptr= best[1]; + *my_ptr= best[1]; -// printf("%d %d %d \n", best[0], best[1], dmin); return dmin; } -#ifndef CMP_DIRECT /* no 4mv search needed in direct mode */ -static int RENAME(epzs_motion_search4)(MpegEncContext * s, int block, - int *mx_ptr, int *my_ptr, - int P[10][2], int pred_x, int pred_y, - int xmin, int ymin, int xmax, int ymax, Picture *ref_picture, uint16_t * const mv_penalty) +//this function is dedicated to the braindamaged gcc +int ff_epzs_motion_search(MpegEncContext *s, int *mx_ptr, int *my_ptr, + int P[10][2], int src_index, int ref_index, + int16_t (*last_mv)[2], int ref_mv_scale, + int size, int h) +{ + MotionEstContext * const c= &s->me; +//FIXME convert other functions in the same way if faster + if(c->flags==0 && h==16 && size==0){ + return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, 0, 0, 16); +// case FLAG_QPEL: +// return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, FLAG_QPEL); + }else{ + return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, c->flags, size, h); + } +} + +static int epzs_motion_search4(MpegEncContext * s, + int *mx_ptr, int *my_ptr, int P[10][2], + int src_index, int ref_index, int16_t (*last_mv)[2], + int ref_mv_scale) { + MotionEstContext * const c= &s->me; int best[2]={0, 0}; - int d, dmin; - const int shift= 1+s->quarter_sample; - uint32_t *map= s->me.map; - int map_generation; - const int penalty_factor= s->me.penalty_factor; + int d, dmin; + unsigned map_generation; + const int penalty_factor= c->penalty_factor; const int size=1; - me_cmp_func cmp, chroma_cmp; - LOAD_COMMON((s->mb_x*2 + (block&1))*8, (s->mb_y*2 + (block>>1))*8); - - cmp= s->dsp.me_cmp[size]; - chroma_cmp= s->dsp.me_cmp[size+1]; + const int h=8; + const int ref_mv_stride= s->mb_stride; + const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride; + me_cmp_func cmpf, chroma_cmpf; + LOAD_COMMON + int flags= c->flags; + LOAD_COMMON2 - map_generation= update_map_generation(s); + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + map_generation= update_map_generation(c); dmin = 1000000; -//printf("%d %d %d %d //",xmin, ymin, xmax, ymax); + /* first line */ - if ((s->mb_y == 0 || s->first_slice_line) && block<2) { - CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) - CHECK_MV(P_LAST[0]>>shift, P_LAST[1]>>shift) + if (s->first_slice_line) { + CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift) }else{ CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift) //FIXME try some early stop - if(dmin>64*2){ - CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift) - CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) - CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift) - CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) - CHECK_MV(P_LAST[0]>>shift, P_LAST[1]>>shift) - } + CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift) + CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) + CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift) + CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) } if(dmin>64*4){ - CHECK_MV(P_LAST_RIGHT[0]>>shift, P_LAST_RIGHT[1]>>shift) - CHECK_MV(P_LAST_BOTTOM[0]>>shift, P_LAST_BOTTOM[1]>>shift) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16) + if(s->mb_y+1end_mb_y) //FIXME replace at least with last_slice_line + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16) } - if(s->avctx->dia_size<2) - dmin= RENAME(small_diamond_search)(s, best, dmin, ref_picture, - pred_x, pred_y, penalty_factor, xmin, ymin, xmax, ymax, - shift, map, map_generation, size, mv_penalty); - else - dmin= RENAME(var_diamond_search)(s, best, dmin, ref_picture, - pred_x, pred_y, penalty_factor, xmin, ymin, xmax, ymax, - shift, map, map_generation, size, mv_penalty); + dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + + *mx_ptr= best[0]; + *my_ptr= best[1]; + + return dmin; +} + +//try to merge with above FIXME (needs PSNR test) +static int epzs_motion_search2(MpegEncContext * s, + int *mx_ptr, int *my_ptr, int P[10][2], + int src_index, int ref_index, int16_t (*last_mv)[2], + int ref_mv_scale) +{ + MotionEstContext * const c= &s->me; + int best[2]={0, 0}; + int d, dmin; + unsigned map_generation; + const int penalty_factor= c->penalty_factor; + const int size=0; //FIXME pass as arg + const int h=8; + const int ref_mv_stride= s->mb_stride; + const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride; + me_cmp_func cmpf, chroma_cmpf; + LOAD_COMMON + int flags= c->flags; + LOAD_COMMON2 + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + map_generation= update_map_generation(c); + + dmin = 1000000; + + /* first line */ + if (s->first_slice_line) { + CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) + CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift) + }else{ + CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift) + //FIXME try some early stop + CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift) + CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) + CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift) + CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) + } + if(dmin>64*4){ + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16) + if(s->mb_y+1end_mb_y) //FIXME replace at least with last_slice_line + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16) + } + + dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + *mx_ptr= best[0]; - *my_ptr= best[1]; + *my_ptr= best[1]; -// printf("%d %d %d \n", best[0], best[1], dmin); return dmin; } -#endif /* !CMP_DIRECT */