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