diff motion_est_template.c @ 1950:a3c60fa850dc libavcodec

motion estimation cleanup replace ugly macros by always_inline functions, that way its much more readable and flexible as always_inline can simply be removed while the macros couldnt be about 0.5 % speedup with default parameters

--- a/motion_est_template.c	Tue Apr 20 17:05:12 2004 +0000
+++ b/motion_est_template.c	Thu Apr 22 03:31:29 2004 +0000
@@ -22,58 +22,32 @@
  * @file motion_est_template.c
  * Motion estimation template.
  */
-//FIXME ref2_y next_pic?
+
 //lets hope gcc will remove the unused vars ...(gcc 3.2.2 seems to do it ...)
-//Note, the last line is there to kill these ugly unused var warnings
 #define LOAD_COMMON\
     uint32_t * const score_map= s->me.score_map;\
-    const int time_pp= s->pp_time;\
-    const int time_pb= s->pb_time;\
     const int xmin= s->me.xmin;\
     const int ymin= s->me.ymin;\
     const int xmax= s->me.xmax;\
     const int ymax= s->me.ymax;\
-    uint8_t * const src_y= src_data[0];\
-    uint8_t * const src_u= src_data[1];\
-    uint8_t * const src_v= src_data[2];\
-    uint8_t * const ref_y= ref_data[0];\
-    uint8_t * const ref_u= ref_data[1];\
-    uint8_t * const ref_v= ref_data[2];\
-    op_pixels_func (*hpel_put)[4];\
-    op_pixels_func (*hpel_avg)[4]= &s->dsp.avg_pixels_tab[size];\
-    op_pixels_func (*chroma_hpel_put)[4];\
-    qpel_mc_func (*qpel_put)[16];\
-    qpel_mc_func (*qpel_avg)[16]= &s->dsp.avg_qpel_pixels_tab[size];\
-    const __attribute__((unused)) int unu= time_pp + time_pb + (size_t)src_u + (size_t)src_v + (size_t)ref_u + (size_t)ref_v\
-                                           + (size_t)hpel_avg + (size_t)qpel_avg + (size_t)score_map\
-                                           + xmin + xmax + ymin + ymax;\
-    if(s->no_rounding /*FIXME b_type*/){\
-        hpel_put= &s->dsp.put_no_rnd_pixels_tab[size];\
-        chroma_hpel_put= &s->dsp.put_no_rnd_pixels_tab[size+1];\
-        qpel_put= &s->dsp.put_no_rnd_qpel_pixels_tab[size];\
-    }else{\
-        hpel_put=& s->dsp.put_pixels_tab[size];\
-        chroma_hpel_put= &s->dsp.put_pixels_tab[size+1];\
-        qpel_put= &s->dsp.put_qpel_pixels_tab[size];\
-    }
+    uint8_t *mv_penalty= s->me.current_mv_penalty;\
+    const int pred_x= s->me.pred_x;\
+    const int pred_y= s->me.pred_y;\
 
-
-#ifdef CMP_HPEL
-    
 #define CHECK_HALF_MV(dx, dy, x, y)\
 {\
     const int hx= 2*(x)+(dx);\
     const int hy= 2*(y)+(dy);\
-    CMP_HPEL(d, dx, dy, x, y, size);\
+    d= cmp(s, x, y, dx, dy, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);\
     d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\
     COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
 }
 
 #if 0
-static int RENAME(hpel_motion_search)(MpegEncContext * s,
+static int hpel_motion_search)(MpegEncContext * s,
 				  int *mx_ptr, int *my_ptr, int dmin,
-                                  int pred_x, int pred_y, uint8_t *ref_data[3], 
-                                  int size, uint8_t * const mv_penalty)
+                                  uint8_t *ref_data[3], 
+                                  int size)
 {
     const int xx = 16 * s->mb_x + 8*(n&1);
     const int yy = 16 * s->mb_y + 8*(n>>1);
@@ -94,8 +68,8 @@
         hpel_put=& s->dsp.put_pixels_tab[size];
         chroma_hpel_put= &s->dsp.put_pixels_tab[size+1];
     }
-    cmp= s->dsp.me_cmp[size];
-    chroma_cmp= s->dsp.me_cmp[size+1];
+    cmpf= s->dsp.me_cmp[size];
+    chroma_cmpf= s->dsp.me_cmp[size+1];
     cmp_sub= s->dsp.me_sub_cmp[size];
     chroma_cmp_sub= s->dsp.me_sub_cmp[size+1];
 
@@ -138,11 +112,10 @@
 }
 
 #else
-static int RENAME(hpel_motion_search)(MpegEncContext * s,
+static int hpel_motion_search(MpegEncContext * s,
 				  int *mx_ptr, int *my_ptr, int dmin,
-                                  int pred_x, int pred_y, uint8_t *src_data[3], 
-                                  uint8_t *ref_data[3], int stride, int uvstride,
-                                  int size, int h, uint8_t * const mv_penalty)
+                                  int src_index, int ref_index,
+                                  int size, int h)
 {
     const int mx = *mx_ptr;
     const int my = *my_ptr;   
@@ -151,6 +124,7 @@
     int bx=2*mx, by=2*my;
 
     LOAD_COMMON
+    int flags= s->me.sub_flags;
     
  //FIXME factorize
 
@@ -164,7 +138,7 @@
     }
         
     if(s->avctx->me_cmp != s->avctx->me_sub_cmp){
-        CMP_HPEL(dmin, 0, 0, mx, my, size);
+        dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
         if(mx || my || size>0)
             dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor;
     }
@@ -246,14 +220,16 @@
 }
 #endif
 
-static int RENAME(hpel_get_mb_score)(MpegEncContext * s, int mx, int my, int pred_x, int pred_y, uint8_t *src_data[3], 
-                                  uint8_t *ref_data[3], int stride, int uvstride,
-                                  uint8_t * const mv_penalty)
+static int inline get_mb_score(MpegEncContext * s, int mx, int my, int src_index,
+                               int ref_index)
 {
 //    const int check_luma= s->dsp.me_sub_cmp != s->dsp.mb_cmp;
     const int size= 0;
     const int h= 16;
     const int penalty_factor= s->me.mb_penalty_factor;
+    const int flags= s->me.mb_flags;
+    const int qpel= flags & FLAG_QPEL;
+    const int mask= 1+2*qpel;
     me_cmp_func cmp_sub, chroma_cmp_sub;
     int d;
 
@@ -267,7 +243,7 @@
     assert(!s->me.skip);
     assert(s->avctx->me_sub_cmp != s->avctx->mb_cmp);
 
-    CMP_HPEL(d, mx&1, my&1, mx>>1, my>>1, size);
+    d= cmp(s, mx>>(qpel+1), my>>(qpel+1), mx&mask, my&mask, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
     //FIXME check cbp before adding penalty for (0,0) vector
     if(mx || my || size>0)
         d += (mv_penalty[mx - pred_x] + mv_penalty[my - pred_y])*penalty_factor;
@@ -275,26 +251,19 @@
     return d;
 }
 
-#endif /* CMP_HPEL */
-
-
-
-#ifdef CMP_QPEL
-
 #define CHECK_QUARTER_MV(dx, dy, x, y)\
 {\
     const int hx= 4*(x)+(dx);\
     const int hy= 4*(y)+(dy);\
-    CMP_QPEL(d, dx, dy, x, y, size);\
+    d= cmp(s, x, y, dx, dy, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
     d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\
     COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
 }
 
-static int RENAME(qpel_motion_search)(MpegEncContext * s,
+static int qpel_motion_search(MpegEncContext * s,
 				  int *mx_ptr, int *my_ptr, int dmin,
-                                  int pred_x, int pred_y, uint8_t *src_data[3], 
-                                  uint8_t *ref_data[3], int stride, int uvstride,                                  
-                                  int size, int h, uint8_t * const mv_penalty)
+                                  int src_index, int ref_index,                                  
+                                  int size, int h)
 {
     const int mx = *mx_ptr;
     const int my = *my_ptr;   
@@ -302,13 +271,14 @@
     const int map_generation= s->me.map_generation;
     const int subpel_quality= s->avctx->me_subpel_quality;
     uint32_t *map= s->me.map;
-    me_cmp_func cmp, chroma_cmp;
+    me_cmp_func cmpf, chroma_cmpf;
     me_cmp_func cmp_sub, chroma_cmp_sub;
 
     LOAD_COMMON
+    int flags= s->me.sub_flags;
     
-    cmp= s->dsp.me_cmp[size];
-    chroma_cmp= s->dsp.me_cmp[size+1]; //factorize FIXME
+    cmpf= s->dsp.me_cmp[size];
+    chroma_cmpf= s->dsp.me_cmp[size+1]; //factorize FIXME
  //FIXME factorize
 
     cmp_sub= s->dsp.me_sub_cmp[size];
@@ -321,7 +291,7 @@
     }
         
     if(s->avctx->me_cmp != s->avctx->me_sub_cmp){
-        CMP_QPEL(dmin, 0, 0, mx, my, size);
+        dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
         if(mx || my || size>0)
             dmin += (mv_penalty[4*mx - pred_x] + mv_penalty[4*my - pred_y])*penalty_factor;
     }
@@ -386,7 +356,7 @@
             if(map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)] == (my<<ME_MAP_MV_BITS) + mx + map_generation && 0){ //FIXME
                 tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
             }else{
-                CMP(tl, mx-1, my-1, size); //FIXME wrong if chroma me is different
+                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
             }
             
             cxy= 2*tl + (cx + cy)/4 - (cx2 + cy2) - 2*c; 
@@ -509,36 +479,6 @@
     return dmin;
 }
 
-static int RENAME(qpel_get_mb_score)(MpegEncContext * s, int mx, int my, int pred_x, int pred_y, uint8_t *src_data[3], 
-                                  uint8_t *ref_data[3], int stride, int uvstride,
-                                  uint8_t * const mv_penalty)
-{
-    const int size= 0;
-    const int h= 16;
-    const int penalty_factor= s->me.mb_penalty_factor;
-    me_cmp_func cmp_sub, chroma_cmp_sub;
-    int d;
-
-    LOAD_COMMON
-    
- //FIXME factorize
-
-    cmp_sub= s->dsp.mb_cmp[size];
-    chroma_cmp_sub= s->dsp.mb_cmp[size+1];
-    
-    assert(!s->me.skip);
-    assert(s->avctx->me_sub_cmp != s->avctx->mb_cmp);
-
-    CMP_QPEL(d, mx&3, my&3, mx>>2, my>>2, size);
-    //FIXME check cbp before adding penalty for (0,0) vector
-    if(mx || my || size>0)
-        d += (mv_penalty[mx - pred_x] + mv_penalty[my - pred_y])*penalty_factor;
-        
-    return d;
-}
-
-
-#endif /* CMP_QPEL */
 
 #define CHECK_MV(x,y)\
 {\
@@ -546,7 +486,7 @@
     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
 /*printf("check_mv %d %d\n", x, y);*/\
     if(map[index]!=key){\
-        CMP(d, x, y, size);\
+        d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
         map[index]= key;\
         score_map[index]= d;\
         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\
@@ -570,7 +510,7 @@
     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
 /*printf("check_mv_dir %d %d %d\n", x, y, new_dir);*/\
     if(map[index]!=key){\
-        CMP(d, x, y, size);\
+        d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
         map[index]= key;\
         score_map[index]= d;\
         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\
@@ -590,27 +530,29 @@
 if( (y)<(ymin<<(S)) ) printf("%d %d %d %d %d ymin" #v, ymin, (x), (y), s->mb_x, s->mb_y);\
 if( (y)>(ymax<<(S)) ) printf("%d %d %d %d %d ymax" #v, ymax, (x), (y), s->mb_x, s->mb_y);\
 
+#define LOAD_COMMON2\
+    uint32_t *map= s->me.map;\
+    const int qpel= flags&FLAG_QPEL;\
+    const int shift= 1+qpel;\
 
-static inline int RENAME(small_diamond_search)(MpegEncContext * s, int *best, int dmin,
-                                       uint8_t *src_data[3],
-                                       uint8_t *ref_data[3], int stride, int uvstride,
-                                       int const pred_x, int const pred_y, int const penalty_factor,
-                                       int const shift,
-                                       uint32_t *map, int map_generation, int size, int h, uint8_t * const mv_penalty
-                                       )
+static always_inline int small_diamond_search(MpegEncContext * s, int *best, int dmin,
+                                       int src_index, int ref_index, int const penalty_factor,
+                                       int size, int h, int flags)
 {
-    me_cmp_func cmp, chroma_cmp;
+    me_cmp_func cmpf, chroma_cmpf;
     int next_dir=-1;
     LOAD_COMMON
+    LOAD_COMMON2
+    int map_generation= s->me.map_generation;
     
-    cmp= s->dsp.me_cmp[size];
-    chroma_cmp= s->dsp.me_cmp[size+1];
+    cmpf= s->dsp.me_cmp[size];
+    chroma_cmpf= s->dsp.me_cmp[size+1];
 
     { /* ensure that the best point is in the MAP as h/qpel refinement needs it */
         const int key= (best[1]<<ME_MAP_MV_BITS) + best[0] + map_generation;
         const int index= ((best[1]<<ME_MAP_SHIFT) + best[0])&(ME_MAP_SIZE-1);
         if(map[index]!=key){ //this will be executed only very rarey
-            CMP(score_map[index], best[0], best[1], size);
+            score_map[index]= cmp(s, best[0], best[1], 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
             map[index]= key;
         }
     }
@@ -634,20 +576,18 @@
     }
 }
 
-static inline int RENAME(funny_diamond_search)(MpegEncContext * s, int *best, int dmin,
-                                       uint8_t *src_data[3],
-                                       uint8_t *ref_data[3], int stride, int uvstride,
-                                       int const pred_x, int const pred_y, int const penalty_factor,
-                                       int const shift,
-                                       uint32_t *map, int map_generation, int size, int h, uint8_t * const mv_penalty
-                                       )
+static int funny_diamond_search(MpegEncContext * s, int *best, int dmin,
+                                       int src_index, int ref_index, int const penalty_factor,
+                                       int size, int h, int flags)
 {
-    me_cmp_func cmp, chroma_cmp;
+    me_cmp_func cmpf, chroma_cmpf;
     int dia_size;
     LOAD_COMMON
+    LOAD_COMMON2
+    int map_generation= s->me.map_generation;
     
-    cmp= s->dsp.me_cmp[size];
-    chroma_cmp= s->dsp.me_cmp[size+1];
+    cmpf= s->dsp.me_cmp[size];
+    chroma_cmpf= s->dsp.me_cmp[size+1];
 
     for(dia_size=1; dia_size<=4; dia_size++){
         int dir;
@@ -702,7 +642,7 @@
     const int index= (((ay)<<ME_MAP_SHIFT) + (ax))&(ME_MAP_SIZE-1);\
 /*printf("sab check %d %d\n", ax, ay);*/\
     if(map[index]!=key){\
-        CMP(d, ax, ay, size);\
+        d= cmp(s, ax, ay, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
         map[index]= key;\
         score_map[index]= d;\
         d += (mv_penalty[((ax)<<shift)-pred_x] + mv_penalty[((ay)<<shift)-pred_y])*penalty_factor;\
@@ -726,22 +666,20 @@
 }
 
 #define MAX_SAB_SIZE 16
-static inline int RENAME(sab_diamond_search)(MpegEncContext * s, int *best, int dmin,
-                                       uint8_t *src_data[3],
-                                       uint8_t *ref_data[3], int stride, int uvstride,
-                                       int const pred_x, int const pred_y, int const penalty_factor,
-                                       int const shift,
-                                       uint32_t *map, int map_generation, int size, int h, uint8_t * const mv_penalty
-                                       )
+static int sab_diamond_search(MpegEncContext * s, int *best, int dmin,
+                                       int src_index, int ref_index, int const penalty_factor,
+                                       int size, int h, int flags)
 {
-    me_cmp_func cmp, chroma_cmp;
+    me_cmp_func cmpf, chroma_cmpf;
     Minima minima[MAX_SAB_SIZE];
     const int minima_count= ABS(s->me.dia_size);
     int i, j;
     LOAD_COMMON
+    LOAD_COMMON2
+    int map_generation= s->me.map_generation;
     
-    cmp= s->dsp.me_cmp[size];
-    chroma_cmp= s->dsp.me_cmp[size+1];
+    cmpf= s->dsp.me_cmp[size];
+    chroma_cmpf= s->dsp.me_cmp[size+1];
     
     for(j=i=0; i<ME_MAP_SIZE; i++){
         uint32_t key= map[i];
@@ -807,20 +745,18 @@
     return dmin;    
 }
 
-static inline int RENAME(var_diamond_search)(MpegEncContext * s, int *best, int dmin,
-                                       uint8_t *src_data[3],
-                                       uint8_t *ref_data[3], int stride, int uvstride,
-                                       int const pred_x, int const pred_y, int const penalty_factor,
-                                       int const shift,
-                                       uint32_t *map, int map_generation, int size, int h, uint8_t * const mv_penalty
-                                       )
+static int var_diamond_search(MpegEncContext * s, int *best, int dmin,
+                                       int src_index, int ref_index, int const penalty_factor,
+                                       int size, int h, int flags)
 {
-    me_cmp_func cmp, chroma_cmp;
+    me_cmp_func cmpf, chroma_cmpf;
     int dia_size;
     LOAD_COMMON
+    LOAD_COMMON2
+    int map_generation= s->me.map_generation;
     
-    cmp= s->dsp.me_cmp[size];
-    chroma_cmp= s->dsp.me_cmp[size+1];
+    cmpf= s->dsp.me_cmp[size];
+    chroma_cmpf= s->dsp.me_cmp[size+1];
 
     for(dia_size=1; dia_size<=s->me.dia_size; dia_size++){
         int dir, start, end;
@@ -885,31 +821,42 @@
     return dmin;    
 }
 
-static int RENAME(epzs_motion_search)(MpegEncContext * s,
-                             int *mx_ptr, int *my_ptr,
-                             int P[10][2], int pred_x, int pred_y, uint8_t *src_data[3], 
-                             uint8_t *ref_data[3], int stride, int uvstride, int16_t (*last_mv)[2], 
-                             int ref_mv_scale, uint8_t * const mv_penalty)
+static always_inline int diamond_search(MpegEncContext * s, int *best, int dmin,
+                                       int src_index, int ref_index, int const penalty_factor,
+                                       int size, int h, int flags){
+    if(s->me.dia_size==-1)
+        return funny_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
+    else if(s->me.dia_size<-1)
+        return   sab_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
+    else if(s->me.dia_size<2)
+        return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
+    else
+        return   var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
+}
+
+static always_inline int epzs_motion_search_internal(MpegEncContext * s, int *mx_ptr, int *my_ptr,
+                             int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2], 
+                             int ref_mv_scale, int flags)
 {
     int best[2]={0, 0};
-    int d, dmin; 
-    const int shift= 1+s->quarter_sample;
-    uint32_t *map= s->me.map;
+    int d, dmin;
     int map_generation;
     const int penalty_factor= s->me.penalty_factor;
     const int size=0;
     const int h=16;
     const int ref_mv_stride= s->mb_stride; //pass as arg  FIXME
     const int ref_mv_xy= s->mb_x + s->mb_y*ref_mv_stride; //add to last_mv beforepassing FIXME
-    me_cmp_func cmp, chroma_cmp;
-    LOAD_COMMON
+    me_cmp_func cmpf, chroma_cmpf;
     
-    cmp= s->dsp.me_cmp[size];
-    chroma_cmp= s->dsp.me_cmp[size+1];
+    LOAD_COMMON
+    LOAD_COMMON2
+    
+    cmpf= s->dsp.me_cmp[size];
+    chroma_cmpf= s->dsp.me_cmp[size+1];
     
     map_generation= update_map_generation(s);
 
-    CMP(dmin, 0, 0, size);
+    dmin= cmp(s, 0, 0, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
     map[0]= map_generation;
     score_map[0]= dmin;
 
@@ -974,22 +921,7 @@
     }
 
 //check(best[0],best[1],0, b0)
-    if(s->me.dia_size==-1)
-        dmin= RENAME(funny_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-    else if(s->me.dia_size<-1)
-        dmin= RENAME(sab_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-    else if(s->me.dia_size<2)
-        dmin= RENAME(small_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-    else
-        dmin= RENAME(var_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
+    dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 
 //check(best[0],best[1],0, b1)
     *mx_ptr= best[0];
@@ -999,29 +931,42 @@
     return dmin;
 }
 
-#ifndef CMP_DIRECT /* no 4mv search needed in direct mode */
-static int RENAME(epzs_motion_search4)(MpegEncContext * s,
-                             int *mx_ptr, int *my_ptr,
-                             int P[10][2], int pred_x, int pred_y,
-                             uint8_t *src_data[3], 
-                             uint8_t *ref_data[3], int stride, int uvstride, int16_t (*last_mv)[2], 
-                             int ref_mv_scale, uint8_t * const mv_penalty)
+//this function is dedicated to the braindamaged gcc
+static inline int epzs_motion_search(MpegEncContext * s, int *mx_ptr, int *my_ptr,
+                             int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2], 
+                             int ref_mv_scale)
+{
+//FIXME convert other functions in the same way if faster
+    switch(s->me.flags){
+    case 0:
+        return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, 0);
+//    case FLAG_QPEL:
+//        return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, FLAG_QPEL);
+    default:
+        return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, s->me.flags);
+    }
+}
+
+static int epzs_motion_search4(MpegEncContext * s,
+                             int *mx_ptr, int *my_ptr, int P[10][2],
+                             int src_index, int ref_index, int16_t (*last_mv)[2], 
+                             int ref_mv_scale)
 {
     int best[2]={0, 0};
     int d, dmin; 
-    const int shift= 1+s->quarter_sample;
-    uint32_t *map= s->me.map;
     int map_generation;
     const int penalty_factor= s->me.penalty_factor;
     const int size=1;
     const int h=8;
     const int ref_mv_stride= s->mb_stride;
     const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride;
-    me_cmp_func cmp, chroma_cmp;
+    me_cmp_func cmpf, chroma_cmpf;
     LOAD_COMMON
+    int flags= s->me.flags;
+    LOAD_COMMON2
     
-    cmp= s->dsp.me_cmp[size];
-    chroma_cmp= s->dsp.me_cmp[size+1];
+    cmpf= s->dsp.me_cmp[size];
+    chroma_cmpf= s->dsp.me_cmp[size+1];
 
     map_generation= update_map_generation(s);
 
@@ -1053,23 +998,7 @@
                             (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
     }
 
-    if(s->me.dia_size==-1)
-        dmin= RENAME(funny_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-    else if(s->me.dia_size<-1)
-        dmin= RENAME(sab_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-    else if(s->me.dia_size<2)
-        dmin= RENAME(small_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-    else
-        dmin= RENAME(var_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-
+    dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 
     *mx_ptr= best[0];
     *my_ptr= best[1];    
@@ -1079,28 +1008,26 @@
 }
 
 //try to merge with above FIXME (needs PSNR test)
-static int RENAME(epzs_motion_search2)(MpegEncContext * s,
-                             int *mx_ptr, int *my_ptr,
-                             int P[10][2], int pred_x, int pred_y,
-                             uint8_t *src_data[3], 
-                             uint8_t *ref_data[3], int stride, int uvstride, int16_t (*last_mv)[2], 
-                             int ref_mv_scale, uint8_t * const mv_penalty)
+static int epzs_motion_search2(MpegEncContext * s,
+                             int *mx_ptr, int *my_ptr, int P[10][2],
+                             int src_index, int ref_index, int16_t (*last_mv)[2], 
+                             int ref_mv_scale)
 {
     int best[2]={0, 0};
     int d, dmin; 
-    const int shift= 1+s->quarter_sample;
-    uint32_t *map= s->me.map;
     int map_generation;
     const int penalty_factor= s->me.penalty_factor;
     const int size=0; //FIXME pass as arg
     const int h=8;
     const int ref_mv_stride= s->mb_stride;
     const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride;
-    me_cmp_func cmp, chroma_cmp;
+    me_cmp_func cmpf, chroma_cmpf;
     LOAD_COMMON
+    int flags= s->me.flags;
+    LOAD_COMMON2
     
-    cmp= s->dsp.me_cmp[size];
-    chroma_cmp= s->dsp.me_cmp[size+1];
+    cmpf= s->dsp.me_cmp[size];
+    chroma_cmpf= s->dsp.me_cmp[size+1];
 
     map_generation= update_map_generation(s);
 
@@ -1132,23 +1059,7 @@
                             (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
     }
 
-    if(s->me.dia_size==-1)
-        dmin= RENAME(funny_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-    else if(s->me.dia_size<-1)
-        dmin= RENAME(sab_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-    else if(s->me.dia_size<2)
-        dmin= RENAME(small_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-    else
-        dmin= RENAME(var_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
-                                   pred_x, pred_y, penalty_factor, 
-				   shift, map, map_generation, size, h, mv_penalty);
-
+    dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
 
     *mx_ptr= best[0];
     *my_ptr= best[1];    
@@ -1156,4 +1067,3 @@
 //    printf("%d %d %d \n", best[0], best[1], dmin);
     return dmin;
 }
-#endif /* !CMP_DIRECT */