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