falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
9447 Commits
32 Branches
511MB
Tree: 4440b1188e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4440b1188e'
${ noResults }
FFmpeg/libavcodec/motion_est_template.c

1250 lines
43KB
Raw Blame History 

  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. /**

  24.  * @file motion_est_template.c

  25.  * Motion estimation template.

  26.  */

  27. 

  28. //lets hope gcc will remove the unused vars ...(gcc 3.2.2 seems to do it ...)

  29. #define LOAD_COMMON\

  30.     uint32_t attribute_unused * const score_map= c->score_map;\

  31.     const int attribute_unused xmin= c->xmin;\

  32.     const int attribute_unused ymin= c->ymin;\

  33.     const int attribute_unused xmax= c->xmax;\

  34.     const int attribute_unused ymax= c->ymax;\

  35.     uint8_t *mv_penalty= c->current_mv_penalty;\

  36.     const int pred_x= c->pred_x;\

  37.     const int pred_y= c->pred_y;\

  38. 

  39. #define CHECK_HALF_MV(dx, dy, x, y)\

  40. {\

  41.     const int hx= 2*(x)+(dx);\

  42.     const int hy= 2*(y)+(dy);\

  43.     d= cmp(s, x, y, dx, dy, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);\

  44.     d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\

  45.     COPY3_IF_LT(dmin, d, bx, hx, by, hy)\

  46. }

  47. 

  48. #if 0

  49. static int hpel_motion_search)(MpegEncContext * s,

  50.                                   int *mx_ptr, int *my_ptr, int dmin,

  51.                                   uint8_t *ref_data[3],

  52.                                   int size)

  53. {

  54.     const int xx = 16 * s->mb_x + 8*(n&1);

  55.     const int yy = 16 * s->mb_y + 8*(n>>1);

  56.     const int mx = *mx_ptr;

  57.     const int my = *my_ptr;

  58.     const int penalty_factor= c->sub_penalty_factor;

  59. 

  60.     LOAD_COMMON

  61. 

  62.  //   INIT;

  63.  //FIXME factorize

  64.     me_cmp_func cmp, chroma_cmp, cmp_sub, chroma_cmp_sub;

  65. 

  66.     if(s->no_rounding /*FIXME b_type*/){

  67.         hpel_put= &s->dsp.put_no_rnd_pixels_tab[size];

  68.         chroma_hpel_put= &s->dsp.put_no_rnd_pixels_tab[size+1];

  69.     }else{

  70.         hpel_put=& s->dsp.put_pixels_tab[size];

  71.         chroma_hpel_put= &s->dsp.put_pixels_tab[size+1];

  72.     }

  73.     cmpf= s->dsp.me_cmp[size];

  74.     chroma_cmpf= s->dsp.me_cmp[size+1];

  75.     cmp_sub= s->dsp.me_sub_cmp[size];

  76.     chroma_cmp_sub= s->dsp.me_sub_cmp[size+1];

  77. 

  78.     if(c->skip){ //FIXME somehow move up (benchmark)

  79.         *mx_ptr = 0;

  80.         *my_ptr = 0;

  81.         return dmin;

  82.     }

  83. 

  84.     if(c->avctx->me_cmp != c->avctx->me_sub_cmp){

  85.         CMP_HPEL(dmin, 0, 0, mx, my, size);

  86.         if(mx || my)

  87.             dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor;

  88.     }

  89. 

  90.     if (mx > xmin && mx < xmax &&

  91.         my > ymin && my < ymax) {

  92.         int bx=2*mx, by=2*my;

  93.         int d= dmin;

  94. 

  95.         CHECK_HALF_MV(1, 1, mx-1, my-1)

  96.         CHECK_HALF_MV(0, 1, mx  , my-1)

  97.         CHECK_HALF_MV(1, 1, mx  , my-1)

  98.         CHECK_HALF_MV(1, 0, mx-1, my  )

  99.         CHECK_HALF_MV(1, 0, mx  , my  )

  100.         CHECK_HALF_MV(1, 1, mx-1, my  )

  101.         CHECK_HALF_MV(0, 1, mx  , my  )

  102.         CHECK_HALF_MV(1, 1, mx  , my  )

  103. 

  104.         assert(bx >= xmin*2 || bx <= xmax*2 || by >= ymin*2 || by <= ymax*2);

  105. 

  106.         *mx_ptr = bx;

  107.         *my_ptr = by;

  108.     }else{

  109.         *mx_ptr =2*mx;

  110.         *my_ptr =2*my;

  111.     }

  112. 

  113.     return dmin;

  114. }

  115. 

  116. #else

  117. static int hpel_motion_search(MpegEncContext * s,

  118.                                   int *mx_ptr, int *my_ptr, int dmin,

  119.                                   int src_index, int ref_index,

  120.                                   int size, int h)

  121. {

  122.     MotionEstContext * const c= &s->me;

  123.     const int mx = *mx_ptr;

  124.     const int my = *my_ptr;

  125.     const int penalty_factor= c->sub_penalty_factor;

  126.     me_cmp_func cmp_sub, chroma_cmp_sub;

  127.     int bx=2*mx, by=2*my;

  128. 

  129.     LOAD_COMMON

  130.     int flags= c->sub_flags;

  131. 

  132.  //FIXME factorize

  133. 

  134.     cmp_sub= s->dsp.me_sub_cmp[size];

  135.     chroma_cmp_sub= s->dsp.me_sub_cmp[size+1];

  136. 

  137.     if(c->skip){ //FIXME move out of hpel?

  138.         *mx_ptr = 0;

  139.         *my_ptr = 0;

  140.         return dmin;

  141.     }

  142. 

  143.     if(c->avctx->me_cmp != c->avctx->me_sub_cmp){

  144.         dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);

  145.         if(mx || my || size>0)

  146.             dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor;

  147.     }

  148. 

  149.     if (mx > xmin && mx < xmax &&

  150.         my > ymin && my < ymax) {

  151.         int d= dmin;

  152.         const int index= (my<<ME_MAP_SHIFT) + mx;

  153.         const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]

  154.                      + (mv_penalty[bx   - pred_x] + mv_penalty[by-2 - pred_y])*c->penalty_factor;

  155.         const int l= score_map[(index- 1               )&(ME_MAP_SIZE-1)]

  156.                      + (mv_penalty[bx-2 - pred_x] + mv_penalty[by   - pred_y])*c->penalty_factor;

  157.         const int r= score_map[(index+ 1               )&(ME_MAP_SIZE-1)]

  158.                      + (mv_penalty[bx+2 - pred_x] + mv_penalty[by   - pred_y])*c->penalty_factor;

  159.         const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]

  160.                      + (mv_penalty[bx   - pred_x] + mv_penalty[by+2 - pred_y])*c->penalty_factor;

  161. 

  162. #if 1

  163.         int key;

  164.         int map_generation= c->map_generation;

  165. #ifndef NDEBUG

  166.         uint32_t *map= c->map;

  167. #endif

  168.         key= ((my-1)<<ME_MAP_MV_BITS) + (mx) + map_generation;

  169.         assert(map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)] == key);

  170.         key= ((my+1)<<ME_MAP_MV_BITS) + (mx) + map_generation;

  171.         assert(map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)] == key);

  172.         key= ((my)<<ME_MAP_MV_BITS) + (mx+1) + map_generation;

  173.         assert(map[(index+1)&(ME_MAP_SIZE-1)] == key);

  174.         key= ((my)<<ME_MAP_MV_BITS) + (mx-1) + map_generation;

  175.         assert(map[(index-1)&(ME_MAP_SIZE-1)] == key);

  176. #endif

  177.         if(t<=b){

  178.             CHECK_HALF_MV(0, 1, mx  ,my-1)

  179.             if(l<=r){

  180.                 CHECK_HALF_MV(1, 1, mx-1, my-1)

  181.                 if(t+r<=b+l){

  182.                     CHECK_HALF_MV(1, 1, mx  , my-1)

  183.                 }else{

  184.                     CHECK_HALF_MV(1, 1, mx-1, my  )

  185.                 }

  186.                 CHECK_HALF_MV(1, 0, mx-1, my  )

  187.             }else{

  188.                 CHECK_HALF_MV(1, 1, mx  , my-1)

  189.                 if(t+l<=b+r){

  190.                     CHECK_HALF_MV(1, 1, mx-1, my-1)

  191.                 }else{

  192.                     CHECK_HALF_MV(1, 1, mx  , my  )

  193.                 }

  194.                 CHECK_HALF_MV(1, 0, mx  , my  )

  195.             }

  196.         }else{

  197.             if(l<=r){

  198.                 if(t+l<=b+r){

  199.                     CHECK_HALF_MV(1, 1, mx-1, my-1)

  200.                 }else{

  201.                     CHECK_HALF_MV(1, 1, mx  , my  )

  202.                 }

  203.                 CHECK_HALF_MV(1, 0, mx-1, my)

  204.                 CHECK_HALF_MV(1, 1, mx-1, my)

  205.             }else{

  206.                 if(t+r<=b+l){

  207.                     CHECK_HALF_MV(1, 1, mx  , my-1)

  208.                 }else{

  209.                     CHECK_HALF_MV(1, 1, mx-1, my)

  210.                 }

  211.                 CHECK_HALF_MV(1, 0, mx  , my)

  212.                 CHECK_HALF_MV(1, 1, mx  , my)

  213.             }

  214.             CHECK_HALF_MV(0, 1, mx  , my)

  215.         }

  216.         assert(bx >= xmin*2 && bx <= xmax*2 && by >= ymin*2 && by <= ymax*2);

  217.     }

  218. 

  219.     *mx_ptr = bx;

  220.     *my_ptr = by;

  221. 

  222.     return dmin;

  223. }

  224. #endif

  225. 

  226. static int no_sub_motion_search(MpegEncContext * s,

  227.           int *mx_ptr, int *my_ptr, int dmin,

  228.                                   int src_index, int ref_index,

  229.                                   int size, int h)

  230. {

  231.     (*mx_ptr)<<=1;

  232.     (*my_ptr)<<=1;

  233.     return dmin;

  234. }

  235. 

  236. inline int ff_get_mb_score(MpegEncContext * s, int mx, int my, int src_index,

  237.                                int ref_index, int size, int h, int add_rate)

  238. {

  239. //    const int check_luma= s->dsp.me_sub_cmp != s->dsp.mb_cmp;

  240.     MotionEstContext * const c= &s->me;

  241.     const int penalty_factor= c->mb_penalty_factor;

  242.     const int flags= c->mb_flags;

  243.     const int qpel= flags & FLAG_QPEL;

  244.     const int mask= 1+2*qpel;

  245.     me_cmp_func cmp_sub, chroma_cmp_sub;

  246.     int d;

  247. 

  248.     LOAD_COMMON

  249. 

  250.  //FIXME factorize

  251. 

  252.     cmp_sub= s->dsp.mb_cmp[size];

  253.     chroma_cmp_sub= s->dsp.mb_cmp[size+1];

  254. 

  255. //    assert(!c->skip);

  256. //    assert(c->avctx->me_sub_cmp != c->avctx->mb_cmp);

  257. 

  258.     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);

  259.     //FIXME check cbp before adding penalty for (0,0) vector

  260.     if(add_rate && (mx || my || size>0))

  261.         d += (mv_penalty[mx - pred_x] + mv_penalty[my - pred_y])*penalty_factor;

  262. 

  263.     return d;

  264. }

  265. 

  266. #define CHECK_QUARTER_MV(dx, dy, x, y)\

  267. {\

  268.     const int hx= 4*(x)+(dx);\

  269.     const int hy= 4*(y)+(dy);\

  270.     d= cmp(s, x, y, dx, dy, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\

  271.     d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\

  272.     COPY3_IF_LT(dmin, d, bx, hx, by, hy)\

  273. }

  274. 

  275. static int qpel_motion_search(MpegEncContext * s,

  276.                                   int *mx_ptr, int *my_ptr, int dmin,

  277.                                   int src_index, int ref_index,

  278.                                   int size, int h)

  279. {

  280.     MotionEstContext * const c= &s->me;

  281.     const int mx = *mx_ptr;

  282.     const int my = *my_ptr;

  283.     const int penalty_factor= c->sub_penalty_factor;

  284.     const int map_generation= c->map_generation;

  285.     const int subpel_quality= c->avctx->me_subpel_quality;

  286.     uint32_t *map= c->map;

  287.     me_cmp_func cmpf, chroma_cmpf;

  288.     me_cmp_func cmp_sub, chroma_cmp_sub;

  289. 

  290.     LOAD_COMMON

  291.     int flags= c->sub_flags;

  292. 

  293.     cmpf= s->dsp.me_cmp[size];

  294.     chroma_cmpf= s->dsp.me_cmp[size+1]; //factorize FIXME

  295.  //FIXME factorize

  296. 

  297.     cmp_sub= s->dsp.me_sub_cmp[size];

  298.     chroma_cmp_sub= s->dsp.me_sub_cmp[size+1];

  299. 

  300.     if(c->skip){ //FIXME somehow move up (benchmark)

  301.         *mx_ptr = 0;

  302.         *my_ptr = 0;

  303.         return dmin;

  304.     }

  305. 

  306.     if(c->avctx->me_cmp != c->avctx->me_sub_cmp){

  307.         dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);

  308.         if(mx || my || size>0)

  309.             dmin += (mv_penalty[4*mx - pred_x] + mv_penalty[4*my - pred_y])*penalty_factor;

  310.     }

  311. 

  312.     if (mx > xmin && mx < xmax &&

  313.         my > ymin && my < ymax) {

  314.         int bx=4*mx, by=4*my;

  315.         int d= dmin;

  316.         int i, nx, ny;

  317.         const int index= (my<<ME_MAP_SHIFT) + mx;

  318.         const int t= score_map[(index-(1<<ME_MAP_SHIFT)  )&(ME_MAP_SIZE-1)];

  319.         const int l= score_map[(index- 1                 )&(ME_MAP_SIZE-1)];

  320.         const int r= score_map[(index+ 1                 )&(ME_MAP_SIZE-1)];

  321.         const int b= score_map[(index+(1<<ME_MAP_SHIFT)  )&(ME_MAP_SIZE-1)];

  322.         const int c= score_map[(index                    )&(ME_MAP_SIZE-1)];

  323.         int best[8];

  324.         int best_pos[8][2];

  325. 

  326.         memset(best, 64, sizeof(int)*8);

  327. #if 1

  328.         if(s->me.dia_size>=2){

  329.             const int tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];

  330.             const int bl= score_map[(index+(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];

  331.             const int tr= score_map[(index-(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];

  332.             const int br= score_map[(index+(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];

  333. 

  334.             for(ny= -3; ny <= 3; ny++){

  335.                 for(nx= -3; nx <= 3; nx++){

  336.                     //FIXME this could overflow (unlikely though)

  337.                     const int64_t t2= nx*nx*(tr + tl - 2*t) + 4*nx*(tr-tl) + 32*t;

  338.                     const int64_t c2= nx*nx*( r +  l - 2*c) + 4*nx*( r- l) + 32*c;

  339.                     const int64_t b2= nx*nx*(br + bl - 2*b) + 4*nx*(br-bl) + 32*b;

  340.                     int score= (ny*ny*(b2 + t2 - 2*c2) + 4*ny*(b2 - t2) + 32*c2 + 512)>>10;

  341.                     int i;

  342. 

  343.                     if((nx&3)==0 && (ny&3)==0) continue;

  344. 

  345.                     score += (mv_penalty[4*mx + nx - pred_x] + mv_penalty[4*my + ny - pred_y])*penalty_factor;

  346. 

  347. //                    if(nx&1) score-=1024*c->penalty_factor;

  348. //                    if(ny&1) score-=1024*c->penalty_factor;

  349. 

  350.                     for(i=0; i<8; i++){

  351.                         if(score < best[i]){

  352.                             memmove(&best[i+1], &best[i], sizeof(int)*(7-i));

  353.                             memmove(&best_pos[i+1][0], &best_pos[i][0], sizeof(int)*2*(7-i));

  354.                             best[i]= score;

  355.                             best_pos[i][0]= nx + 4*mx;

  356.                             best_pos[i][1]= ny + 4*my;

  357.                             break;

  358.                         }

  359.                     }

  360.                 }

  361.             }

  362.         }else{

  363.             int tl;

  364.             //FIXME this could overflow (unlikely though)

  365.             const int cx = 4*(r - l);

  366.             const int cx2= r + l - 2*c;

  367.             const int cy = 4*(b - t);

  368.             const int cy2= b + t - 2*c;

  369.             int cxy;

  370. 

  371.             if(map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)] == (my<<ME_MAP_MV_BITS) + mx + map_generation && 0){ //FIXME

  372.                 tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];

  373.             }else{

  374.                 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

  375.             }

  376. 

  377.             cxy= 2*tl + (cx + cy)/4 - (cx2 + cy2) - 2*c;

  378. 

  379.             assert(16*cx2 + 4*cx + 32*c == 32*r);

  380.             assert(16*cx2 - 4*cx + 32*c == 32*l);

  381.             assert(16*cy2 + 4*cy + 32*c == 32*b);

  382.             assert(16*cy2 - 4*cy + 32*c == 32*t);

  383.             assert(16*cxy + 16*cy2 + 16*cx2 - 4*cy - 4*cx + 32*c == 32*tl);

  384. 

  385.             for(ny= -3; ny <= 3; ny++){

  386.                 for(nx= -3; nx <= 3; nx++){

  387.                     //FIXME this could overflow (unlikely though)

  388.                     int score= ny*nx*cxy + nx*nx*cx2 + ny*ny*cy2 + nx*cx + ny*cy + 32*c; //FIXME factor

  389.                     int i;

  390. 

  391.                     if((nx&3)==0 && (ny&3)==0) continue;

  392. 

  393.                     score += 32*(mv_penalty[4*mx + nx - pred_x] + mv_penalty[4*my + ny - pred_y])*penalty_factor;

  394. //                    if(nx&1) score-=32*c->penalty_factor;

  395.   //                  if(ny&1) score-=32*c->penalty_factor;

  396. 

  397.                     for(i=0; i<8; i++){

  398.                         if(score < best[i]){

  399.                             memmove(&best[i+1], &best[i], sizeof(int)*(7-i));

  400.                             memmove(&best_pos[i+1][0], &best_pos[i][0], sizeof(int)*2*(7-i));

  401.                             best[i]= score;

  402.                             best_pos[i][0]= nx + 4*mx;

  403.                             best_pos[i][1]= ny + 4*my;

  404.                             break;

  405.                         }

  406.                     }

  407.                 }

  408.             }

  409.         }

  410.         for(i=0; i<subpel_quality; i++){

  411.             nx= best_pos[i][0];

  412.             ny= best_pos[i][1];

  413.             CHECK_QUARTER_MV(nx&3, ny&3, nx>>2, ny>>2)

  414.         }

  415. 

  416. #if 0

  417.             const int tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];

  418.             const int bl= score_map[(index+(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];

  419.             const int tr= score_map[(index-(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];

  420.             const int br= score_map[(index+(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];

  421. //            if(l < r && l < t && l < b && l < tl && l < bl && l < tr && l < br && bl < tl){

  422.             if(tl<br){

  423. 

  424. //            nx= FFMAX(4*mx - bx, bx - 4*mx);

  425. //            ny= FFMAX(4*my - by, by - 4*my);

  426. 

  427.             static int stats[7][7], count;

  428.             count++;

  429.             stats[4*mx - bx + 3][4*my - by + 3]++;

  430.             if(256*256*256*64 % count ==0){

  431.                 for(i=0; i<49; i++){

  432.                     if((i%7)==0) printf("\n");

  433.                     printf("%6d ", stats[0][i]);

  434.                 }

  435.                 printf("\n");

  436.             }

  437.             }

  438. #endif

  439. #else

  440. 

  441.         CHECK_QUARTER_MV(2, 2, mx-1, my-1)

  442.         CHECK_QUARTER_MV(0, 2, mx  , my-1)

  443.         CHECK_QUARTER_MV(2, 2, mx  , my-1)

  444.         CHECK_QUARTER_MV(2, 0, mx  , my  )

  445.         CHECK_QUARTER_MV(2, 2, mx  , my  )

  446.         CHECK_QUARTER_MV(0, 2, mx  , my  )

  447.         CHECK_QUARTER_MV(2, 2, mx-1, my  )

  448.         CHECK_QUARTER_MV(2, 0, mx-1, my  )

  449. 

  450.         nx= bx;

  451.         ny= by;

  452. 

  453.         for(i=0; i<8; i++){

  454.             int ox[8]= {0, 1, 1, 1, 0,-1,-1,-1};

  455.             int oy[8]= {1, 1, 0,-1,-1,-1, 0, 1};

  456.             CHECK_QUARTER_MV((nx + ox[i])&3, (ny + oy[i])&3, (nx + ox[i])>>2, (ny + oy[i])>>2)

  457.         }

  458. #endif

  459. #if 0

  460.         //outer ring

  461.         CHECK_QUARTER_MV(1, 3, mx-1, my-1)

  462.         CHECK_QUARTER_MV(1, 2, mx-1, my-1)

  463.         CHECK_QUARTER_MV(1, 1, mx-1, my-1)

  464.         CHECK_QUARTER_MV(2, 1, mx-1, my-1)

  465.         CHECK_QUARTER_MV(3, 1, mx-1, my-1)

  466.         CHECK_QUARTER_MV(0, 1, mx  , my-1)

  467.         CHECK_QUARTER_MV(1, 1, mx  , my-1)

  468.         CHECK_QUARTER_MV(2, 1, mx  , my-1)

  469.         CHECK_QUARTER_MV(3, 1, mx  , my-1)

  470.         CHECK_QUARTER_MV(3, 2, mx  , my-1)

  471.         CHECK_QUARTER_MV(3, 3, mx  , my-1)

  472.         CHECK_QUARTER_MV(3, 0, mx  , my  )

  473.         CHECK_QUARTER_MV(3, 1, mx  , my  )

  474.         CHECK_QUARTER_MV(3, 2, mx  , my  )

  475.         CHECK_QUARTER_MV(3, 3, mx  , my  )

  476.         CHECK_QUARTER_MV(2, 3, mx  , my  )

  477.         CHECK_QUARTER_MV(1, 3, mx  , my  )

  478.         CHECK_QUARTER_MV(0, 3, mx  , my  )

  479.         CHECK_QUARTER_MV(3, 3, mx-1, my  )

  480.         CHECK_QUARTER_MV(2, 3, mx-1, my  )

  481.         CHECK_QUARTER_MV(1, 3, mx-1, my  )

  482.         CHECK_QUARTER_MV(1, 2, mx-1, my  )

  483.         CHECK_QUARTER_MV(1, 1, mx-1, my  )

  484.         CHECK_QUARTER_MV(1, 0, mx-1, my  )

  485. #endif

  486.         assert(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);

  487. 

  488.         *mx_ptr = bx;

  489.         *my_ptr = by;

  490.     }else{

  491.         *mx_ptr =4*mx;

  492.         *my_ptr =4*my;

  493.     }

  494. 

  495.     return dmin;

  496. }

  497. 

  498. 

  499. #define CHECK_MV(x,y)\

  500. {\

  501.     const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\

  502.     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\

  503.     assert((x) >= xmin);\

  504.     assert((x) <= xmax);\

  505.     assert((y) >= ymin);\

  506.     assert((y) <= ymax);\

  507. /*printf("check_mv %d %d\n", x, y);*/\

  508.     if(map[index]!=key){\

  509.         d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\

  510.         map[index]= key;\

  511.         score_map[index]= d;\

  512.         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\

  513. /*printf("score:%d\n", d);*/\

  514.         COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\

  515.     }\

  516. }

  517. 

  518. #define CHECK_CLIPPED_MV(ax,ay)\

  519. {\

  520.     const int Lx= ax;\

  521.     const int Ly= ay;\

  522.     const int Lx2= FFMAX(xmin, FFMIN(Lx, xmax));\

  523.     const int Ly2= FFMAX(ymin, FFMIN(Ly, ymax));\

  524.     CHECK_MV(Lx2, Ly2)\

  525. }

  526. 

  527. #define CHECK_MV_DIR(x,y,new_dir)\

  528. {\

  529.     const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\

  530.     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\

  531. /*printf("check_mv_dir %d %d %d\n", x, y, new_dir);*/\

  532.     if(map[index]!=key){\

  533.         d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\

  534.         map[index]= key;\

  535.         score_map[index]= d;\

  536.         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\

  537. /*printf("score:%d\n", d);*/\

  538.         if(d<dmin){\

  539.             best[0]=x;\

  540.             best[1]=y;\

  541.             dmin=d;\

  542.             next_dir= new_dir;\

  543.         }\

  544.     }\

  545. }

  546. 

  547. #define check(x,y,S,v)\

  548. if( (x)<(xmin<<(S)) ) printf("%d %d %d %d %d xmin" #v, xmin, (x), (y), s->mb_x, s->mb_y);\

  549. if( (x)>(xmax<<(S)) ) printf("%d %d %d %d %d xmax" #v, xmax, (x), (y), s->mb_x, s->mb_y);\

  550. if( (y)<(ymin<<(S)) ) printf("%d %d %d %d %d ymin" #v, ymin, (x), (y), s->mb_x, s->mb_y);\

  551. if( (y)>(ymax<<(S)) ) printf("%d %d %d %d %d ymax" #v, ymax, (x), (y), s->mb_x, s->mb_y);\

  552. 

  553. #define LOAD_COMMON2\

  554.     uint32_t *map= c->map;\

  555.     const int qpel= flags&FLAG_QPEL;\

  556.     const int shift= 1+qpel;\

  557. 

  558. static av_always_inline int small_diamond_search(MpegEncContext * s, int *best, int dmin,

  559.                                        int src_index, int ref_index, int const penalty_factor,

  560.                                        int size, int h, int flags)

  561. {

  562.     MotionEstContext * const c= &s->me;

  563.     me_cmp_func cmpf, chroma_cmpf;

  564.     int next_dir=-1;

  565.     LOAD_COMMON

  566.     LOAD_COMMON2

  567.     int map_generation= c->map_generation;

  568. 

  569.     cmpf= s->dsp.me_cmp[size];

  570.     chroma_cmpf= s->dsp.me_cmp[size+1];

  571. 

  572.     { /* ensure that the best point is in the MAP as h/qpel refinement needs it */

  573.         const int key= (best[1]<<ME_MAP_MV_BITS) + best[0] + map_generation;

  574.         const int index= ((best[1]<<ME_MAP_SHIFT) + best[0])&(ME_MAP_SIZE-1);

  575.         if(map[index]!=key){ //this will be executed only very rarey

  576.             score_map[index]= cmp(s, best[0], best[1], 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);

  577.             map[index]= key;

  578.         }

  579.     }

  580. 

  581.     for(;;){

  582.         int d;

  583.         const int dir= next_dir;

  584.         const int x= best[0];

  585.         const int y= best[1];

  586.         next_dir=-1;

  587. 

  588. //printf("%d", dir);

  589.         if(dir!=2 && x>xmin) CHECK_MV_DIR(x-1, y  , 0)

  590.         if(dir!=3 && y>ymin) CHECK_MV_DIR(x  , y-1, 1)

  591.         if(dir!=0 && x<xmax) CHECK_MV_DIR(x+1, y  , 2)

  592.         if(dir!=1 && y<ymax) CHECK_MV_DIR(x  , y+1, 3)

  593. 

  594.         if(next_dir==-1){

  595.             return dmin;

  596.         }

  597.     }

  598. }

  599. 

  600. static int funny_diamond_search(MpegEncContext * s, int *best, int dmin,

  601.                                        int src_index, int ref_index, int const penalty_factor,

  602.                                        int size, int h, int flags)

  603. {

  604.     MotionEstContext * const c= &s->me;

  605.     me_cmp_func cmpf, chroma_cmpf;

  606.     int dia_size;

  607.     LOAD_COMMON

  608.     LOAD_COMMON2

  609.     int map_generation= c->map_generation;

  610. 

  611.     cmpf= s->dsp.me_cmp[size];

  612.     chroma_cmpf= s->dsp.me_cmp[size+1];

  613. 

  614.     for(dia_size=1; dia_size<=4; dia_size++){

  615.         int dir;

  616.         const int x= best[0];

  617.         const int y= best[1];

  618. 

  619.         if(dia_size&(dia_size-1)) continue;

  620. 

  621.         if(   x + dia_size > xmax

  622.            || x - dia_size < xmin

  623.            || y + dia_size > ymax

  624.            || y - dia_size < ymin)

  625.            continue;

  626. 

  627.         for(dir= 0; dir<dia_size; dir+=2){

  628.             int d;

  629. 

  630.             CHECK_MV(x + dir           , y + dia_size - dir);

  631.             CHECK_MV(x + dia_size - dir, y - dir           );

  632.             CHECK_MV(x - dir           , y - dia_size + dir);

  633.             CHECK_MV(x - dia_size + dir, y + dir           );

  634.         }

  635. 

  636.         if(x!=best[0] || y!=best[1])

  637.             dia_size=0;

  638. #if 0

  639. {

  640. int dx, dy, i;

  641. static int stats[8*8];

  642. dx= FFABS(x-best[0]);

  643. dy= FFABS(y-best[1]);

  644. if(dy>dx){

  645.     dx^=dy; dy^=dx; dx^=dy;

  646. }

  647. stats[dy*8 + dx] ++;

  648. if(256*256*256*64 % (stats[0]+1)==0){

  649.     for(i=0; i<64; i++){

  650.         if((i&7)==0) printf("\n");

  651.         printf("%8d ", stats[i]);

  652.     }

  653.     printf("\n");

  654. }

  655. }

  656. #endif

  657.     }

  658.     return dmin;

  659. }

  660. 

  661. static int hex_search(MpegEncContext * s, int *best, int dmin,

  662.                                        int src_index, int ref_index, int const penalty_factor,

  663.                                        int size, int h, int flags, int dia_size)

  664. {

  665.     MotionEstContext * const c= &s->me;

  666.     me_cmp_func cmpf, chroma_cmpf;

  667.     LOAD_COMMON

  668.     LOAD_COMMON2

  669.     int map_generation= c->map_generation;

  670.     int x,y,d;

  671.     const int dec= dia_size & (dia_size-1);

  672. 

  673.     cmpf= s->dsp.me_cmp[size];

  674.     chroma_cmpf= s->dsp.me_cmp[size+1];

  675. 

  676.     for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){

  677.         do{

  678.             x= best[0];

  679.             y= best[1];

  680. 

  681.             CHECK_CLIPPED_MV(x  -dia_size    , y);

  682.             CHECK_CLIPPED_MV(x+  dia_size    , y);

  683.             CHECK_CLIPPED_MV(x+( dia_size>>1), y+dia_size);

  684.             CHECK_CLIPPED_MV(x+( dia_size>>1), y-dia_size);

  685.             if(dia_size>1){

  686.                 CHECK_CLIPPED_MV(x+(-dia_size>>1), y+dia_size);

  687.                 CHECK_CLIPPED_MV(x+(-dia_size>>1), y-dia_size);

  688.             }

  689.         }while(best[0] != x || best[1] != y);

  690.     }

  691. 

  692.     return dmin;

  693. }

  694. 

  695. static int l2s_dia_search(MpegEncContext * s, int *best, int dmin,

  696.                                        int src_index, int ref_index, int const penalty_factor,

  697.                                        int size, int h, int flags)

  698. {

  699.     MotionEstContext * const c= &s->me;

  700.     me_cmp_func cmpf, chroma_cmpf;

  701.     LOAD_COMMON

  702.     LOAD_COMMON2

  703.     int map_generation= c->map_generation;

  704.     int x,y,i,d;

  705.     int dia_size= c->dia_size&0xFF;

  706.     const int dec= dia_size & (dia_size-1);

  707.     static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1},

  708.                                 { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}};

  709. 

  710.     cmpf= s->dsp.me_cmp[size];

  711.     chroma_cmpf= s->dsp.me_cmp[size+1];

  712. 

  713.     for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){

  714.         do{

  715.             x= best[0];

  716.             y= best[1];

  717.             for(i=0; i<8; i++){

  718.                 CHECK_CLIPPED_MV(x+hex[i][0]*dia_size, y+hex[i][1]*dia_size);

  719.             }

  720.         }while(best[0] != x || best[1] != y);

  721.     }

  722. 

  723.     x= best[0];

  724.     y= best[1];

  725.     CHECK_CLIPPED_MV(x+1, y);

  726.     CHECK_CLIPPED_MV(x, y+1);

  727.     CHECK_CLIPPED_MV(x-1, y);

  728.     CHECK_CLIPPED_MV(x, y-1);

  729. 

  730.     return dmin;

  731. }

  732. 

  733. static int umh_search(MpegEncContext * s, int *best, int dmin,

  734.                                        int src_index, int ref_index, int const penalty_factor,

  735.                                        int size, int h, int flags)

  736. {

  737.     MotionEstContext * const c= &s->me;

  738.     me_cmp_func cmpf, chroma_cmpf;

  739.     LOAD_COMMON

  740.     LOAD_COMMON2

  741.     int map_generation= c->map_generation;

  742.     int x,y,x2,y2, i, j, d;

  743.     const int dia_size= c->dia_size&0xFE;

  744.     static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2},

  745.                                  { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2},

  746.                                  {-2, 3}, { 0, 4}, { 2, 3},

  747.                                  {-2,-3}, { 0,-4}, { 2,-3},};

  748. 

  749.     cmpf= s->dsp.me_cmp[size];

  750.     chroma_cmpf= s->dsp.me_cmp[size+1];

  751. 

  752.     x= best[0];

  753.     y= best[1];

  754.     for(x2=FFMAX(x-dia_size+1, xmin); x2<=FFMIN(x+dia_size-1,xmax); x2+=2){

  755.         CHECK_MV(x2, y);

  756.     }

  757.     for(y2=FFMAX(y-dia_size/2+1, ymin); y2<=FFMIN(y+dia_size/2-1,ymax); y2+=2){

  758.         CHECK_MV(x, y2);

  759.     }

  760. 

  761.     x= best[0];

  762.     y= best[1];

  763.     for(y2=FFMAX(y-2, ymin); y2<=FFMIN(y+2,ymax); y2++){

  764.         for(x2=FFMAX(x-2, xmin); x2<=FFMIN(x+2,xmax); x2++){

  765.             CHECK_MV(x2, y2);

  766.         }

  767.     }

  768. 

  769. //FIXME prevent the CLIP stuff

  770. 

  771.     for(j=1; j<=dia_size/4; j++){

  772.         for(i=0; i<16; i++){

  773.             CHECK_CLIPPED_MV(x+hex[i][0]*j, y+hex[i][1]*j);

  774.         }

  775.     }

  776. 

  777.     return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2);

  778. }

  779. 

  780. #define SAB_CHECK_MV(ax,ay)\

  781. {\

  782.     const int key= ((ay)<<ME_MAP_MV_BITS) + (ax) + map_generation;\

  783.     const int index= (((ay)<<ME_MAP_SHIFT) + (ax))&(ME_MAP_SIZE-1);\

  784. /*printf("sab check %d %d\n", ax, ay);*/\

  785.     if(map[index]!=key){\

  786.         d= cmp(s, ax, ay, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\

  787.         map[index]= key;\

  788.         score_map[index]= d;\

  789.         d += (mv_penalty[((ax)<<shift)-pred_x] + mv_penalty[((ay)<<shift)-pred_y])*penalty_factor;\

  790. /*printf("score: %d\n", d);*/\

  791.         if(d < minima[minima_count-1].height){\

  792.             int j=0;\

  793.             \

  794.             while(d >= minima[j].height) j++;\

  795. \

  796.             memmove(&minima [j+1], &minima [j], (minima_count - j - 1)*sizeof(Minima));\

  797. \

  798.             minima[j].checked= 0;\

  799.             minima[j].height= d;\

  800.             minima[j].x= ax;\

  801.             minima[j].y= ay;\

  802.             \

  803.             i=-1;\

  804.             continue;\

  805.         }\

  806.     }\

  807. }

  808. 

  809. #define MAX_SAB_SIZE ME_MAP_SIZE

  810. static int sab_diamond_search(MpegEncContext * s, int *best, int dmin,

  811.                                        int src_index, int ref_index, int const penalty_factor,

  812.                                        int size, int h, int flags)

  813. {

  814.     MotionEstContext * const c= &s->me;

  815.     me_cmp_func cmpf, chroma_cmpf;

  816.     Minima minima[MAX_SAB_SIZE];

  817.     const int minima_count= FFABS(c->dia_size);

  818.     int i, j;

  819.     LOAD_COMMON

  820.     LOAD_COMMON2

  821.     int map_generation= c->map_generation;

  822. 

  823.     cmpf= s->dsp.me_cmp[size];

  824.     chroma_cmpf= s->dsp.me_cmp[size+1];

  825. 

  826.     /*Note j<MAX_SAB_SIZE is needed if MAX_SAB_SIZE < ME_MAP_SIZE as j can

  827.       become larger due to MVs overflowing their ME_MAP_MV_BITS bits space in map

  828.      */

  829.     for(j=i=0; i<ME_MAP_SIZE && j<MAX_SAB_SIZE; i++){

  830.         uint32_t key= map[i];

  831. 

  832.         key += (1<<(ME_MAP_MV_BITS-1)) + (1<<(2*ME_MAP_MV_BITS-1));

  833. 

  834.         if((key&((-1)<<(2*ME_MAP_MV_BITS))) != map_generation) continue;

  835. 

  836.         minima[j].height= score_map[i];

  837.         minima[j].x= key & ((1<<ME_MAP_MV_BITS)-1); key>>=ME_MAP_MV_BITS;

  838.         minima[j].y= key & ((1<<ME_MAP_MV_BITS)-1);

  839.         minima[j].x-= (1<<(ME_MAP_MV_BITS-1));

  840.         minima[j].y-= (1<<(ME_MAP_MV_BITS-1));

  841. 

  842.         // all entries in map should be in range except if the mv overflows their ME_MAP_MV_BITS bits space

  843.         if(   minima[j].x > xmax || minima[j].x < xmin

  844.            || minima[j].y > ymax || minima[j].y < ymin)

  845.             continue;

  846. 

  847.         minima[j].checked=0;

  848.         if(minima[j].x || minima[j].y)

  849.             minima[j].height+= (mv_penalty[((minima[j].x)<<shift)-pred_x] + mv_penalty[((minima[j].y)<<shift)-pred_y])*penalty_factor;

  850. 

  851.         j++;

  852.     }

  853. 

  854.     qsort(minima, j, sizeof(Minima), minima_cmp);

  855. 

  856.     for(; j<minima_count; j++){

  857.         minima[j].height=256*256*256*64;

  858.         minima[j].checked=0;

  859.         minima[j].x= minima[j].y=0;

  860.     }

  861. 

  862.     for(i=0; i<minima_count; i++){

  863.         const int x= minima[i].x;

  864.         const int y= minima[i].y;

  865.         int d;

  866. 

  867.         if(minima[i].checked) continue;

  868. 

  869.         if(   x >= xmax || x <= xmin

  870.            || y >= ymax || y <= ymin)

  871.            continue;

  872. 

  873.         SAB_CHECK_MV(x-1, y)

  874.         SAB_CHECK_MV(x+1, y)

  875.         SAB_CHECK_MV(x  , y-1)

  876.         SAB_CHECK_MV(x  , y+1)

  877. 

  878.         minima[i].checked= 1;

  879.     }

  880. 

  881.     best[0]= minima[0].x;

  882.     best[1]= minima[0].y;

  883.     dmin= minima[0].height;

  884. 

  885.     if(   best[0] < xmax && best[0] > xmin

  886.        && best[1] < ymax && best[1] > ymin){

  887.         int d;

  888.         //ensure that the refernece samples for hpel refinement are in the map

  889.         CHECK_MV(best[0]-1, best[1])

  890.         CHECK_MV(best[0]+1, best[1])

  891.         CHECK_MV(best[0], best[1]-1)

  892.         CHECK_MV(best[0], best[1]+1)

  893.     }

  894.     return dmin;

  895. }

  896. 

  897. static int var_diamond_search(MpegEncContext * s, int *best, int dmin,

  898.                                        int src_index, int ref_index, int const penalty_factor,

  899.                                        int size, int h, int flags)

  900. {

  901.     MotionEstContext * const c= &s->me;

  902.     me_cmp_func cmpf, chroma_cmpf;

  903.     int dia_size;

  904.     LOAD_COMMON

  905.     LOAD_COMMON2

  906.     int map_generation= c->map_generation;

  907. 

  908.     cmpf= s->dsp.me_cmp[size];

  909.     chroma_cmpf= s->dsp.me_cmp[size+1];

  910. 

  911.     for(dia_size=1; dia_size<=c->dia_size; dia_size++){

  912.         int dir, start, end;

  913.         const int x= best[0];

  914.         const int y= best[1];

  915. 

  916.         start= FFMAX(0, y + dia_size - ymax);

  917.         end  = FFMIN(dia_size, xmax - x + 1);

  918.         for(dir= start; dir<end; dir++){

  919.             int d;

  920. 

  921. //check(x + dir,y + dia_size - dir,0, a0)

  922.             CHECK_MV(x + dir           , y + dia_size - dir);

  923.         }

  924. 

  925.         start= FFMAX(0, x + dia_size - xmax);

  926.         end  = FFMIN(dia_size, y - ymin + 1);

  927.         for(dir= start; dir<end; dir++){

  928.             int d;

  929. 

  930. //check(x + dia_size - dir, y - dir,0, a1)

  931.             CHECK_MV(x + dia_size - dir, y - dir           );

  932.         }

  933. 

  934.         start= FFMAX(0, -y + dia_size + ymin );

  935.         end  = FFMIN(dia_size, x - xmin + 1);

  936.         for(dir= start; dir<end; dir++){

  937.             int d;

  938. 

  939. //check(x - dir,y - dia_size + dir,0, a2)

  940.             CHECK_MV(x - dir           , y - dia_size + dir);

  941.         }

  942. 

  943.         start= FFMAX(0, -x + dia_size + xmin );

  944.         end  = FFMIN(dia_size, ymax - y + 1);

  945.         for(dir= start; dir<end; dir++){

  946.             int d;

  947. 

  948. //check(x - dia_size + dir, y + dir,0, a3)

  949.             CHECK_MV(x - dia_size + dir, y + dir           );

  950.         }

  951. 

  952.         if(x!=best[0] || y!=best[1])

  953.             dia_size=0;

  954. #if 0

  955. {

  956. int dx, dy, i;

  957. static int stats[8*8];

  958. dx= FFABS(x-best[0]);

  959. dy= FFABS(y-best[1]);

  960. stats[dy*8 + dx] ++;

  961. if(256*256*256*64 % (stats[0]+1)==0){

  962.     for(i=0; i<64; i++){

  963.         if((i&7)==0) printf("\n");

  964.         printf("%6d ", stats[i]);

  965.     }

  966.     printf("\n");

  967. }

  968. }

  969. #endif

  970.     }

  971.     return dmin;

  972. }

  973. 

  974. static av_always_inline int diamond_search(MpegEncContext * s, int *best, int dmin,

  975.                                        int src_index, int ref_index, int const penalty_factor,

  976.                                        int size, int h, int flags){

  977.     MotionEstContext * const c= &s->me;

  978.     if(c->dia_size==-1)

  979.         return funny_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);

  980.     else if(c->dia_size<-1)

  981.         return   sab_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);

  982.     else if(c->dia_size<2)

  983.         return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);

  984.     else if(c->dia_size>768)

  985.         return           umh_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);

  986.     else if(c->dia_size>512)

  987.         return           hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, c->dia_size&0xFF);

  988.     else if(c->dia_size>256)

  989.         return       l2s_dia_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);

  990.     else

  991.         return   var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);

  992. }

  993. 

  994. /*!

  995.    \param P[10][2] a list of candidate mvs to check before starting the

  996.    iterative search. If one of the candidates is close to the optimal mv, then

  997.    it takes fewer iterations. And it increases the chance that we find the

  998.    optimal mv.

  999.  */

  1000. static av_always_inline int epzs_motion_search_internal(MpegEncContext * s, int *mx_ptr, int *my_ptr,

  1001.                              int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2],

  1002.                              int ref_mv_scale, int flags, int size, int h)

  1003. {

  1004.     MotionEstContext * const c= &s->me;

  1005.     int best[2]={0, 0};      /*!< x and y coordinates of the best motion vector.

  1006.                                i.e. the difference between the position of the

  1007.                                block currently being encoded and the position of

  1008.                                the block chosen to predict it from. */

  1009.     int d;                   ///< the score (cmp + penalty) of any given mv

  1010.     int dmin;                /*!< the best value of d, i.e. the score

  1011.                                corresponding to the mv stored in best[]. */

  1012.     int map_generation;

  1013.     int penalty_factor;

  1014.     const int ref_mv_stride= s->mb_stride; //pass as arg  FIXME

  1015.     const int ref_mv_xy= s->mb_x + s->mb_y*ref_mv_stride; //add to last_mv beforepassing FIXME

  1016.     me_cmp_func cmpf, chroma_cmpf;

  1017. 

  1018.     LOAD_COMMON

  1019.     LOAD_COMMON2

  1020. 

  1021.     if(c->pre_pass){

  1022.         penalty_factor= c->pre_penalty_factor;

  1023.         cmpf= s->dsp.me_pre_cmp[size];

  1024.         chroma_cmpf= s->dsp.me_pre_cmp[size+1];

  1025.     }else{

  1026.         penalty_factor= c->penalty_factor;

  1027.         cmpf= s->dsp.me_cmp[size];

  1028.         chroma_cmpf= s->dsp.me_cmp[size+1];

  1029.     }

  1030. 

  1031.     map_generation= update_map_generation(c);

  1032. 

  1033.     assert(cmpf);

  1034.     dmin= cmp(s, 0, 0, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);

  1035.     map[0]= map_generation;

  1036.     score_map[0]= dmin;

  1037. 

  1038.     //FIXME precalc first term below?

  1039.     if((s->pict_type == B_TYPE && !(c->flags & FLAG_DIRECT)) || s->flags&CODEC_FLAG_MV0)

  1040.         dmin += (mv_penalty[pred_x] + mv_penalty[pred_y])*penalty_factor;

  1041. 

  1042.     /* first line */

  1043.     if (s->first_slice_line) {

  1044.         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)

  1045.         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,

  1046.                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)

  1047.     }else{

  1048.         if(dmin<((h*h*s->avctx->mv0_threshold)>>8)

  1049.                     && ( P_LEFT[0]    |P_LEFT[1]

  1050.                         |P_TOP[0]     |P_TOP[1]

  1051.                         |P_TOPRIGHT[0]|P_TOPRIGHT[1])==0){

  1052.             *mx_ptr= 0;

  1053.             *my_ptr= 0;

  1054.             c->skip=1;

  1055.             return dmin;

  1056.         }

  1057.         CHECK_MV(    P_MEDIAN[0] >>shift ,    P_MEDIAN[1] >>shift)

  1058.         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)  , (P_MEDIAN[1]>>shift)-1)

  1059.         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)  , (P_MEDIAN[1]>>shift)+1)

  1060.         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)-1, (P_MEDIAN[1]>>shift)  )

  1061.         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)+1, (P_MEDIAN[1]>>shift)  )

  1062.         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,

  1063.                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)

  1064.         CHECK_MV(P_LEFT[0]    >>shift, P_LEFT[1]    >>shift)

  1065.         CHECK_MV(P_TOP[0]     >>shift, P_TOP[1]     >>shift)

  1066.         CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)

  1067.     }

  1068.     if(dmin>h*h*4){

  1069.         if(c->pre_pass){

  1070.             CHECK_CLIPPED_MV((last_mv[ref_mv_xy-1][0]*ref_mv_scale + (1<<15))>>16,

  1071.                             (last_mv[ref_mv_xy-1][1]*ref_mv_scale + (1<<15))>>16)

  1072.             if(!s->first_slice_line)

  1073.                 CHECK_CLIPPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,

  1074.                                 (last_mv[ref_mv_xy-ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)

  1075.         }else{

  1076.             CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,

  1077.                             (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)

  1078.             if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line

  1079.                 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,

  1080.                                 (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)

  1081.         }

  1082.     }

  1083. 

  1084.     if(c->avctx->last_predictor_count){

  1085.         const int count= c->avctx->last_predictor_count;

  1086.         const int xstart= FFMAX(0, s->mb_x - count);

  1087.         const int ystart= FFMAX(0, s->mb_y - count);

  1088.         const int xend= FFMIN(s->mb_width , s->mb_x + count + 1);

  1089.         const int yend= FFMIN(s->mb_height, s->mb_y + count + 1);

  1090.         int mb_y;

  1091. 

  1092.         for(mb_y=ystart; mb_y<yend; mb_y++){

  1093.             int mb_x;

  1094.             for(mb_x=xstart; mb_x<xend; mb_x++){

  1095.                 const int xy= mb_x + 1 + (mb_y + 1)*ref_mv_stride;

  1096.                 int mx= (last_mv[xy][0]*ref_mv_scale + (1<<15))>>16;

  1097.                 int my= (last_mv[xy][1]*ref_mv_scale + (1<<15))>>16;

  1098. 

  1099.                 if(mx>xmax || mx<xmin || my>ymax || my<ymin) continue;

  1100.                 CHECK_MV(mx,my)

  1101.             }

  1102.         }

  1103.     }

  1104. 

  1105. //check(best[0],best[1],0, b0)

  1106.     dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);

  1107. 

  1108. //check(best[0],best[1],0, b1)

  1109.     *mx_ptr= best[0];

  1110.     *my_ptr= best[1];

  1111. 

  1112. //    printf("%d %d %d \n", best[0], best[1], dmin);

  1113.     return dmin;

  1114. }

  1115. 

  1116. //this function is dedicated to the braindamaged gcc

  1117. inline int ff_epzs_motion_search(MpegEncContext * s, int *mx_ptr, int *my_ptr,

  1118.                              int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2],

  1119.                              int ref_mv_scale, int size, int h)

  1120. {

  1121.     MotionEstContext * const c= &s->me;

  1122. //FIXME convert other functions in the same way if faster

  1123.     if(c->flags==0 && h==16 && size==0){

  1124.         return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, 0, 0, 16);

  1125. //    case FLAG_QPEL:

  1126. //        return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, FLAG_QPEL);

  1127.     }else{

  1128.         return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, c->flags, size, h);

  1129.     }

  1130. }

  1131. 

  1132. static int epzs_motion_search4(MpegEncContext * s,

  1133.                              int *mx_ptr, int *my_ptr, int P[10][2],

  1134.                              int src_index, int ref_index, int16_t (*last_mv)[2],

  1135.                              int ref_mv_scale)

  1136. {

  1137.     MotionEstContext * const c= &s->me;

  1138.     int best[2]={0, 0};

  1139.     int d, dmin;

  1140.     int map_generation;

  1141.     const int penalty_factor= c->penalty_factor;

  1142.     const int size=1;

  1143.     const int h=8;

  1144.     const int ref_mv_stride= s->mb_stride;

  1145.     const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride;

  1146.     me_cmp_func cmpf, chroma_cmpf;

  1147.     LOAD_COMMON

  1148.     int flags= c->flags;

  1149.     LOAD_COMMON2

  1150. 

  1151.     cmpf= s->dsp.me_cmp[size];

  1152.     chroma_cmpf= s->dsp.me_cmp[size+1];

  1153. 

  1154.     map_generation= update_map_generation(c);

  1155. 

  1156.     dmin = 1000000;

  1157. //printf("%d %d %d %d //",xmin, ymin, xmax, ymax);

  1158.     /* first line */

  1159.     if (s->first_slice_line) {

  1160.         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)

  1161.         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,

  1162.                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)

  1163.         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)

  1164.     }else{

  1165.         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)

  1166.         //FIXME try some early stop

  1167.         CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)

  1168.         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)

  1169.         CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)

  1170.         CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)

  1171.         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,

  1172.                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)

  1173.     }

  1174.     if(dmin>64*4){

  1175.         CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,

  1176.                         (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)

  1177.         if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line

  1178.             CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,

  1179.                             (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)

  1180.     }

  1181. 

  1182.     dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);

  1183. 

  1184.     *mx_ptr= best[0];

  1185.     *my_ptr= best[1];

  1186. 

  1187. //    printf("%d %d %d \n", best[0], best[1], dmin);

  1188.     return dmin;

  1189. }

  1190. 

  1191. //try to merge with above FIXME (needs PSNR test)

  1192. static int epzs_motion_search2(MpegEncContext * s,

  1193.                              int *mx_ptr, int *my_ptr, int P[10][2],

  1194.                              int src_index, int ref_index, int16_t (*last_mv)[2],

  1195.                              int ref_mv_scale)

  1196. {

  1197.     MotionEstContext * const c= &s->me;

  1198.     int best[2]={0, 0};

  1199.     int d, dmin;

  1200.     int map_generation;

  1201.     const int penalty_factor= c->penalty_factor;

  1202.     const int size=0; //FIXME pass as arg

  1203.     const int h=8;

  1204.     const int ref_mv_stride= s->mb_stride;

  1205.     const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride;

  1206.     me_cmp_func cmpf, chroma_cmpf;

  1207.     LOAD_COMMON

  1208.     int flags= c->flags;

  1209.     LOAD_COMMON2

  1210. 

  1211.     cmpf= s->dsp.me_cmp[size];

  1212.     chroma_cmpf= s->dsp.me_cmp[size+1];

  1213. 

  1214.     map_generation= update_map_generation(c);

  1215. 

  1216.     dmin = 1000000;

  1217. //printf("%d %d %d %d //",xmin, ymin, xmax, ymax);

  1218.     /* first line */

  1219.     if (s->first_slice_line) {

  1220.         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)

  1221.         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,

  1222.                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)

  1223.         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)

  1224.     }else{

  1225.         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)

  1226.         //FIXME try some early stop

  1227.         CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)

  1228.         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)

  1229.         CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)

  1230.         CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)

  1231.         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,

  1232.                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)

  1233.     }

  1234.     if(dmin>64*4){

  1235.         CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,

  1236.                         (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)

  1237.         if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line

  1238.             CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,

  1239.                             (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)

  1240.     }

  1241. 

  1242.     dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);

  1243. 

  1244.     *mx_ptr= best[0];

  1245.     *my_ptr= best[1];

  1246. 

  1247. //    printf("%d %d %d \n", best[0], best[1], dmin);

  1248.     return dmin;

  1249. }