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