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;\
38 #define CHECK_HALF_MV(dx, dy, x, y)\
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)\
48 int *mx_ptr,
int *my_ptr,
int dmin,
49 int src_index,
int ref_index,
53 const int mx = *mx_ptr;
54 const int my = *my_ptr;
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)
79 if (mx > xmin && mx < xmax &&
80 my > ymin && my < ymax) {
95 uint32_t *map= c->
map;
144 assert(bx >= xmin*2 && bx <= xmax*2 && by >= ymin*2 && by <= ymax*2);
154 int *mx_ptr,
int *my_ptr,
int dmin,
155 int src_index,
int ref_index,
164 int src_index,
int ref_index,
int size,
172 const int mask= 1+2*qpel;
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);
188 if(add_rate && (mx || my || size>0))
195 int ref_index,
int size,
int h,
int add_rate)
197 return get_mb_score(s, mx, my, src_index, ref_index, size, h, add_rate);
200 #define CHECK_QUARTER_MV(dx, dy, x, y)\
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)\
210 int *mx_ptr,
int *my_ptr,
int dmin,
211 int src_index,
int ref_index,
215 const int mx = *mx_ptr;
216 const int my = *my_ptr;
220 uint32_t *map= c->
map;
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)
246 if (mx > xmin && mx < xmax &&
247 my > ymin && my < ymax) {
248 int bx=4*mx, by=4*my;
253 const int l= score_map[(index- 1 )&(
ME_MAP_SIZE-1)];
260 memset(best, 64,
sizeof(
int)*8);
267 for(ny= -3; ny <= 3; ny++){
268 for(nx= -3; nx <= 3; nx++){
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;
276 if((nx&3)==0 && (ny&3)==0)
continue;
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));
288 best_pos[i][0]= nx + 4*mx;
289 best_pos[i][1]= ny + 4*my;
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;
307 tl=
cmp(s, mx-1, my-1, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
310 cxy= 2*tl + (cx + cy)/4 - (cx2 + cy2) - 2*c;
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);
318 for(ny= -3; ny <= 3; ny++){
319 for(nx= -3; nx <= 3; nx++){
321 int score= ny*nx*cxy + nx*nx*cx2 + ny*ny*cy2 + nx*cx + ny*cy + 32*c;
324 if((nx&3)==0 && (ny&3)==0)
continue;
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));
335 best_pos[i][0]= nx + 4*mx;
336 best_pos[i][1]= ny + 4*my;
343 for(i=0; i<subpel_quality; i++){
349 assert(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);
362 #define CHECK_MV(x,y)\
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);\
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)\
379 #define CHECK_CLIPPED_MV(ax,ay)\
383 const int Lx2= FFMAX(xmin, FFMIN(Lx, xmax));\
384 const int Ly2= FFMAX(ymin, FFMIN(Ly, ymax));\
388 #define CHECK_MV_DIR(x,y,new_dir)\
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);\
395 score_map[index]= d;\
396 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\
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);\
412 #define LOAD_COMMON2\
413 uint32_t *map= c->map;\
414 const int qpel= flags&FLAG_QPEL;\
415 const int shift= 1+qpel;\
418 int src_index,
int ref_index,
int const penalty_factor,
432 const unsigned key = (best[1]<<
ME_MAP_MV_BITS) + best[0] + map_generation;
435 score_map[
index]=
cmp(s, best[0], best[1], 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
442 const int dir= next_dir;
443 const int x= best[0];
444 const int y= best[1];
459 int src_index,
int ref_index,
int const penalty_factor,
472 for(dia_size=1; dia_size<=4; dia_size++){
474 const int x= best[0];
475 const int y= best[1];
477 if(dia_size&(dia_size-1))
continue;
479 if( x + dia_size > xmax
480 || x - dia_size < xmin
481 || y + dia_size > ymax
482 || y - dia_size < ymin)
485 for(dir= 0; dir<dia_size; dir+=2){
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 );
494 if(x!=best[0] || y!=best[1])
501 int src_index,
int ref_index,
int const penalty_factor,
502 int size,
int h,
int flags,
int dia_size)
510 const int dec= dia_size & (dia_size-1);
515 for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
528 }
while(best[0] != x || best[1] != y);
535 int src_index,
int ref_index,
int const penalty_factor,
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}};
552 for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
559 }
while(best[0] != x || best[1] != y);
573 int src_index,
int ref_index,
int const penalty_factor,
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},};
593 for(x2=
FFMAX(x-dia_size+1, xmin); x2<=
FFMIN(x+dia_size-1,xmax); x2+=2){
596 for(y2=
FFMAX(y-dia_size/2+1, ymin); y2<=
FFMIN(y+dia_size/2-1,ymax); y2+=2){
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++){
610 for(j=1; j<=dia_size/4; j++){
616 return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2);
620 int src_index,
int ref_index,
int const penalty_factor,
629 const int dia_size= c->
dia_size&0xFF;
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++){
654 #define SAB_CHECK_MV(ax,ay)\
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);\
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){\
666 while(d >= minima[j].height) j++;\
668 memmove(&minima [j+1], &minima [j], (minima_count - j - 1)*sizeof(Minima));\
670 minima[j].checked= 0;\
671 minima[j].height= d;\
681 #define MAX_SAB_SIZE ME_MAP_SIZE
683 int src_index,
int ref_index,
int const penalty_factor,
702 uint32_t key= map[i];
708 minima[j].
height= score_map[i];
715 if( minima[j].x > xmax || minima[j].x < xmin
716 || minima[j].y > ymax || minima[j].y < ymin)
720 if(minima[j].x || minima[j].y)
728 for(; j<minima_count; j++){
729 minima[j].
height=256*256*256*64;
731 minima[j].
x= minima[j].
y=0;
734 for(i=0; i<minima_count; i++){
735 const int x= minima[i].
x;
736 const int y= minima[i].
y;
739 if(minima[i].
checked)
continue;
741 if( x >= xmax || x <= xmin
742 || y >= ymax || y <= ymin)
753 best[0]= minima[0].
x;
754 best[1]= minima[0].
y;
757 if( best[0] < xmax && best[0] > xmin
758 && best[1] < ymax && best[1] > ymin){
770 int src_index,
int ref_index,
int const penalty_factor,
783 for(dia_size=1; dia_size<=c->
dia_size; dia_size++){
785 const int x= best[0];
786 const int y= best[1];
788 start=
FFMAX(0, y + dia_size - ymax);
789 end =
FFMIN(dia_size, xmax - x + 1);
790 for(dir= start; dir<end; dir++){
794 CHECK_MV(x + dir , y + dia_size - dir);
797 start=
FFMAX(0, x + dia_size - xmax);
798 end =
FFMIN(dia_size, y - ymin + 1);
799 for(dir= start; dir<end; dir++){
803 CHECK_MV(x + dia_size - dir, y - dir );
806 start=
FFMAX(0, -y + dia_size + ymin );
807 end =
FFMIN(dia_size, x - xmin + 1);
808 for(dir= start; dir<end; dir++){
812 CHECK_MV(x - dir , y - dia_size + dir);
815 start=
FFMAX(0, -x + dia_size + xmin );
816 end =
FFMIN(dia_size, ymax - y + 1);
817 for(dir= start; dir<end; dir++){
821 CHECK_MV(x - dia_size + dir, y + dir );
824 if(x!=best[0] || y!=best[1])
831 int src_index,
int ref_index,
int const penalty_factor,
835 return funny_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
837 return sab_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
839 return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
841 return full_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
843 return umh_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
845 return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, c->
dia_size&0xFF);
847 return l2s_dia_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
849 return var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
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)
870 unsigned map_generation;
873 const int ref_mv_xy= s->
mb_x + s->
mb_y*ref_mv_stride;
892 dmin=
cmp(s, 0, 0, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
893 map[0]= map_generation;
904 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
921 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
929 (last_mv[ref_mv_xy-1][1]*ref_mv_scale + (1<<15))>>16)
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)
935 (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
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)
944 const int xstart=
FFMAX(0, s->
mb_x - count);
945 const int ystart=
FFMAX(0, s->
mb_y - count);
950 for(mb_y=ystart; mb_y<yend; mb_y++){
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;
957 if(mx>xmax || mx<xmin || my>ymax || my<ymin)
continue;
964 dmin=
diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
975 int P[10][2],
int src_index,
int ref_index,
976 int16_t (*last_mv)[2],
int ref_mv_scale,
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);
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);
991 int *mx_ptr,
int *my_ptr,
int P[10][2],
992 int src_index,
int ref_index, int16_t (*last_mv)[2],
998 unsigned map_generation;
1003 const int ref_mv_xy= s->
mb_x + s->
mb_y *ref_mv_stride;
1020 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1030 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1034 (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
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)
1040 dmin=
diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
1050 int *mx_ptr,
int *my_ptr,
int P[10][2],
1051 int src_index,
int ref_index, int16_t (*last_mv)[2],
1057 unsigned map_generation;
1062 const int ref_mv_xy= s->
mb_x + s->
mb_y *ref_mv_stride;
1079 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1089 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1093 (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
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)
1099 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(* me_cmp_func)(void *s, 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.
me_cmp_func me_pre_cmp[6]
int me_cmp
motion estimation comparison function
#define CODEC_FLAG_MV0
Always try a MB with MV=<0,0>.
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
DSPContext dsp
pointers for accelerated dsp functions
#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 ...
uint32_t * map
map to avoid duplicate evaluations
int mv0_threshold
Note: Value depends upon the compare function used for fullpel ME.
int flags
AVCodecContext.flags (HQ, MV4, ...)
me_cmp_func me_sub_cmp[6]
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