rename attribute_unused to av_unused and moves its declaration to common.h
[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 /**
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 av_unused * const score_map= c->score_map;\
31     const int av_unused xmin= c->xmin;\
32     const int av_unused ymin= c->ymin;\
33     const int av_unused xmax= c->xmax;\
34     const int av_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 }