31 uint32_t av_unused * const score_map= c->score_map;\
32 const int av_unused xmin= c->xmin;\
33 const int av_unused ymin= c->ymin;\
34 const int av_unused xmax= c->xmax;\
35 const int av_unused ymax= c->ymax;\
36 uint8_t *mv_penalty= c->current_mv_penalty;\
37 const int pred_x= c->pred_x;\
38 const int pred_y= c->pred_y;\
40 #define CHECK_HALF_MV(dx, dy, x, y)\
42 const int hx= 2*(x)+(dx);\
43 const int hy= 2*(y)+(dy);\
44 d= cmp_hpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);\
45 d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\
46 COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
50 int *mx_ptr,
int *my_ptr,
int dmin,
51 int src_index,
int ref_index,
55 const int mx = *mx_ptr;
56 const int my = *my_ptr;
76 dmin=
cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
77 if(mx || my || size>0)
81 if (mx > xmin && mx < xmax &&
82 my > ymin && my < ymax) {
97 uint32_t *map= c->
map;
146 assert(bx >= xmin*2 && bx <= xmax*2 && by >= ymin*2 && by <= ymax*2);
156 int *mx_ptr,
int *my_ptr,
int dmin,
157 int src_index,
int ref_index,
166 int src_index,
int ref_index,
int size,
173 const int mask= 1+2*qpel;
187 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);
189 if(add_rate && (mx || my || size>0))
196 int ref_index,
int size,
int h,
int add_rate)
198 return get_mb_score(s, mx, my, src_index, ref_index, size, h, add_rate);
201 #define CHECK_QUARTER_MV(dx, dy, x, y)\
203 const int hx= 4*(x)+(dx);\
204 const int hy= 4*(y)+(dy);\
205 d= cmp_qpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
206 d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\
207 COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
211 int *mx_ptr,
int *my_ptr,
int dmin,
212 int src_index,
int ref_index,
216 const int mx = *mx_ptr;
217 const int my = *my_ptr;
221 uint32_t *map= c->
map;
242 dmin=
cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
243 if(mx || my || size>0)
247 if (mx > xmin && mx < xmax &&
248 my > ymin && my < ymax) {
249 int bx=4*mx, by=4*my;
254 const int l= score_map[(index- 1 )&(
ME_MAP_SIZE-1)];
261 memset(best, 64,
sizeof(
int)*8);
268 for(ny= -3; ny <= 3; ny++){
269 for(nx= -3; nx <= 3; nx++){
271 const int64_t t2= nx*nx*(tr + tl - 2*t) + 4*nx*(tr-tl) + 32*t;
272 const int64_t c2= nx*nx*( r + l - 2*c) + 4*nx*( r- l) + 32*c;
273 const int64_t b2= nx*nx*(br + bl - 2*
b) + 4*nx*(br-bl) + 32*
b;
274 int score= (ny*ny*(b2 + t2 - 2*c2) + 4*ny*(b2 - t2) + 32*c2 + 512)>>10;
277 if((nx&3)==0 && (ny&3)==0)
continue;
286 memmove(&best[i+1], &best[i],
sizeof(
int)*(7-i));
287 memmove(&best_pos[i+1][0], &best_pos[i][0],
sizeof(
int)*2*(7-i));
289 best_pos[i][0]= nx + 4*mx;
290 best_pos[i][1]= ny + 4*my;
299 const int cx = 4*(r - l);
300 const int cx2= r + l - 2*c;
301 const int cy = 4*(b - t);
302 const int cy2= b + t - 2*c;
308 tl=
cmp(s, mx-1, my-1, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
311 cxy= 2*tl + (cx + cy)/4 - (cx2 + cy2) - 2*c;
313 assert(16*cx2 + 4*cx + 32*c == 32*r);
314 assert(16*cx2 - 4*cx + 32*c == 32*l);
315 assert(16*cy2 + 4*cy + 32*c == 32*b);
316 assert(16*cy2 - 4*cy + 32*c == 32*t);
317 assert(16*cxy + 16*cy2 + 16*cx2 - 4*cy - 4*cx + 32*c == 32*tl);
319 for(ny= -3; ny <= 3; ny++){
320 for(nx= -3; nx <= 3; nx++){
322 int score= ny*nx*cxy + nx*nx*cx2 + ny*ny*cy2 + nx*cx + ny*cy + 32*c;
325 if((nx&3)==0 && (ny&3)==0)
continue;
333 memmove(&best[i+1], &best[i],
sizeof(
int)*(7-i));
334 memmove(&best_pos[i+1][0], &best_pos[i][0],
sizeof(
int)*2*(7-i));
336 best_pos[i][0]= nx + 4*mx;
337 best_pos[i][1]= ny + 4*my;
344 for(i=0; i<subpel_quality; i++){
350 assert(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);
363 #define CHECK_MV(x,y)\
365 const unsigned key = ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
366 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
367 assert((x) >= xmin);\
368 assert((x) <= xmax);\
369 assert((y) >= ymin);\
370 assert((y) <= ymax);\
371 if(map[index]!=key){\
372 d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
374 score_map[index]= d;\
375 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\
376 COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\
380 #define CHECK_CLIPPED_MV(ax,ay)\
384 const int Lx2= FFMAX(xmin, FFMIN(Lx, xmax));\
385 const int Ly2= FFMAX(ymin, FFMIN(Ly, ymax));\
389 #define CHECK_MV_DIR(x,y,new_dir)\
391 const unsigned key = ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
392 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
393 if(map[index]!=key){\
394 d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
396 score_map[index]= d;\
397 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\
407 #define check(x,y,S,v)\
408 if( (x)<(xmin<<(S)) ) printf("%d %d %d %d %d xmin" #v, xmin, (x), (y), s->mb_x, s->mb_y);\
409 if( (x)>(xmax<<(S)) ) printf("%d %d %d %d %d xmax" #v, xmax, (x), (y), s->mb_x, s->mb_y);\
410 if( (y)<(ymin<<(S)) ) printf("%d %d %d %d %d ymin" #v, ymin, (x), (y), s->mb_x, s->mb_y);\
411 if( (y)>(ymax<<(S)) ) printf("%d %d %d %d %d ymax" #v, ymax, (x), (y), s->mb_x, s->mb_y);\
413 #define LOAD_COMMON2\
414 uint32_t *map= c->map;\
415 const int qpel= flags&FLAG_QPEL;\
416 const int shift= 1+qpel;\
419 int src_index,
int ref_index,
int const penalty_factor,
433 const unsigned key = (best[1]<<
ME_MAP_MV_BITS) + best[0] + map_generation;
436 score_map[
index]=
cmp(s, best[0], best[1], 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
443 const int dir= next_dir;
444 const int x= best[0];
445 const int y= best[1];
460 int src_index,
int ref_index,
int const penalty_factor,
473 for(dia_size=1; dia_size<=4; dia_size++){
475 const int x= best[0];
476 const int y= best[1];
478 if(dia_size&(dia_size-1))
continue;
480 if( x + dia_size > xmax
481 || x - dia_size < xmin
482 || y + dia_size > ymax
483 || y - dia_size < ymin)
486 for(dir= 0; dir<dia_size; dir+=2){
489 CHECK_MV(x + dir , y + dia_size - dir);
490 CHECK_MV(x + dia_size - dir, y - dir );
491 CHECK_MV(x - dir , y - dia_size + dir);
492 CHECK_MV(x - dia_size + dir, y + dir );
495 if(x!=best[0] || y!=best[1])
502 int src_index,
int ref_index,
int const penalty_factor,
503 int size,
int h,
int flags,
int dia_size)
511 const int dec= dia_size & (dia_size-1);
516 for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
529 }
while(best[0] != x || best[1] != y);
536 int src_index,
int ref_index,
int const penalty_factor,
546 const int dec= dia_size & (dia_size-1);
547 static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1},
548 { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}};
553 for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
560 }
while(best[0] != x || best[1] != y);
574 int src_index,
int ref_index,
int const penalty_factor,
582 int x,y,x2,y2, i, j, d;
583 const int dia_size= c->
dia_size&0xFE;
584 static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2},
585 { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2},
586 {-2, 3}, { 0, 4}, { 2, 3},
587 {-2,-3}, { 0,-4}, { 2,-3},};
594 for(x2=
FFMAX(x-dia_size+1, xmin); x2<=
FFMIN(x+dia_size-1,xmax); x2+=2){
597 for(y2=
FFMAX(y-dia_size/2+1, ymin); y2<=
FFMIN(y+dia_size/2-1,ymax); y2+=2){
603 for(y2=
FFMAX(y-2, ymin); y2<=
FFMIN(y+2,ymax); y2++){
604 for(x2=
FFMAX(x-2, xmin); x2<=
FFMIN(x+2,xmax); x2++){
611 for(j=1; j<=dia_size/4; j++){
617 return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2);
621 int src_index,
int ref_index,
int const penalty_factor,
630 const int dia_size= c->
dia_size&0xFF;
635 for(y=
FFMAX(-dia_size, ymin); y<=
FFMIN(dia_size,ymax); y++){
636 for(x=
FFMAX(-dia_size, xmin); x<=
FFMIN(dia_size,xmax); x++){
655 #define SAB_CHECK_MV(ax,ay)\
657 const unsigned key = ((ay)<<ME_MAP_MV_BITS) + (ax) + map_generation;\
658 const int index= (((ay)<<ME_MAP_SHIFT) + (ax))&(ME_MAP_SIZE-1);\
659 if(map[index]!=key){\
660 d= cmp(s, ax, ay, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
662 score_map[index]= d;\
663 d += (mv_penalty[((ax)<<shift)-pred_x] + mv_penalty[((ay)<<shift)-pred_y])*penalty_factor;\
664 if(d < minima[minima_count-1].height){\
667 while(d >= minima[j].height) j++;\
669 memmove(&minima [j+1], &minima [j], (minima_count - j - 1)*sizeof(Minima));\
671 minima[j].checked= 0;\
672 minima[j].height= d;\
682 #define MAX_SAB_SIZE ME_MAP_SIZE
684 int src_index,
int ref_index,
int const penalty_factor,
703 uint32_t key= map[i];
709 minima[j].
height= score_map[i];
716 if( minima[j].x > xmax || minima[j].x < xmin
717 || minima[j].y > ymax || minima[j].y < ymin)
721 if(minima[j].x || minima[j].y)
729 for(; j<minima_count; j++){
730 minima[j].
height=256*256*256*64;
732 minima[j].
x= minima[j].
y=0;
735 for(i=0; i<minima_count; i++){
736 const int x= minima[i].
x;
737 const int y= minima[i].
y;
740 if(minima[i].
checked)
continue;
742 if( x >= xmax || x <= xmin
743 || y >= ymax || y <= ymin)
754 best[0]= minima[0].
x;
755 best[1]= minima[0].
y;
758 if( best[0] < xmax && best[0] > xmin
759 && best[1] < ymax && best[1] > ymin){
771 int src_index,
int ref_index,
int const penalty_factor,
784 for(dia_size=1; dia_size<=c->
dia_size; dia_size++){
786 const int x= best[0];
787 const int y= best[1];
789 start=
FFMAX(0, y + dia_size - ymax);
790 end =
FFMIN(dia_size, xmax - x + 1);
791 for(dir= start; dir<end; dir++){
795 CHECK_MV(x + dir , y + dia_size - dir);
798 start=
FFMAX(0, x + dia_size - xmax);
799 end =
FFMIN(dia_size, y - ymin + 1);
800 for(dir= start; dir<end; dir++){
804 CHECK_MV(x + dia_size - dir, y - dir );
807 start=
FFMAX(0, -y + dia_size + ymin );
808 end =
FFMIN(dia_size, x - xmin + 1);
809 for(dir= start; dir<end; dir++){
813 CHECK_MV(x - dir , y - dia_size + dir);
816 start=
FFMAX(0, -x + dia_size + xmin );
817 end =
FFMIN(dia_size, ymax - y + 1);
818 for(dir= start; dir<end; dir++){
822 CHECK_MV(x - dia_size + dir, y + dir );
825 if(x!=best[0] || y!=best[1])
832 int src_index,
int ref_index,
int const penalty_factor,
836 return funny_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
838 return sab_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
840 return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
842 return full_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
844 return umh_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
846 return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, c->
dia_size&0xFF);
848 return l2s_dia_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
850 return var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
860 int P[10][2],
int src_index,
int ref_index, int16_t (*last_mv)[2],
861 int ref_mv_scale,
int flags,
int size,
int h)
871 unsigned map_generation;
874 const int ref_mv_xy= s->
mb_x + s->
mb_y*ref_mv_stride;
893 dmin=
cmp(s, 0, 0, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
894 map[0]= map_generation;
906 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
923 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
931 (last_mv[ref_mv_xy-1][1]*ref_mv_scale + (1<<15))>>16)
933 CHECK_CLIPPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
934 (last_mv[ref_mv_xy-ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
937 (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
939 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
940 (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
946 const int xstart=
FFMAX(0, s->
mb_x - count);
947 const int ystart=
FFMAX(0, s->
mb_y - count);
952 for(mb_y=ystart; mb_y<yend; mb_y++){
954 for(mb_x=xstart; mb_x<xend; mb_x++){
955 const int xy= mb_x + 1 + (mb_y + 1)*ref_mv_stride;
956 int mx= (last_mv[xy][0]*ref_mv_scale + (1<<15))>>16;
957 int my= (last_mv[xy][1]*ref_mv_scale + (1<<15))>>16;
959 if(mx>xmax || mx<xmin || my>ymax || my<ymin)
continue;
966 dmin=
diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
977 int P[10][2],
int src_index,
int ref_index,
978 int16_t (*last_mv)[2],
int ref_mv_scale,
983 if(c->
flags==0 && h==16 && size==0){
984 return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, 0, 0, 16);
988 return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, c->
flags, size, h);
993 int *mx_ptr,
int *my_ptr,
int P[10][2],
994 int src_index,
int ref_index, int16_t (*last_mv)[2],
1000 unsigned map_generation;
1005 const int ref_mv_xy= s->
mb_x + s->
mb_y *ref_mv_stride;
1022 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1032 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1036 (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
1038 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
1039 (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
1042 dmin=
diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
1052 int *mx_ptr,
int *my_ptr,
int P[10][2],
1053 int src_index,
int ref_index, int16_t (*last_mv)[2],
1059 unsigned map_generation;
1064 const int ref_mv_xy= s->
mb_x + s->
mb_y *ref_mv_stride;
1081 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1091 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1095 (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
1097 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
1098 (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
1101 dmin=
diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
static int minima_cmp(const void *a, const void *b)
static unsigned update_map_generation(MotionEstContext *c)
static int epzs_motion_search2(MpegEncContext *s, int *mx_ptr, int *my_ptr, int P[10][2], int src_index, int ref_index, int16_t(*last_mv)[2], int ref_mv_scale)
int skip
set if ME is skipped for the current MB
int pre_pass
= 1 for the pre pass
#define SAB_CHECK_MV(ax, ay)
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
static av_always_inline int diamond_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags)
static int sab_diamond_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags)
static int funny_diamond_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags)
int mpv_flags
flags set by private options
me_cmp_func me_pre_cmp[6]
int(* me_cmp_func)(struct MpegEncContext *c, uint8_t *blk1, uint8_t *blk2, int line_size, int h)
static int full_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags)
Motion estimation context.
int me_cmp
motion estimation comparison function
static int umh_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags)
int ff_epzs_motion_search(MpegEncContext *s, int *mx_ptr, int *my_ptr, int P[10][2], int src_index, int ref_index, int16_t(*last_mv)[2], int ref_mv_scale, int size, int h)
int mb_height
number of MBs horizontally & vertically
#define CHECK_CLIPPED_MV(ax, ay)
int ff_get_mb_score(MpegEncContext *s, int mx, int my, int src_index, int ref_index, int size, int h, int add_rate)
static const uint16_t mask[17]
static int epzs_motion_search4(MpegEncContext *s, int *mx_ptr, int *my_ptr, int P[10][2], int src_index, int ref_index, int16_t(*last_mv)[2], int ref_mv_scale)
static int no_sub_motion_search(MpegEncContext *s, int *mx_ptr, int *my_ptr, int dmin, int src_index, int ref_index, int size, int h)
int me_sub_cmp
subpixel motion estimation comparison function
static av_always_inline int small_diamond_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags)
#define CHECK_MV_DIR(x, y, new_dir)
#define CHECK_HALF_MV(dx, dy, x, y)
static av_always_inline int epzs_motion_search_internal(MpegEncContext *s, int *mx_ptr, int *my_ptr, int P[10][2], int src_index, int ref_index, int16_t(*last_mv)[2], int ref_mv_scale, int flags, int size, int h)
static int hex_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags, int dia_size)
static int hpel_motion_search(MpegEncContext *s, int *mx_ptr, int *my_ptr, int dmin, int src_index, int ref_index, int size, int h)
static av_always_inline int cmp(MpegEncContext *s, const int x, const int y, const int subx, const int suby, const int size, const int h, int ref_index, int src_index, me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags)
compares a block (either a full macroblock or a partition thereof) against a proposed motion-compensa...
int last_predictor_count
amount of previous MV predictors (2a+1 x 2a+1 square)
static int get_mb_score(MpegEncContext *s, int mx, int my, int src_index, int ref_index, int size, int h, int add_rate)
static int qpel_motion_search(MpegEncContext *s, int *mx_ptr, int *my_ptr, int dmin, int src_index, int ref_index, int size, int h)
int penalty_factor
an estimate of the bits required to code a given mv value, e.g.
static int l2s_dia_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags)
int first_slice_line
used in mpeg4 too to handle resync markers
#define CHECK_QUARTER_MV(dx, dy, x, y)
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
struct AVCodecContext * avctx
static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV *2+1]
Table of number of bits a motion vector component needs.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
me_cmp_func me_sub_cmp[6]
uint32_t * map
map to avoid duplicate evaluations
int mv0_threshold
Note: Value depends upon the compare function used for fullpel ME.
static int var_diamond_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags)
int me_subpel_quality
subpel ME quality