git.sesse.net Git - ffmpeg/blob - libavcodec/motion_est_template.c

   1 /*
   2  * Motion estimation
   3  * Copyright (c) 2002-2004 Michael Niedermayer
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * Motion estimation template.
  25  */
  26
  27 //Let us hope gcc will remove the unused vars ...(gcc 3.2.2 seems to do it ...)
  28 #define LOAD_COMMON\
  29     uint32_t av_unused * const score_map= c->score_map;\
  30     const int av_unused xmin= c->xmin;\
  31     const int av_unused ymin= c->ymin;\
  32     const int av_unused xmax= c->xmax;\
  33     const int av_unused ymax= c->ymax;\
  34     uint8_t *mv_penalty= c->current_mv_penalty;\
  35     const int pred_x= c->pred_x;\
  36     const int pred_y= c->pred_y;\
  37
  38 #define CHECK_HALF_MV(dx, dy, x, y)\
  39 {\
  40     const int hx= 2*(x)+(dx);\
  41     const int hy= 2*(y)+(dy);\
  42     d= cmp_hpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);\
  43     d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\
  44     COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
  45 }
  46
  47 static int hpel_motion_search(MpegEncContext * s,
  48                                   int *mx_ptr, int *my_ptr, int dmin,
  49                                   int src_index, int ref_index,
  50                                   int size, int h)
  51 {
  52     MotionEstContext * const c= &s->me;
  53     const int mx = *mx_ptr;
  54     const int my = *my_ptr;
  55     const int penalty_factor= c->sub_penalty_factor;
  56     me_cmp_func cmp_sub, chroma_cmp_sub;
  57     int bx=2*mx, by=2*my;
  58
  59     LOAD_COMMON
  60     int flags= c->sub_flags;
  61
  62  //FIXME factorize
  63
  64     cmp_sub= s->dsp.me_sub_cmp[size];
  65     chroma_cmp_sub= s->dsp.me_sub_cmp[size+1];
  66
  67     if(c->skip){ //FIXME move out of hpel?
  68         *mx_ptr = 0;
  69         *my_ptr = 0;
  70         return dmin;
  71     }
  72
  73     if(c->avctx->me_cmp != c->avctx->me_sub_cmp){
  74         dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
  75         if(mx || my || size>0)
  76             dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor;
  77     }
  78
  79     if (mx > xmin && mx < xmax &&
  80         my > ymin && my < ymax) {
  81         int d= dmin;
  82         const int index= (my<<ME_MAP_SHIFT) + mx;
  83         const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]
  84                      + (mv_penalty[bx   - pred_x] + mv_penalty[by-2 - pred_y])*c->penalty_factor;
  85         const int l= score_map[(index- 1               )&(ME_MAP_SIZE-1)]
  86                      + (mv_penalty[bx-2 - pred_x] + mv_penalty[by   - pred_y])*c->penalty_factor;
  87         const int r= score_map[(index+ 1               )&(ME_MAP_SIZE-1)]
  88                      + (mv_penalty[bx+2 - pred_x] + mv_penalty[by   - pred_y])*c->penalty_factor;
  89         const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]
  90                      + (mv_penalty[bx   - pred_x] + mv_penalty[by+2 - pred_y])*c->penalty_factor;
  91
  92 #if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 1
  93         unsigned key;
  94         unsigned map_generation= c->map_generation;
  95         key= ((my-1)<<ME_MAP_MV_BITS) + (mx) + map_generation;
  96         av_assert2(c->map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)] == key);
  97         key= ((my+1)<<ME_MAP_MV_BITS) + (mx) + map_generation;
  98         av_assert2(c->map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)] == key);
  99         key= ((my)<<ME_MAP_MV_BITS) + (mx+1) + map_generation;
 100         av_assert2(c->map[(index+1)&(ME_MAP_SIZE-1)] == key);
 101         key= ((my)<<ME_MAP_MV_BITS) + (mx-1) + map_generation;
 102         av_assert2(c->map[(index-1)&(ME_MAP_SIZE-1)] == key);
 103 #endif
 104         if(t<=b){
 105             CHECK_HALF_MV(0, 1, mx  ,my-1)
 106             if(l<=r){
 107                 CHECK_HALF_MV(1, 1, mx-1, my-1)
 108                 if(t+r<=b+l){
 109                     CHECK_HALF_MV(1, 1, mx  , my-1)
 110                 }else{
 111                     CHECK_HALF_MV(1, 1, mx-1, my  )
 112                 }
 113                 CHECK_HALF_MV(1, 0, mx-1, my  )
 114             }else{
 115                 CHECK_HALF_MV(1, 1, mx  , my-1)
 116                 if(t+l<=b+r){
 117                     CHECK_HALF_MV(1, 1, mx-1, my-1)
 118                 }else{
 119                     CHECK_HALF_MV(1, 1, mx  , my  )
 120                 }
 121                 CHECK_HALF_MV(1, 0, mx  , my  )
 122             }
 123         }else{
 124             if(l<=r){
 125                 if(t+l<=b+r){
 126                     CHECK_HALF_MV(1, 1, mx-1, my-1)
 127                 }else{
 128                     CHECK_HALF_MV(1, 1, mx  , my  )
 129                 }
 130                 CHECK_HALF_MV(1, 0, mx-1, my)
 131                 CHECK_HALF_MV(1, 1, mx-1, my)
 132             }else{
 133                 if(t+r<=b+l){
 134                     CHECK_HALF_MV(1, 1, mx  , my-1)
 135                 }else{
 136                     CHECK_HALF_MV(1, 1, mx-1, my)
 137                 }
 138                 CHECK_HALF_MV(1, 0, mx  , my)
 139                 CHECK_HALF_MV(1, 1, mx  , my)
 140             }
 141             CHECK_HALF_MV(0, 1, mx  , my)
 142         }
 143         av_assert2(bx >= xmin*2 && bx <= xmax*2 && by >= ymin*2 && by <= ymax*2);
 144     }
 145
 146     *mx_ptr = bx;
 147     *my_ptr = by;
 148
 149     return dmin;
 150 }
 151
 152 static int no_sub_motion_search(MpegEncContext * s,
 153           int *mx_ptr, int *my_ptr, int dmin,
 154                                   int src_index, int ref_index,
 155                                   int size, int h)
 156 {
 157     (*mx_ptr)<<=1;
 158     (*my_ptr)<<=1;
 159     return dmin;
 160 }
 161
 162 static inline int get_mb_score(MpegEncContext *s, int mx, int my,
 163                                int src_index, int ref_index, int size,
 164                                int h, int add_rate)
 165 {
 166 //    const int check_luma= s->dsp.me_sub_cmp != s->dsp.mb_cmp;
 167     MotionEstContext * const c= &s->me;
 168     const int penalty_factor= c->mb_penalty_factor;
 169     const int flags= c->mb_flags;
 170     const int qpel= flags & FLAG_QPEL;
 171     const int mask= 1+2*qpel;
 172     me_cmp_func cmp_sub, chroma_cmp_sub;
 173     int d;
 174
 175     LOAD_COMMON
 176
 177  //FIXME factorize
 178
 179     cmp_sub= s->dsp.mb_cmp[size];
 180     chroma_cmp_sub= s->dsp.mb_cmp[size+1];
 181
 182     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);
 183     //FIXME check cbp before adding penalty for (0,0) vector
 184     if(add_rate && (mx || my || size>0))
 185         d += (mv_penalty[mx - pred_x] + mv_penalty[my - pred_y])*penalty_factor;
 186
 187     return d;
 188 }
 189
 190 int ff_get_mb_score(MpegEncContext *s, int mx, int my, int src_index,
 191                     int ref_index, int size, int h, int add_rate)
 192 {
 193     return get_mb_score(s, mx, my, src_index, ref_index, size, h, add_rate);
 194 }
 195
 196 #define CHECK_QUARTER_MV(dx, dy, x, y)\
 197 {\
 198     const int hx= 4*(x)+(dx);\
 199     const int hy= 4*(y)+(dy);\
 200     d= cmp_qpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
 201     d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\
 202     COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
 203 }
 204
 205 static int qpel_motion_search(MpegEncContext * s,
 206                                   int *mx_ptr, int *my_ptr, int dmin,
 207                                   int src_index, int ref_index,
 208                                   int size, int h)
 209 {
 210     MotionEstContext * const c= &s->me;
 211     const int mx = *mx_ptr;
 212     const int my = *my_ptr;
 213     const int penalty_factor= c->sub_penalty_factor;
 214     const unsigned map_generation = c->map_generation;
 215     const int subpel_quality= c->avctx->me_subpel_quality;
 216     uint32_t *map= c->map;
 217     me_cmp_func cmpf, chroma_cmpf;
 218     me_cmp_func cmp_sub, chroma_cmp_sub;
 219
 220     LOAD_COMMON
 221     int flags= c->sub_flags;
 222
 223     cmpf= s->dsp.me_cmp[size];
 224     chroma_cmpf= s->dsp.me_cmp[size+1]; //factorize FIXME
 225  //FIXME factorize
 226
 227     cmp_sub= s->dsp.me_sub_cmp[size];
 228     chroma_cmp_sub= s->dsp.me_sub_cmp[size+1];
 229
 230     if(c->skip){ //FIXME somehow move up (benchmark)
 231         *mx_ptr = 0;
 232         *my_ptr = 0;
 233         return dmin;
 234     }
 235
 236     if(c->avctx->me_cmp != c->avctx->me_sub_cmp){
 237         dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
 238         if(mx || my || size>0)
 239             dmin += (mv_penalty[4*mx - pred_x] + mv_penalty[4*my - pred_y])*penalty_factor;
 240     }
 241
 242     if (mx > xmin && mx < xmax &&
 243         my > ymin && my < ymax) {
 244         int bx=4*mx, by=4*my;
 245         int d= dmin;
 246         int i, nx, ny;
 247         const int index= (my<<ME_MAP_SHIFT) + mx;
 248         const int t= score_map[(index-(1<<ME_MAP_SHIFT)  )&(ME_MAP_SIZE-1)];
 249         const int l= score_map[(index- 1                 )&(ME_MAP_SIZE-1)];
 250         const int r= score_map[(index+ 1                 )&(ME_MAP_SIZE-1)];
 251         const int b= score_map[(index+(1<<ME_MAP_SHIFT)  )&(ME_MAP_SIZE-1)];
 252         const int c= score_map[(index                    )&(ME_MAP_SIZE-1)];
 253         int best[8];
 254         int best_pos[8][2];
 255
 256         memset(best, 64, sizeof(int)*8);
 257         if(s->me.dia_size>=2){
 258             const int tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
 259             const int bl= score_map[(index+(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
 260             const int tr= score_map[(index-(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];
 261             const int br= score_map[(index+(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];
 262
 263             for(ny= -3; ny <= 3; ny++){
 264                 for(nx= -3; nx <= 3; nx++){
 265                     //FIXME this could overflow (unlikely though)
 266                     const int64_t t2= nx*nx*(tr + tl - 2*t) + 4*nx*(tr-tl) + 32*t;
 267                     const int64_t c2= nx*nx*( r +  l - 2*c) + 4*nx*( r- l) + 32*c;
 268                     const int64_t b2= nx*nx*(br + bl - 2*b) + 4*nx*(br-bl) + 32*b;
 269                     int score= (ny*ny*(b2 + t2 - 2*c2) + 4*ny*(b2 - t2) + 32*c2 + 512)>>10;
 270                     int i;
 271
 272                     if((nx&3)==0 && (ny&3)==0) continue;
 273
 274                     score += (mv_penalty[4*mx + nx - pred_x] + mv_penalty[4*my + ny - pred_y])*penalty_factor;
 275
 276 //                    if(nx&1) score-=1024*c->penalty_factor;
 277 //                    if(ny&1) score-=1024*c->penalty_factor;
 278
 279                     for(i=0; i<8; i++){
 280                         if(score < best[i]){
 281                             memmove(&best[i+1], &best[i], sizeof(int)*(7-i));
 282                             memmove(&best_pos[i+1][0], &best_pos[i][0], sizeof(int)*2*(7-i));
 283                             best[i]= score;
 284                             best_pos[i][0]= nx + 4*mx;
 285                             best_pos[i][1]= ny + 4*my;
 286                             break;
 287                         }
 288                     }
 289                 }
 290             }
 291         }else{
 292             int tl;
 293             //FIXME this could overflow (unlikely though)
 294             const int cx = 4*(r - l);
 295             const int cx2= r + l - 2*c;
 296             const int cy = 4*(b - t);
 297             const int cy2= b + t - 2*c;
 298             int cxy;
 299
 300             if(map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)] == (my<<ME_MAP_MV_BITS) + mx + map_generation && 0){ //FIXME
 301                 tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
 302             }else{
 303                 tl= cmp(s, mx-1, my-1, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);//FIXME wrong if chroma me is different
 304             }
 305
 306             cxy= 2*tl + (cx + cy)/4 - (cx2 + cy2) - 2*c;
 307
 308             av_assert2(16*cx2 + 4*cx + 32*c == 32*r);
 309             av_assert2(16*cx2 - 4*cx + 32*c == 32*l);
 310             av_assert2(16*cy2 + 4*cy + 32*c == 32*b);
 311             av_assert2(16*cy2 - 4*cy + 32*c == 32*t);
 312             av_assert2(16*cxy + 16*cy2 + 16*cx2 - 4*cy - 4*cx + 32*c == 32*tl);
 313
 314             for(ny= -3; ny <= 3; ny++){
 315                 for(nx= -3; nx <= 3; nx++){
 316                     //FIXME this could overflow (unlikely though)
 317                     int score= ny*nx*cxy + nx*nx*cx2 + ny*ny*cy2 + nx*cx + ny*cy + 32*c; //FIXME factor
 318                     int i;
 319
 320                     if((nx&3)==0 && (ny&3)==0) continue;
 321
 322                     score += 32*(mv_penalty[4*mx + nx - pred_x] + mv_penalty[4*my + ny - pred_y])*penalty_factor;
 323 //                    if(nx&1) score-=32*c->penalty_factor;
 324   //                  if(ny&1) score-=32*c->penalty_factor;
 325
 326                     for(i=0; i<8; i++){
 327                         if(score < best[i]){
 328                             memmove(&best[i+1], &best[i], sizeof(int)*(7-i));
 329                             memmove(&best_pos[i+1][0], &best_pos[i][0], sizeof(int)*2*(7-i));
 330                             best[i]= score;
 331                             best_pos[i][0]= nx + 4*mx;
 332                             best_pos[i][1]= ny + 4*my;
 333                             break;
 334                         }
 335                     }
 336                 }
 337             }
 338         }
 339         for(i=0; i<subpel_quality; i++){
 340             nx= best_pos[i][0];
 341             ny= best_pos[i][1];
 342             CHECK_QUARTER_MV(nx&3, ny&3, nx>>2, ny>>2)
 343         }
 344
 345         av_assert2(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);
 346
 347         *mx_ptr = bx;
 348         *my_ptr = by;
 349     }else{
 350         *mx_ptr =4*mx;
 351         *my_ptr =4*my;
 352     }
 353
 354     return dmin;
 355 }
 356
 357
 358 #define CHECK_MV(x,y)\
 359 {\
 360     const unsigned key = ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
 361     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
 362     av_assert2((x) >= xmin);\
 363     av_assert2((x) <= xmax);\
 364     av_assert2((y) >= ymin);\
 365     av_assert2((y) <= ymax);\
 366     if(map[index]!=key){\
 367         d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
 368         map[index]= key;\
 369         score_map[index]= d;\
 370         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\
 371         COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\
 372     }\
 373 }
 374
 375 #define CHECK_CLIPPED_MV(ax,ay)\
 376 {\
 377     const int Lx= ax;\
 378     const int Ly= ay;\
 379     const int Lx2= FFMAX(xmin, FFMIN(Lx, xmax));\
 380     const int Ly2= FFMAX(ymin, FFMIN(Ly, ymax));\
 381     CHECK_MV(Lx2, Ly2)\
 382 }
 383
 384 #define CHECK_MV_DIR(x,y,new_dir)\
 385 {\
 386     const unsigned key = ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
 387     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
 388     if(map[index]!=key){\
 389         d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
 390         map[index]= key;\
 391         score_map[index]= d;\
 392         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\
 393         if(d<dmin){\
 394             best[0]=x;\
 395             best[1]=y;\
 396             dmin=d;\
 397             next_dir= new_dir;\
 398         }\
 399     }\
 400 }
 401
 402 #define check(x,y,S,v)\
 403 if( (x)<(xmin<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d xmin" #v, xmin, (x), (y), s->mb_x, s->mb_y);\
 404 if( (x)>(xmax<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d xmax" #v, xmax, (x), (y), s->mb_x, s->mb_y);\
 405 if( (y)<(ymin<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d ymin" #v, ymin, (x), (y), s->mb_x, s->mb_y);\
 406 if( (y)>(ymax<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d ymax" #v, ymax, (x), (y), s->mb_x, s->mb_y);\
 407
 408 #define LOAD_COMMON2\
 409     uint32_t *map= c->map;\
 410     const int qpel= flags&FLAG_QPEL;\
 411     const int shift= 1+qpel;\
 412
 413 static av_always_inline int small_diamond_search(MpegEncContext * s, int *best, int dmin,
 414                                        int src_index, int ref_index, int const penalty_factor,
 415                                        int size, int h, int flags)
 416 {
 417     MotionEstContext * const c= &s->me;
 418     me_cmp_func cmpf, chroma_cmpf;
 419     int next_dir=-1;
 420     LOAD_COMMON
 421     LOAD_COMMON2
 422     unsigned map_generation = c->map_generation;
 423
 424     cmpf= s->dsp.me_cmp[size];
 425     chroma_cmpf= s->dsp.me_cmp[size+1];
 426
 427     { /* ensure that the best point is in the MAP as h/qpel refinement needs it */
 428         const unsigned key = (best[1]<<ME_MAP_MV_BITS) + best[0] + map_generation;
 429         const int index= ((best[1]<<ME_MAP_SHIFT) + best[0])&(ME_MAP_SIZE-1);
 430         if(map[index]!=key){ //this will be executed only very rarey
 431             score_map[index]= cmp(s, best[0], best[1], 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
 432             map[index]= key;
 433         }
 434     }
 435
 436     for(;;){
 437         int d;
 438         const int dir= next_dir;
 439         const int x= best[0];
 440         const int y= best[1];
 441         next_dir=-1;
 442
 443         if(dir!=2 && x>xmin) CHECK_MV_DIR(x-1, y  , 0)
 444         if(dir!=3 && y>ymin) CHECK_MV_DIR(x  , y-1, 1)
 445         if(dir!=0 && x<xmax) CHECK_MV_DIR(x+1, y  , 2)
 446         if(dir!=1 && y<ymax) CHECK_MV_DIR(x  , y+1, 3)
 447
 448         if(next_dir==-1){
 449             return dmin;
 450         }
 451     }
 452 }
 453
 454 static int funny_diamond_search(MpegEncContext * s, int *best, int dmin,
 455                                        int src_index, int ref_index, int const penalty_factor,
 456                                        int size, int h, int flags)
 457 {
 458     MotionEstContext * const c= &s->me;
 459     me_cmp_func cmpf, chroma_cmpf;
 460     int dia_size;
 461     LOAD_COMMON
 462     LOAD_COMMON2
 463     unsigned map_generation = c->map_generation;
 464
 465     cmpf= s->dsp.me_cmp[size];
 466     chroma_cmpf= s->dsp.me_cmp[size+1];
 467
 468     for(dia_size=1; dia_size<=4; dia_size++){
 469         int dir;
 470         const int x= best[0];
 471         const int y= best[1];
 472
 473         if(dia_size&(dia_size-1)) continue;
 474
 475         if(   x + dia_size > xmax
 476            || x - dia_size < xmin
 477            || y + dia_size > ymax
 478            || y - dia_size < ymin)
 479            continue;
 480
 481         for(dir= 0; dir<dia_size; dir+=2){
 482             int d;
 483
 484             CHECK_MV(x + dir           , y + dia_size - dir);
 485             CHECK_MV(x + dia_size - dir, y - dir           );
 486             CHECK_MV(x - dir           , y - dia_size + dir);
 487             CHECK_MV(x - dia_size + dir, y + dir           );
 488         }
 489
 490         if(x!=best[0] || y!=best[1])
 491             dia_size=0;
 492     }
 493     return dmin;
 494 }
 495
 496 static int hex_search(MpegEncContext * s, int *best, int dmin,
 497                                        int src_index, int ref_index, int const penalty_factor,
 498                                        int size, int h, int flags, int dia_size)
 499 {
 500     MotionEstContext * const c= &s->me;
 501     me_cmp_func cmpf, chroma_cmpf;
 502     LOAD_COMMON
 503     LOAD_COMMON2
 504     unsigned map_generation = c->map_generation;
 505     int x,y,d;
 506     const int dec= dia_size & (dia_size-1);
 507
 508     cmpf= s->dsp.me_cmp[size];
 509     chroma_cmpf= s->dsp.me_cmp[size+1];
 510
 511     for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
 512         do{
 513             x= best[0];
 514             y= best[1];
 515
 516             CHECK_CLIPPED_MV(x  -dia_size    , y);
 517             CHECK_CLIPPED_MV(x+  dia_size    , y);
 518             CHECK_CLIPPED_MV(x+( dia_size>>1), y+dia_size);
 519             CHECK_CLIPPED_MV(x+( dia_size>>1), y-dia_size);
 520             if(dia_size>1){
 521                 CHECK_CLIPPED_MV(x+(-dia_size>>1), y+dia_size);
 522                 CHECK_CLIPPED_MV(x+(-dia_size>>1), y-dia_size);
 523             }
 524         }while(best[0] != x || best[1] != y);
 525     }
 526
 527     return dmin;
 528 }
 529
 530 static int l2s_dia_search(MpegEncContext * s, int *best, int dmin,
 531                                        int src_index, int ref_index, int const penalty_factor,
 532                                        int size, int h, int flags)
 533 {
 534     MotionEstContext * const c= &s->me;
 535     me_cmp_func cmpf, chroma_cmpf;
 536     LOAD_COMMON
 537     LOAD_COMMON2
 538     unsigned map_generation = c->map_generation;
 539     int x,y,i,d;
 540     int dia_size= c->dia_size&0xFF;
 541     const int dec= dia_size & (dia_size-1);
 542     static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1},
 543                                 { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}};
 544
 545     cmpf= s->dsp.me_cmp[size];
 546     chroma_cmpf= s->dsp.me_cmp[size+1];
 547
 548     for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
 549         do{
 550             x= best[0];
 551             y= best[1];
 552             for(i=0; i<8; i++){
 553                 CHECK_CLIPPED_MV(x+hex[i][0]*dia_size, y+hex[i][1]*dia_size);
 554             }
 555         }while(best[0] != x || best[1] != y);
 556     }
 557
 558     x= best[0];
 559     y= best[1];
 560     CHECK_CLIPPED_MV(x+1, y);
 561     CHECK_CLIPPED_MV(x, y+1);
 562     CHECK_CLIPPED_MV(x-1, y);
 563     CHECK_CLIPPED_MV(x, y-1);
 564
 565     return dmin;
 566 }
 567
 568 static int umh_search(MpegEncContext * s, int *best, int dmin,
 569                                        int src_index, int ref_index, int const penalty_factor,
 570                                        int size, int h, int flags)
 571 {
 572     MotionEstContext * const c= &s->me;
 573     me_cmp_func cmpf, chroma_cmpf;
 574     LOAD_COMMON
 575     LOAD_COMMON2
 576     unsigned map_generation = c->map_generation;
 577     int x,y,x2,y2, i, j, d;
 578     const int dia_size= c->dia_size&0xFE;
 579     static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2},
 580                                  { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2},
 581                                  {-2, 3}, { 0, 4}, { 2, 3},
 582                                  {-2,-3}, { 0,-4}, { 2,-3},};
 583
 584     cmpf= s->dsp.me_cmp[size];
 585     chroma_cmpf= s->dsp.me_cmp[size+1];
 586
 587     x= best[0];
 588     y= best[1];
 589     for(x2=FFMAX(x-dia_size+1, xmin); x2<=FFMIN(x+dia_size-1,xmax); x2+=2){
 590         CHECK_MV(x2, y);
 591     }
 592     for(y2=FFMAX(y-dia_size/2+1, ymin); y2<=FFMIN(y+dia_size/2-1,ymax); y2+=2){
 593         CHECK_MV(x, y2);
 594     }
 595
 596     x= best[0];
 597     y= best[1];
 598     for(y2=FFMAX(y-2, ymin); y2<=FFMIN(y+2,ymax); y2++){
 599         for(x2=FFMAX(x-2, xmin); x2<=FFMIN(x+2,xmax); x2++){
 600             CHECK_MV(x2, y2);
 601         }
 602     }
 603
 604 //FIXME prevent the CLIP stuff
 605
 606     for(j=1; j<=dia_size/4; j++){
 607         for(i=0; i<16; i++){
 608             CHECK_CLIPPED_MV(x+hex[i][0]*j, y+hex[i][1]*j);
 609         }
 610     }
 611
 612     return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2);
 613 }
 614
 615 static int full_search(MpegEncContext * s, int *best, int dmin,
 616                                        int src_index, int ref_index, int const penalty_factor,
 617                                        int size, int h, int flags)
 618 {
 619     MotionEstContext * const c= &s->me;
 620     me_cmp_func cmpf, chroma_cmpf;
 621     LOAD_COMMON
 622     LOAD_COMMON2
 623     unsigned map_generation = c->map_generation;
 624     int x,y, d;
 625     const int dia_size= c->dia_size&0xFF;
 626
 627     cmpf= s->dsp.me_cmp[size];
 628     chroma_cmpf= s->dsp.me_cmp[size+1];
 629
 630     for(y=FFMAX(-dia_size, ymin); y<=FFMIN(dia_size,ymax); y++){
 631         for(x=FFMAX(-dia_size, xmin); x<=FFMIN(dia_size,xmax); x++){
 632             CHECK_MV(x, y);
 633         }
 634     }
 635
 636     x= best[0];
 637     y= best[1];
 638     d= dmin;
 639     CHECK_CLIPPED_MV(x  , y);
 640     CHECK_CLIPPED_MV(x+1, y);
 641     CHECK_CLIPPED_MV(x, y+1);
 642     CHECK_CLIPPED_MV(x-1, y);
 643     CHECK_CLIPPED_MV(x, y-1);
 644     best[0]= x;
 645     best[1]= y;
 646
 647     return d;
 648 }
 649
 650 #define SAB_CHECK_MV(ax,ay)\
 651 {\
 652     const unsigned key = ((ay)<<ME_MAP_MV_BITS) + (ax) + map_generation;\
 653     const int index= (((ay)<<ME_MAP_SHIFT) + (ax))&(ME_MAP_SIZE-1);\
 654     if(map[index]!=key){\
 655         d= cmp(s, ax, ay, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
 656         map[index]= key;\
 657         score_map[index]= d;\
 658         d += (mv_penalty[((ax)<<shift)-pred_x] + mv_penalty[((ay)<<shift)-pred_y])*penalty_factor;\
 659         if(d < minima[minima_count-1].height){\
 660             int j=0;\
 661             \
 662             while(d >= minima[j].height) j++;\
 663 \
 664             memmove(&minima [j+1], &minima [j], (minima_count - j - 1)*sizeof(Minima));\
 665 \
 666             minima[j].checked= 0;\
 667             minima[j].height= d;\
 668             minima[j].x= ax;\
 669             minima[j].y= ay;\
 670             \
 671             i=-1;\
 672             continue;\
 673         }\
 674     }\
 675 }
 676
 677 #define MAX_SAB_SIZE ME_MAP_SIZE
 678 static int sab_diamond_search(MpegEncContext * s, int *best, int dmin,
 679                                        int src_index, int ref_index, int const penalty_factor,
 680                                        int size, int h, int flags)
 681 {
 682     MotionEstContext * const c= &s->me;
 683     me_cmp_func cmpf, chroma_cmpf;
 684     Minima minima[MAX_SAB_SIZE];
 685     const int minima_count= FFABS(c->dia_size);
 686     int i, j;
 687     LOAD_COMMON
 688     LOAD_COMMON2
 689     unsigned map_generation = c->map_generation;
 690
 691     av_assert1(minima_count <= MAX_SAB_SIZE);
 692
 693     cmpf= s->dsp.me_cmp[size];
 694     chroma_cmpf= s->dsp.me_cmp[size+1];
 695
 696     /*Note j<MAX_SAB_SIZE is needed if MAX_SAB_SIZE < ME_MAP_SIZE as j can
 697       become larger due to MVs overflowing their ME_MAP_MV_BITS bits space in map
 698      */
 699     for(j=i=0; i<ME_MAP_SIZE && j<MAX_SAB_SIZE; i++){
 700         uint32_t key= map[i];
 701
 702         key += (1<<(ME_MAP_MV_BITS-1)) + (1<<(2*ME_MAP_MV_BITS-1));
 703
 704         if((key&((-1)<<(2*ME_MAP_MV_BITS))) != map_generation) continue;
 705
 706         minima[j].height= score_map[i];
 707         minima[j].x= key & ((1<<ME_MAP_MV_BITS)-1); key>>=ME_MAP_MV_BITS;
 708         minima[j].y= key & ((1<<ME_MAP_MV_BITS)-1);
 709         minima[j].x-= (1<<(ME_MAP_MV_BITS-1));
 710         minima[j].y-= (1<<(ME_MAP_MV_BITS-1));
 711
 712         // all entries in map should be in range except if the mv overflows their ME_MAP_MV_BITS bits space
 713         if(   minima[j].x > xmax || minima[j].x < xmin
 714            || minima[j].y > ymax || minima[j].y < ymin)
 715             continue;
 716
 717         minima[j].checked=0;
 718         if(minima[j].x || minima[j].y)
 719             minima[j].height+= (mv_penalty[((minima[j].x)<<shift)-pred_x] + mv_penalty[((minima[j].y)<<shift)-pred_y])*penalty_factor;
 720
 721         j++;
 722     }
 723
 724     qsort(minima, j, sizeof(Minima), minima_cmp);
 725
 726     for(; j<minima_count; j++){
 727         minima[j].height=256*256*256*64;
 728         minima[j].checked=0;
 729         minima[j].x= minima[j].y=0;
 730     }
 731
 732     for(i=0; i<minima_count; i++){
 733         const int x= minima[i].x;
 734         const int y= minima[i].y;
 735         int d;
 736
 737         if(minima[i].checked) continue;
 738
 739         if(   x >= xmax || x <= xmin
 740            || y >= ymax || y <= ymin)
 741            continue;
 742
 743         SAB_CHECK_MV(x-1, y)
 744         SAB_CHECK_MV(x+1, y)
 745         SAB_CHECK_MV(x  , y-1)
 746         SAB_CHECK_MV(x  , y+1)
 747
 748         minima[i].checked= 1;
 749     }
 750
 751     best[0]= minima[0].x;
 752     best[1]= minima[0].y;
 753     dmin= minima[0].height;
 754
 755     if(   best[0] < xmax && best[0] > xmin
 756        && best[1] < ymax && best[1] > ymin){
 757         int d;
 758         //ensure that the refernece samples for hpel refinement are in the map
 759         CHECK_MV(best[0]-1, best[1])
 760         CHECK_MV(best[0]+1, best[1])
 761         CHECK_MV(best[0], best[1]-1)
 762         CHECK_MV(best[0], best[1]+1)
 763     }
 764     return dmin;
 765 }
 766
 767 static int var_diamond_search(MpegEncContext * s, int *best, int dmin,
 768                                        int src_index, int ref_index, int const penalty_factor,
 769                                        int size, int h, int flags)
 770 {
 771     MotionEstContext * const c= &s->me;
 772     me_cmp_func cmpf, chroma_cmpf;
 773     int dia_size;
 774     LOAD_COMMON
 775     LOAD_COMMON2
 776     unsigned map_generation = c->map_generation;
 777
 778     cmpf= s->dsp.me_cmp[size];
 779     chroma_cmpf= s->dsp.me_cmp[size+1];
 780
 781     for(dia_size=1; dia_size<=c->dia_size; dia_size++){
 782         int dir, start, end;
 783         const int x= best[0];
 784         const int y= best[1];
 785
 786         start= FFMAX(0, y + dia_size - ymax);
 787         end  = FFMIN(dia_size, xmax - x + 1);
 788         for(dir= start; dir<end; dir++){
 789             int d;
 790
 791 //check(x + dir,y + dia_size - dir,0, a0)
 792             CHECK_MV(x + dir           , y + dia_size - dir);
 793         }
 794
 795         start= FFMAX(0, x + dia_size - xmax);
 796         end  = FFMIN(dia_size, y - ymin + 1);
 797         for(dir= start; dir<end; dir++){
 798             int d;
 799
 800 //check(x + dia_size - dir, y - dir,0, a1)
 801             CHECK_MV(x + dia_size - dir, y - dir           );
 802         }
 803
 804         start= FFMAX(0, -y + dia_size + ymin );
 805         end  = FFMIN(dia_size, x - xmin + 1);
 806         for(dir= start; dir<end; dir++){
 807             int d;
 808
 809 //check(x - dir,y - dia_size + dir,0, a2)
 810             CHECK_MV(x - dir           , y - dia_size + dir);
 811         }
 812
 813         start= FFMAX(0, -x + dia_size + xmin );
 814         end  = FFMIN(dia_size, ymax - y + 1);
 815         for(dir= start; dir<end; dir++){
 816             int d;
 817
 818 //check(x - dia_size + dir, y + dir,0, a3)
 819             CHECK_MV(x - dia_size + dir, y + dir           );
 820         }
 821
 822         if(x!=best[0] || y!=best[1])
 823             dia_size=0;
 824     }
 825     return dmin;
 826 }
 827
 828 static av_always_inline int diamond_search(MpegEncContext * s, int *best, int dmin,
 829                                        int src_index, int ref_index, int const penalty_factor,
 830                                        int size, int h, int flags){
 831     MotionEstContext * const c= &s->me;
 832     if(c->dia_size==-1)
 833         return funny_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 834     else if(c->dia_size<-1)
 835         return   sab_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 836     else if(c->dia_size<2)
 837         return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 838     else if(c->dia_size>1024)
 839         return          full_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 840     else if(c->dia_size>768)
 841         return           umh_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 842     else if(c->dia_size>512)
 843         return           hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, c->dia_size&0xFF);
 844     else if(c->dia_size>256)
 845         return       l2s_dia_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 846     else
 847         return   var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 848 }
 849
 850 /**
 851    @param P a list of candidate mvs to check before starting the
 852    iterative search. If one of the candidates is close to the optimal mv, then
 853    it takes fewer iterations. And it increases the chance that we find the
 854    optimal mv.
 855  */
 856 static av_always_inline int epzs_motion_search_internal(MpegEncContext * s, int *mx_ptr, int *my_ptr,
 857                              int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2],
 858                              int ref_mv_scale, int flags, int size, int h)
 859 {
 860     MotionEstContext * const c= &s->me;
 861     int best[2]={0, 0};      /**< x and y coordinates of the best motion vector.
 862                                i.e. the difference between the position of the
 863                                block currently being encoded and the position of
 864                                the block chosen to predict it from. */
 865     int d;                   ///< the score (cmp + penalty) of any given mv
 866     int dmin;                /**< the best value of d, i.e. the score
 867                                corresponding to the mv stored in best[]. */
 868     unsigned map_generation;
 869     int penalty_factor;
 870     const int ref_mv_stride= s->mb_stride; //pass as arg  FIXME
 871     const int ref_mv_xy= s->mb_x + s->mb_y*ref_mv_stride; //add to last_mv beforepassing FIXME
 872     me_cmp_func cmpf, chroma_cmpf;
 873
 874     LOAD_COMMON
 875     LOAD_COMMON2
 876
 877     if(c->pre_pass){
 878         penalty_factor= c->pre_penalty_factor;
 879         cmpf= s->dsp.me_pre_cmp[size];
 880         chroma_cmpf= s->dsp.me_pre_cmp[size+1];
 881     }else{
 882         penalty_factor= c->penalty_factor;
 883         cmpf= s->dsp.me_cmp[size];
 884         chroma_cmpf= s->dsp.me_cmp[size+1];
 885     }
 886
 887     map_generation= update_map_generation(c);
 888
 889     av_assert2(cmpf);
 890     dmin= cmp(s, 0, 0, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
 891     map[0]= map_generation;
 892     score_map[0]= dmin;
 893
 894     //FIXME precalc first term below?
 895     if((s->pict_type == AV_PICTURE_TYPE_B && !(c->flags & FLAG_DIRECT)) || s->flags&CODEC_FLAG_MV0)
 896         dmin += (mv_penalty[pred_x] + mv_penalty[pred_y])*penalty_factor;
 897
 898     /* first line */
 899     if (s->first_slice_line) {
 900         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
 901         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
 902                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
 903     }else{
 904         if(dmin<((h*h*s->avctx->mv0_threshold)>>8)
 905                     && ( P_LEFT[0]    |P_LEFT[1]
 906                         |P_TOP[0]     |P_TOP[1]
 907                         |P_TOPRIGHT[0]|P_TOPRIGHT[1])==0){
 908             *mx_ptr= 0;
 909             *my_ptr= 0;
 910             c->skip=1;
 911             return dmin;
 912         }
 913         CHECK_MV(    P_MEDIAN[0] >>shift ,    P_MEDIAN[1] >>shift)
 914         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)  , (P_MEDIAN[1]>>shift)-1)
 915         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)  , (P_MEDIAN[1]>>shift)+1)
 916         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)-1, (P_MEDIAN[1]>>shift)  )
 917         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)+1, (P_MEDIAN[1]>>shift)  )
 918         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
 919                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
 920         CHECK_MV(P_LEFT[0]    >>shift, P_LEFT[1]    >>shift)
 921         CHECK_MV(P_TOP[0]     >>shift, P_TOP[1]     >>shift)
 922         CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
 923     }
 924     if(dmin>h*h*4){
 925         if(c->pre_pass){
 926             CHECK_CLIPPED_MV((last_mv[ref_mv_xy-1][0]*ref_mv_scale + (1<<15))>>16,
 927                             (last_mv[ref_mv_xy-1][1]*ref_mv_scale + (1<<15))>>16)
 928             if(!s->first_slice_line)
 929                 CHECK_CLIPPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
 930                                 (last_mv[ref_mv_xy-ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
 931         }else{
 932             CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
 933                             (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
 934             if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line
 935                 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
 936                                 (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
 937         }
 938     }
 939
 940     if(c->avctx->last_predictor_count){
 941         const int count= c->avctx->last_predictor_count;
 942         const int xstart= FFMAX(0, s->mb_x - count);
 943         const int ystart= FFMAX(0, s->mb_y - count);
 944         const int xend= FFMIN(s->mb_width , s->mb_x + count + 1);
 945         const int yend= FFMIN(s->mb_height, s->mb_y + count + 1);
 946         int mb_y;
 947
 948         for(mb_y=ystart; mb_y<yend; mb_y++){
 949             int mb_x;
 950             for(mb_x=xstart; mb_x<xend; mb_x++){
 951                 const int xy= mb_x + 1 + (mb_y + 1)*ref_mv_stride;
 952                 int mx= (last_mv[xy][0]*ref_mv_scale + (1<<15))>>16;
 953                 int my= (last_mv[xy][1]*ref_mv_scale + (1<<15))>>16;
 954
 955                 if(mx>xmax || mx<xmin || my>ymax || my<ymin) continue;
 956                 CHECK_MV(mx,my)
 957             }
 958         }
 959     }
 960
 961 //check(best[0],best[1],0, b0)
 962     dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 963
 964 //check(best[0],best[1],0, b1)
 965     *mx_ptr= best[0];
 966     *my_ptr= best[1];
 967
 968     return dmin;
 969 }
 970
 971 //this function is dedicated to the braindamaged gcc
 972 int ff_epzs_motion_search(MpegEncContext *s, int *mx_ptr, int *my_ptr,
 973                           int P[10][2], int src_index, int ref_index,
 974                           int16_t (*last_mv)[2], int ref_mv_scale,
 975                           int size, int h)
 976 {
 977     MotionEstContext * const c= &s->me;
 978 //FIXME convert other functions in the same way if faster
 979     if(c->flags==0 && h==16 && size==0){
 980         return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, 0, 0, 16);
 981 //    case FLAG_QPEL:
 982 //        return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, FLAG_QPEL);
 983     }else{
 984         return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, c->flags, size, h);
 985     }
 986 }
 987
 988 static int epzs_motion_search4(MpegEncContext * s,
 989                              int *mx_ptr, int *my_ptr, int P[10][2],
 990                              int src_index, int ref_index, int16_t (*last_mv)[2],
 991                              int ref_mv_scale)
 992 {
 993     MotionEstContext * const c= &s->me;
 994     int best[2]={0, 0};
 995     int d, dmin;
 996     unsigned map_generation;
 997     const int penalty_factor= c->penalty_factor;
 998     const int size=1;
 999     const int h=8;
1000     const int ref_mv_stride= s->mb_stride;
1001     const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride;
1002     me_cmp_func cmpf, chroma_cmpf;
1003     LOAD_COMMON
1004     int flags= c->flags;
1005     LOAD_COMMON2
1006
1007     cmpf= s->dsp.me_cmp[size];
1008     chroma_cmpf= s->dsp.me_cmp[size+1];
1009
1010     map_generation= update_map_generation(c);
1011
1012     dmin = 1000000;
1013
1014     /* first line */
1015     if (s->first_slice_line) {
1016         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1017         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1018                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1019         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
1020     }else{
1021         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
1022         //FIXME try some early stop
1023         CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
1024         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1025         CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
1026         CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
1027         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1028                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1029     }
1030     if(dmin>64*4){
1031         CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
1032                         (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
1033         if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line
1034             CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
1035                             (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
1036     }
1037
1038     dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
1039
1040     *mx_ptr= best[0];
1041     *my_ptr= best[1];
1042
1043     return dmin;
1044 }
1045
1046 //try to merge with above FIXME (needs PSNR test)
1047 static int epzs_motion_search2(MpegEncContext * s,
1048                              int *mx_ptr, int *my_ptr, int P[10][2],
1049                              int src_index, int ref_index, int16_t (*last_mv)[2],
1050                              int ref_mv_scale)
1051 {
1052     MotionEstContext * const c= &s->me;
1053     int best[2]={0, 0};
1054     int d, dmin;
1055     unsigned map_generation;
1056     const int penalty_factor= c->penalty_factor;
1057     const int size=0; //FIXME pass as arg
1058     const int h=8;
1059     const int ref_mv_stride= s->mb_stride;
1060     const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride;
1061     me_cmp_func cmpf, chroma_cmpf;
1062     LOAD_COMMON
1063     int flags= c->flags;
1064     LOAD_COMMON2
1065
1066     cmpf= s->dsp.me_cmp[size];
1067     chroma_cmpf= s->dsp.me_cmp[size+1];
1068
1069     map_generation= update_map_generation(c);
1070
1071     dmin = 1000000;
1072
1073     /* first line */
1074     if (s->first_slice_line) {
1075         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1076         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1077                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1078         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
1079     }else{
1080         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
1081         //FIXME try some early stop
1082         CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
1083         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1084         CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
1085         CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
1086         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1087                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1088     }
1089     if(dmin>64*4){
1090         CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
1091                         (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
1092         if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line
1093             CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
1094                             (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
1095     }
1096
1097     dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
1098
1099     *mx_ptr= best[0];
1100     *my_ptr= best[1];
1101
1102     return dmin;
1103 }