Merge remote branch 'qatar/master'
[ffmpeg.git] / libavcodec / motion_est_template.c
1 /*
2  * Motion estimation
3  * Copyright (c) 2002-2004 Michael Niedermayer
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * Motion estimation template.
25  */
26
27 //Let us hope gcc will remove the unused vars ...(gcc 3.2.2 seems to do it ...)
28 #define LOAD_COMMON\
29     uint32_t av_unused * const score_map= c->score_map;\
30     const int av_unused xmin= c->xmin;\
31     const int av_unused ymin= c->ymin;\
32     const int av_unused xmax= c->xmax;\
33     const int av_unused ymax= c->ymax;\
34     uint8_t *mv_penalty= c->current_mv_penalty;\
35     const int pred_x= c->pred_x;\
36     const int pred_y= c->pred_y;\
37
38 #define CHECK_HALF_MV(dx, dy, x, y)\
39 {\
40     const int hx= 2*(x)+(dx);\
41     const int hy= 2*(y)+(dy);\
42     d= cmp_hpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);\
43     d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\
44     COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
45 }
46
47 #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_qpel(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     }
638     return dmin;
639 }
640
641 static int hex_search(MpegEncContext * s, int *best, int dmin,
642                                        int src_index, int ref_index, int const penalty_factor,
643                                        int size, int h, int flags, int dia_size)
644 {
645     MotionEstContext * const c= &s->me;
646     me_cmp_func cmpf, chroma_cmpf;
647     LOAD_COMMON
648     LOAD_COMMON2
649     int map_generation= c->map_generation;
650     int x,y,d;
651     const int dec= dia_size & (dia_size-1);
652
653     cmpf= s->dsp.me_cmp[size];
654     chroma_cmpf= s->dsp.me_cmp[size+1];
655
656     for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
657         do{
658             x= best[0];
659             y= best[1];
660
661             CHECK_CLIPPED_MV(x  -dia_size    , y);
662             CHECK_CLIPPED_MV(x+  dia_size    , y);
663             CHECK_CLIPPED_MV(x+( dia_size>>1), y+dia_size);
664             CHECK_CLIPPED_MV(x+( dia_size>>1), y-dia_size);
665             if(dia_size>1){
666                 CHECK_CLIPPED_MV(x+(-dia_size>>1), y+dia_size);
667                 CHECK_CLIPPED_MV(x+(-dia_size>>1), y-dia_size);
668             }
669         }while(best[0] != x || best[1] != y);
670     }
671
672     return dmin;
673 }
674
675 static int l2s_dia_search(MpegEncContext * s, int *best, int dmin,
676                                        int src_index, int ref_index, int const penalty_factor,
677                                        int size, int h, int flags)
678 {
679     MotionEstContext * const c= &s->me;
680     me_cmp_func cmpf, chroma_cmpf;
681     LOAD_COMMON
682     LOAD_COMMON2
683     int map_generation= c->map_generation;
684     int x,y,i,d;
685     int dia_size= c->dia_size&0xFF;
686     const int dec= dia_size & (dia_size-1);
687     static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1},
688                                 { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}};
689
690     cmpf= s->dsp.me_cmp[size];
691     chroma_cmpf= s->dsp.me_cmp[size+1];
692
693     for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
694         do{
695             x= best[0];
696             y= best[1];
697             for(i=0; i<8; i++){
698                 CHECK_CLIPPED_MV(x+hex[i][0]*dia_size, y+hex[i][1]*dia_size);
699             }
700         }while(best[0] != x || best[1] != y);
701     }
702
703     x= best[0];
704     y= best[1];
705     CHECK_CLIPPED_MV(x+1, y);
706     CHECK_CLIPPED_MV(x, y+1);
707     CHECK_CLIPPED_MV(x-1, y);
708     CHECK_CLIPPED_MV(x, y-1);
709
710     return dmin;
711 }
712
713 static int umh_search(MpegEncContext * s, int *best, int dmin,
714                                        int src_index, int ref_index, int const penalty_factor,
715                                        int size, int h, int flags)
716 {
717     MotionEstContext * const c= &s->me;
718     me_cmp_func cmpf, chroma_cmpf;
719     LOAD_COMMON
720     LOAD_COMMON2
721     int map_generation= c->map_generation;
722     int x,y,x2,y2, i, j, d;
723     const int dia_size= c->dia_size&0xFE;
724     static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2},
725                                  { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2},
726                                  {-2, 3}, { 0, 4}, { 2, 3},
727                                  {-2,-3}, { 0,-4}, { 2,-3},};
728
729     cmpf= s->dsp.me_cmp[size];
730     chroma_cmpf= s->dsp.me_cmp[size+1];
731
732     x= best[0];
733     y= best[1];
734     for(x2=FFMAX(x-dia_size+1, xmin); x2<=FFMIN(x+dia_size-1,xmax); x2+=2){
735         CHECK_MV(x2, y);
736     }
737     for(y2=FFMAX(y-dia_size/2+1, ymin); y2<=FFMIN(y+dia_size/2-1,ymax); y2+=2){
738         CHECK_MV(x, y2);
739     }
740
741     x= best[0];
742     y= best[1];
743     for(y2=FFMAX(y-2, ymin); y2<=FFMIN(y+2,ymax); y2++){
744         for(x2=FFMAX(x-2, xmin); x2<=FFMIN(x+2,xmax); x2++){
745             CHECK_MV(x2, y2);
746         }
747     }
748
749 //FIXME prevent the CLIP stuff
750
751     for(j=1; j<=dia_size/4; j++){
752         for(i=0; i<16; i++){
753             CHECK_CLIPPED_MV(x+hex[i][0]*j, y+hex[i][1]*j);
754         }
755     }
756
757     return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2);
758 }
759
760 static int full_search(MpegEncContext * s, int *best, int dmin,
761                                        int src_index, int ref_index, int const penalty_factor,
762                                        int size, int h, int flags)
763 {
764     MotionEstContext * const c= &s->me;
765     me_cmp_func cmpf, chroma_cmpf;
766     LOAD_COMMON
767     LOAD_COMMON2
768     int map_generation= c->map_generation;
769     int x,y, d;
770     const int dia_size= c->dia_size&0xFF;
771
772     cmpf= s->dsp.me_cmp[size];
773     chroma_cmpf= s->dsp.me_cmp[size+1];
774
775     for(y=FFMAX(-dia_size, ymin); y<=FFMIN(dia_size,ymax); y++){
776         for(x=FFMAX(-dia_size, xmin); x<=FFMIN(dia_size,xmax); x++){
777             CHECK_MV(x, y);
778         }
779     }
780
781     x= best[0];
782     y= best[1];
783     d= dmin;
784     CHECK_CLIPPED_MV(x  , y);
785     CHECK_CLIPPED_MV(x+1, y);
786     CHECK_CLIPPED_MV(x, y+1);
787     CHECK_CLIPPED_MV(x-1, y);
788     CHECK_CLIPPED_MV(x, y-1);
789     best[0]= x;
790     best[1]= y;
791
792     return d;
793 }
794
795 #define SAB_CHECK_MV(ax,ay)\
796 {\
797     const int key= ((ay)<<ME_MAP_MV_BITS) + (ax) + map_generation;\
798     const int index= (((ay)<<ME_MAP_SHIFT) + (ax))&(ME_MAP_SIZE-1);\
799 /*printf("sab check %d %d\n", ax, ay);*/\
800     if(map[index]!=key){\
801         d= cmp(s, ax, ay, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
802         map[index]= key;\
803         score_map[index]= d;\
804         d += (mv_penalty[((ax)<<shift)-pred_x] + mv_penalty[((ay)<<shift)-pred_y])*penalty_factor;\
805 /*printf("score: %d\n", d);*/\
806         if(d < minima[minima_count-1].height){\
807             int j=0;\
808             \
809             while(d >= minima[j].height) j++;\
810 \
811             memmove(&minima [j+1], &minima [j], (minima_count - j - 1)*sizeof(Minima));\
812 \
813             minima[j].checked= 0;\
814             minima[j].height= d;\
815             minima[j].x= ax;\
816             minima[j].y= ay;\
817             \
818             i=-1;\
819             continue;\
820         }\
821     }\
822 }
823
824 #define MAX_SAB_SIZE ME_MAP_SIZE
825 static int sab_diamond_search(MpegEncContext * s, int *best, int dmin,
826                                        int src_index, int ref_index, int const penalty_factor,
827                                        int size, int h, int flags)
828 {
829     MotionEstContext * const c= &s->me;
830     me_cmp_func cmpf, chroma_cmpf;
831     Minima minima[MAX_SAB_SIZE];
832     const int minima_count= FFABS(c->dia_size);
833     int i, j;
834     LOAD_COMMON
835     LOAD_COMMON2
836     int map_generation= c->map_generation;
837
838     cmpf= s->dsp.me_cmp[size];
839     chroma_cmpf= s->dsp.me_cmp[size+1];
840
841     /*Note j<MAX_SAB_SIZE is needed if MAX_SAB_SIZE < ME_MAP_SIZE as j can
842       become larger due to MVs overflowing their ME_MAP_MV_BITS bits space in map
843      */
844     for(j=i=0; i<ME_MAP_SIZE && j<MAX_SAB_SIZE; i++){
845         uint32_t key= map[i];
846
847         key += (1<<(ME_MAP_MV_BITS-1)) + (1<<(2*ME_MAP_MV_BITS-1));
848
849         if((key&((-1)<<(2*ME_MAP_MV_BITS))) != map_generation) continue;
850
851         minima[j].height= score_map[i];
852         minima[j].x= key & ((1<<ME_MAP_MV_BITS)-1); key>>=ME_MAP_MV_BITS;
853         minima[j].y= key & ((1<<ME_MAP_MV_BITS)-1);
854         minima[j].x-= (1<<(ME_MAP_MV_BITS-1));
855         minima[j].y-= (1<<(ME_MAP_MV_BITS-1));
856
857         // all entries in map should be in range except if the mv overflows their ME_MAP_MV_BITS bits space
858         if(   minima[j].x > xmax || minima[j].x < xmin
859            || minima[j].y > ymax || minima[j].y < ymin)
860             continue;
861
862         minima[j].checked=0;
863         if(minima[j].x || minima[j].y)
864             minima[j].height+= (mv_penalty[((minima[j].x)<<shift)-pred_x] + mv_penalty[((minima[j].y)<<shift)-pred_y])*penalty_factor;
865
866         j++;
867     }
868
869     qsort(minima, j, sizeof(Minima), minima_cmp);
870
871     for(; j<minima_count; j++){
872         minima[j].height=256*256*256*64;
873         minima[j].checked=0;
874         minima[j].x= minima[j].y=0;
875     }
876
877     for(i=0; i<minima_count; i++){
878         const int x= minima[i].x;
879         const int y= minima[i].y;
880         int d;
881
882         if(minima[i].checked) continue;
883
884         if(   x >= xmax || x <= xmin
885            || y >= ymax || y <= ymin)
886            continue;
887
888         SAB_CHECK_MV(x-1, y)
889         SAB_CHECK_MV(x+1, y)
890         SAB_CHECK_MV(x  , y-1)
891         SAB_CHECK_MV(x  , y+1)
892
893         minima[i].checked= 1;
894     }
895
896     best[0]= minima[0].x;
897     best[1]= minima[0].y;
898     dmin= minima[0].height;
899
900     if(   best[0] < xmax && best[0] > xmin
901        && best[1] < ymax && best[1] > ymin){
902         int d;
903         //ensure that the refernece samples for hpel refinement are in the map
904         CHECK_MV(best[0]-1, best[1])
905         CHECK_MV(best[0]+1, best[1])
906         CHECK_MV(best[0], best[1]-1)
907         CHECK_MV(best[0], best[1]+1)
908     }
909     return dmin;
910 }
911
912 static int var_diamond_search(MpegEncContext * s, int *best, int dmin,
913                                        int src_index, int ref_index, int const penalty_factor,
914                                        int size, int h, int flags)
915 {
916     MotionEstContext * const c= &s->me;
917     me_cmp_func cmpf, chroma_cmpf;
918     int dia_size;
919     LOAD_COMMON
920     LOAD_COMMON2
921     int map_generation= c->map_generation;
922
923     cmpf= s->dsp.me_cmp[size];
924     chroma_cmpf= s->dsp.me_cmp[size+1];
925
926     for(dia_size=1; dia_size<=c->dia_size; dia_size++){
927         int dir, start, end;
928         const int x= best[0];
929         const int y= best[1];
930
931         start= FFMAX(0, y + dia_size - ymax);
932         end  = FFMIN(dia_size, xmax - x + 1);
933         for(dir= start; dir<end; dir++){
934             int d;
935
936 //check(x + dir,y + dia_size - dir,0, a0)
937             CHECK_MV(x + dir           , y + dia_size - dir);
938         }
939
940         start= FFMAX(0, x + dia_size - xmax);
941         end  = FFMIN(dia_size, y - ymin + 1);
942         for(dir= start; dir<end; dir++){
943             int d;
944
945 //check(x + dia_size - dir, y - dir,0, a1)
946             CHECK_MV(x + dia_size - dir, y - dir           );
947         }
948
949         start= FFMAX(0, -y + dia_size + ymin );
950         end  = FFMIN(dia_size, x - xmin + 1);
951         for(dir= start; dir<end; dir++){
952             int d;
953
954 //check(x - dir,y - dia_size + dir,0, a2)
955             CHECK_MV(x - dir           , y - dia_size + dir);
956         }
957
958         start= FFMAX(0, -x + dia_size + xmin );
959         end  = FFMIN(dia_size, ymax - y + 1);
960         for(dir= start; dir<end; dir++){
961             int d;
962
963 //check(x - dia_size + dir, y + dir,0, a3)
964             CHECK_MV(x - dia_size + dir, y + dir           );
965         }
966
967         if(x!=best[0] || y!=best[1])
968             dia_size=0;
969     }
970     return dmin;
971 }
972
973 static av_always_inline int diamond_search(MpegEncContext * s, int *best, int dmin,
974                                        int src_index, int ref_index, int const penalty_factor,
975                                        int size, int h, int flags){
976     MotionEstContext * const c= &s->me;
977     if(c->dia_size==-1)
978         return funny_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
979     else if(c->dia_size<-1)
980         return   sab_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
981     else if(c->dia_size<2)
982         return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
983     else if(c->dia_size>1024)
984         return          full_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
985     else if(c->dia_size>768)
986         return           umh_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
987     else if(c->dia_size>512)
988         return           hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, c->dia_size&0xFF);
989     else if(c->dia_size>256)
990         return       l2s_dia_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
991     else
992         return   var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
993 }
994
995 /*!
996    \param P[10][2] a list of candidate mvs to check before starting the
997    iterative search. If one of the candidates is close to the optimal mv, then
998    it takes fewer iterations. And it increases the chance that we find the
999    optimal mv.
1000  */
1001 static av_always_inline int epzs_motion_search_internal(MpegEncContext * s, int *mx_ptr, int *my_ptr,
1002                              int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2],
1003                              int ref_mv_scale, int flags, int size, int h)
1004 {
1005     MotionEstContext * const c= &s->me;
1006     int best[2]={0, 0};      /*!< x and y coordinates of the best motion vector.
1007                                i.e. the difference between the position of the
1008                                block currently being encoded and the position of
1009                                the block chosen to predict it from. */
1010     int d;                   ///< the score (cmp + penalty) of any given mv
1011     int dmin;                /*!< the best value of d, i.e. the score
1012                                corresponding to the mv stored in best[]. */
1013     int map_generation;
1014     int penalty_factor;
1015     const int ref_mv_stride= s->mb_stride; //pass as arg  FIXME
1016     const int ref_mv_xy= s->mb_x + s->mb_y*ref_mv_stride; //add to last_mv beforepassing FIXME
1017     me_cmp_func cmpf, chroma_cmpf;
1018
1019     LOAD_COMMON
1020     LOAD_COMMON2
1021
1022     if(c->pre_pass){
1023         penalty_factor= c->pre_penalty_factor;
1024         cmpf= s->dsp.me_pre_cmp[size];
1025         chroma_cmpf= s->dsp.me_pre_cmp[size+1];
1026     }else{
1027         penalty_factor= c->penalty_factor;
1028         cmpf= s->dsp.me_cmp[size];
1029         chroma_cmpf= s->dsp.me_cmp[size+1];
1030     }
1031
1032     map_generation= update_map_generation(c);
1033
1034     assert(cmpf);
1035     dmin= cmp(s, 0, 0, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
1036     map[0]= map_generation;
1037     score_map[0]= dmin;
1038
1039     //FIXME precalc first term below?
1040     if((s->pict_type == FF_B_TYPE && !(c->flags & FLAG_DIRECT)) || s->flags&CODEC_FLAG_MV0)
1041         dmin += (mv_penalty[pred_x] + mv_penalty[pred_y])*penalty_factor;
1042
1043     /* first line */
1044     if (s->first_slice_line) {
1045         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1046         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1047                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1048     }else{
1049         if(dmin<((h*h*s->avctx->mv0_threshold)>>8)
1050                     && ( P_LEFT[0]    |P_LEFT[1]
1051                         |P_TOP[0]     |P_TOP[1]
1052                         |P_TOPRIGHT[0]|P_TOPRIGHT[1])==0){
1053             *mx_ptr= 0;
1054             *my_ptr= 0;
1055             c->skip=1;
1056             return dmin;
1057         }
1058         CHECK_MV(    P_MEDIAN[0] >>shift ,    P_MEDIAN[1] >>shift)
1059         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)  , (P_MEDIAN[1]>>shift)-1)
1060         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)  , (P_MEDIAN[1]>>shift)+1)
1061         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)-1, (P_MEDIAN[1]>>shift)  )
1062         CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)+1, (P_MEDIAN[1]>>shift)  )
1063         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1064                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1065         CHECK_MV(P_LEFT[0]    >>shift, P_LEFT[1]    >>shift)
1066         CHECK_MV(P_TOP[0]     >>shift, P_TOP[1]     >>shift)
1067         CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
1068     }
1069     if(dmin>h*h*4){
1070         if(c->pre_pass){
1071             CHECK_CLIPPED_MV((last_mv[ref_mv_xy-1][0]*ref_mv_scale + (1<<15))>>16,
1072                             (last_mv[ref_mv_xy-1][1]*ref_mv_scale + (1<<15))>>16)
1073             if(!s->first_slice_line)
1074                 CHECK_CLIPPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
1075                                 (last_mv[ref_mv_xy-ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
1076         }else{
1077             CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
1078                             (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
1079             if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line
1080                 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
1081                                 (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
1082         }
1083     }
1084
1085     if(c->avctx->last_predictor_count){
1086         const int count= c->avctx->last_predictor_count;
1087         const int xstart= FFMAX(0, s->mb_x - count);
1088         const int ystart= FFMAX(0, s->mb_y - count);
1089         const int xend= FFMIN(s->mb_width , s->mb_x + count + 1);
1090         const int yend= FFMIN(s->mb_height, s->mb_y + count + 1);
1091         int mb_y;
1092
1093         for(mb_y=ystart; mb_y<yend; mb_y++){
1094             int mb_x;
1095             for(mb_x=xstart; mb_x<xend; mb_x++){
1096                 const int xy= mb_x + 1 + (mb_y + 1)*ref_mv_stride;
1097                 int mx= (last_mv[xy][0]*ref_mv_scale + (1<<15))>>16;
1098                 int my= (last_mv[xy][1]*ref_mv_scale + (1<<15))>>16;
1099
1100                 if(mx>xmax || mx<xmin || my>ymax || my<ymin) continue;
1101                 CHECK_MV(mx,my)
1102             }
1103         }
1104     }
1105
1106 //check(best[0],best[1],0, b0)
1107     dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
1108
1109 //check(best[0],best[1],0, b1)
1110     *mx_ptr= best[0];
1111     *my_ptr= best[1];
1112
1113 //    printf("%d %d %d \n", best[0], best[1], dmin);
1114     return dmin;
1115 }
1116
1117 //this function is dedicated to the braindamaged gcc
1118 inline int ff_epzs_motion_search(MpegEncContext * s, int *mx_ptr, int *my_ptr,
1119                              int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2],
1120                              int ref_mv_scale, int size, int h)
1121 {
1122     MotionEstContext * const c= &s->me;
1123 //FIXME convert other functions in the same way if faster
1124     if(c->flags==0 && h==16 && size==0){
1125         return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, 0, 0, 16);
1126 //    case FLAG_QPEL:
1127 //        return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, FLAG_QPEL);
1128     }else{
1129         return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, c->flags, size, h);
1130     }
1131 }
1132
1133 static int epzs_motion_search4(MpegEncContext * s,
1134                              int *mx_ptr, int *my_ptr, int P[10][2],
1135                              int src_index, int ref_index, int16_t (*last_mv)[2],
1136                              int ref_mv_scale)
1137 {
1138     MotionEstContext * const c= &s->me;
1139     int best[2]={0, 0};
1140     int d, dmin;
1141     int map_generation;
1142     const int penalty_factor= c->penalty_factor;
1143     const int size=1;
1144     const int h=8;
1145     const int ref_mv_stride= s->mb_stride;
1146     const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride;
1147     me_cmp_func cmpf, chroma_cmpf;
1148     LOAD_COMMON
1149     int flags= c->flags;
1150     LOAD_COMMON2
1151
1152     cmpf= s->dsp.me_cmp[size];
1153     chroma_cmpf= s->dsp.me_cmp[size+1];
1154
1155     map_generation= update_map_generation(c);
1156
1157     dmin = 1000000;
1158 //printf("%d %d %d %d //",xmin, ymin, xmax, ymax);
1159     /* first line */
1160     if (s->first_slice_line) {
1161         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1162         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1163                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1164         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
1165     }else{
1166         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
1167         //FIXME try some early stop
1168         CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
1169         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1170         CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
1171         CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
1172         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1173                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1174     }
1175     if(dmin>64*4){
1176         CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
1177                         (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
1178         if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line
1179             CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
1180                             (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
1181     }
1182
1183     dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
1184
1185     *mx_ptr= best[0];
1186     *my_ptr= best[1];
1187
1188 //    printf("%d %d %d \n", best[0], best[1], dmin);
1189     return dmin;
1190 }
1191
1192 //try to merge with above FIXME (needs PSNR test)
1193 static int epzs_motion_search2(MpegEncContext * s,
1194                              int *mx_ptr, int *my_ptr, int P[10][2],
1195                              int src_index, int ref_index, int16_t (*last_mv)[2],
1196                              int ref_mv_scale)
1197 {
1198     MotionEstContext * const c= &s->me;
1199     int best[2]={0, 0};
1200     int d, dmin;
1201     int map_generation;
1202     const int penalty_factor= c->penalty_factor;
1203     const int size=0; //FIXME pass as arg
1204     const int h=8;
1205     const int ref_mv_stride= s->mb_stride;
1206     const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride;
1207     me_cmp_func cmpf, chroma_cmpf;
1208     LOAD_COMMON
1209     int flags= c->flags;
1210     LOAD_COMMON2
1211
1212     cmpf= s->dsp.me_cmp[size];
1213     chroma_cmpf= s->dsp.me_cmp[size+1];
1214
1215     map_generation= update_map_generation(c);
1216
1217     dmin = 1000000;
1218 //printf("%d %d %d %d //",xmin, ymin, xmax, ymax);
1219     /* first line */
1220     if (s->first_slice_line) {
1221         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1222         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1223                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1224         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
1225     }else{
1226         CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
1227         //FIXME try some early stop
1228         CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
1229         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
1230         CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
1231         CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
1232         CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
1233                         (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1234     }
1235     if(dmin>64*4){
1236         CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
1237                         (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
1238         if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line
1239             CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
1240                             (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
1241     }
1242
1243     dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
1244
1245     *mx_ptr= best[0];
1246     *my_ptr= best[1];
1247
1248 //    printf("%d %d %d \n", best[0], best[1], dmin);
1249     return dmin;
1250 }