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) {
94 #if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 1
145 av_assert2(bx >= xmin*2 && bx <= xmax*2 && by >= ymin*2 && by <= ymax*2);
155 int *mx_ptr,
int *my_ptr,
int dmin,
156 int src_index,
int ref_index,
165 int src_index,
int ref_index,
int size,
172 const int mask= 1+2*qpel;
183 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);
185 if(add_rate && (mx || my || size>0))
192 int ref_index,
int size,
int h,
int add_rate)
194 return get_mb_score(s, mx, my, src_index, ref_index, size, h, add_rate);
197 #define CHECK_QUARTER_MV(dx, dy, x, y)\
199 const int hx= 4*(x)+(dx);\
200 const int hy= 4*(y)+(dy);\
201 d= cmp_qpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
202 d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\
203 COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
207 int *mx_ptr,
int *my_ptr,
int dmin,
208 int src_index,
int ref_index,
212 const int mx = *mx_ptr;
213 const int my = *my_ptr;
217 uint32_t *map= c->
map;
238 dmin=
cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
239 if(mx || my || size>0)
243 if (mx > xmin && mx < xmax &&
244 my > ymin && my < ymax) {
245 int bx=4*mx, by=4*my;
250 const int l= score_map[(index- 1 )&(
ME_MAP_SIZE-1)];
257 memset(best, 64,
sizeof(
int)*8);
264 for(ny= -3; ny <= 3; ny++){
265 for(nx= -3; nx <= 3; nx++){
267 const int64_t
t2= nx*nx*(tr + tl - 2*t) + 4*nx*(tr-tl) + 32*t;
268 const int64_t
c2= nx*nx*( r + l - 2*
c) + 4*nx*( r- l) + 32*
c;
269 const int64_t b2= nx*nx*(br + bl - 2*
b) + 4*nx*(br-bl) + 32*
b;
270 int score= (ny*ny*(b2 + t2 - 2*
c2) + 4*ny*(b2 - t2) + 32*c2 + 512)>>10;
273 if((nx&3)==0 && (ny&3)==0)
continue;
282 memmove(&best[i+1], &best[i],
sizeof(
int)*(7-i));
283 memmove(&best_pos[i+1][0], &best_pos[i][0],
sizeof(
int)*2*(7-i));
285 best_pos[i][0]= nx + 4*mx;
286 best_pos[i][1]= ny + 4*my;
295 const int cx = 4*(r - l);
296 const int cx2= r + l - 2*
c;
297 const int cy = 4*(b - t);
298 const int cy2= b + t - 2*
c;
304 tl=
cmp(s, mx-1, my-1, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
307 cxy= 2*tl + (cx + cy)/4 - (cx2 + cy2) - 2*
c;
313 av_assert2(16*cxy + 16*cy2 + 16*cx2 - 4*cy - 4*cx + 32*c == 32*tl);
315 for(ny= -3; ny <= 3; ny++){
316 for(nx= -3; nx <= 3; nx++){
318 int score= ny*nx*cxy + nx*nx*cx2 + ny*ny*cy2 + nx*cx + ny*cy + 32*
c;
321 if((nx&3)==0 && (ny&3)==0)
continue;
329 memmove(&best[i+1], &best[i],
sizeof(
int)*(7-i));
330 memmove(&best_pos[i+1][0], &best_pos[i][0],
sizeof(
int)*2*(7-i));
332 best_pos[i][0]= nx + 4*mx;
333 best_pos[i][1]= ny + 4*my;
340 for(i=0; i<subpel_quality; i++){
346 av_assert2(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);
359 #define CHECK_MV(x,y)\
361 const unsigned key = ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
362 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
363 av_assert2((x) >= xmin);\
364 av_assert2((x) <= xmax);\
365 av_assert2((y) >= ymin);\
366 av_assert2((y) <= ymax);\
367 if(map[index]!=key){\
368 d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
370 score_map[index]= d;\
371 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\
372 COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\
376 #define CHECK_CLIPPED_MV(ax,ay)\
380 const int Lx2= FFMAX(xmin, FFMIN(Lx, xmax));\
381 const int Ly2= FFMAX(ymin, FFMIN(Ly, ymax));\
385 #define CHECK_MV_DIR(x,y,new_dir)\
387 const unsigned key = ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
388 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
389 if(map[index]!=key){\
390 d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
392 score_map[index]= d;\
393 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*penalty_factor;\
403 #define check(x,y,S,v)\
404 if( (x)<(xmin<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d xmin" #v, xmin, (x), (y), s->mb_x, s->mb_y);\
405 if( (x)>(xmax<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d xmax" #v, xmax, (x), (y), s->mb_x, s->mb_y);\
406 if( (y)<(ymin<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d ymin" #v, ymin, (x), (y), s->mb_x, s->mb_y);\
407 if( (y)>(ymax<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d ymax" #v, ymax, (x), (y), s->mb_x, s->mb_y);\
409 #define LOAD_COMMON2\
410 uint32_t *map= c->map;\
411 const int qpel= flags&FLAG_QPEL;\
412 const int shift= 1+qpel;\
415 int src_index,
int ref_index,
int const penalty_factor,
429 const unsigned key = (best[1]<<
ME_MAP_MV_BITS) + best[0] + map_generation;
432 score_map[
index]=
cmp(s, best[0], best[1], 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
439 const int dir= next_dir;
440 const int x= best[0];
441 const int y= best[1];
456 int src_index,
int ref_index,
int const penalty_factor,
469 for(dia_size=1; dia_size<=4; dia_size++){
471 const int x= best[0];
472 const int y= best[1];
474 if(dia_size&(dia_size-1))
continue;
476 if( x + dia_size > xmax
477 || x - dia_size < xmin
478 || y + dia_size > ymax
479 || y - dia_size < ymin)
482 for(dir= 0; dir<dia_size; dir+=2){
485 CHECK_MV(x + dir , y + dia_size - dir);
486 CHECK_MV(x + dia_size - dir, y - dir );
487 CHECK_MV(x - dir , y - dia_size + dir);
488 CHECK_MV(x - dia_size + dir, y + dir );
491 if(x!=best[0] || y!=best[1])
498 int src_index,
int ref_index,
int const penalty_factor,
507 const int dec= dia_size & (dia_size-1);
512 for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
525 }
while(best[0] != x || best[1] != y);
532 int src_index,
int ref_index,
int const penalty_factor,
542 const int dec= dia_size & (dia_size-1);
543 static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1},
544 { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}};
549 for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
556 }
while(best[0] != x || best[1] != y);
570 int src_index,
int ref_index,
int const penalty_factor,
578 int x,
y,x2,y2, i, j, d;
579 const int dia_size= c->
dia_size&0xFE;
580 static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2},
581 { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2},
582 {-2, 3}, { 0, 4}, { 2, 3},
583 {-2,-3}, { 0,-4}, { 2,-3},};
590 for(x2=
FFMAX(x-dia_size+1, xmin); x2<=
FFMIN(x+dia_size-1,xmax); x2+=2){
593 for(y2=
FFMAX(y-dia_size/2+1, ymin); y2<=
FFMIN(y+dia_size/2-1,ymax); y2+=2){
599 for(y2=
FFMAX(y-2, ymin); y2<=
FFMIN(y+2,ymax); y2++){
600 for(x2=
FFMAX(x-2, xmin); x2<=
FFMIN(x+2,xmax); x2++){
607 for(j=1; j<=dia_size/4; j++){
613 return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2);
617 int src_index,
int ref_index,
int const penalty_factor,
626 const int dia_size= c->
dia_size&0xFF;
631 for(y=
FFMAX(-dia_size, ymin); y<=
FFMIN(dia_size,ymax); y++){
632 for(x=
FFMAX(-dia_size, xmin); x<=
FFMIN(dia_size,xmax); x++){
651 #define SAB_CHECK_MV(ax,ay)\
653 const unsigned key = ((ay)<<ME_MAP_MV_BITS) + (ax) + map_generation;\
654 const int index= (((ay)<<ME_MAP_SHIFT) + (ax))&(ME_MAP_SIZE-1);\
655 if(map[index]!=key){\
656 d= cmp(s, ax, ay, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
658 score_map[index]= d;\
659 d += (mv_penalty[((ax)<<shift)-pred_x] + mv_penalty[((ay)<<shift)-pred_y])*penalty_factor;\
660 if(d < minima[minima_count-1].height){\
663 while(d >= minima[j].height) j++;\
665 memmove(&minima [j+1], &minima [j], (minima_count - j - 1)*sizeof(Minima));\
667 minima[j].checked= 0;\
668 minima[j].height= d;\
678 #define MAX_SAB_SIZE ME_MAP_SIZE
680 int src_index,
int ref_index,
int const penalty_factor,
701 uint32_t key= map[i];
707 minima[j].
height= score_map[i];
714 if( minima[j].x > xmax || minima[j].x < xmin
715 || minima[j].
y > ymax || minima[j].
y < ymin)
719 if(minima[j].x || minima[j].
y)
727 for(; j<minima_count; j++){
728 minima[j].
height=256*256*256*64;
730 minima[j].
x= minima[j].
y=0;
733 for(i=0; i<minima_count; i++){
734 const int x= minima[i].
x;
735 const int y= minima[i].
y;
738 if(minima[i].
checked)
continue;
740 if( x >= xmax || x <= xmin
741 || y >= ymax || y <= ymin)
752 best[0]= minima[0].
x;
753 best[1]= minima[0].
y;
756 if( best[0] < xmax && best[0] > xmin
757 && best[1] < ymax && best[1] > ymin){
769 int src_index,
int ref_index,
int const penalty_factor,
782 for(dia_size=1; dia_size<=c->
dia_size; dia_size++){
784 const int x= best[0];
785 const int y= best[1];
787 start=
FFMAX(0, y + dia_size - ymax);
788 end =
FFMIN(dia_size, xmax - x + 1);
789 for(dir= start; dir<
end; dir++){
793 CHECK_MV(x + dir , y + dia_size - dir);
796 start=
FFMAX(0, x + dia_size - xmax);
797 end =
FFMIN(dia_size, y - ymin + 1);
798 for(dir= start; dir<
end; dir++){
802 CHECK_MV(x + dia_size - dir, y - dir );
805 start=
FFMAX(0, -y + dia_size + ymin );
806 end =
FFMIN(dia_size, x - xmin + 1);
807 for(dir= start; dir<
end; dir++){
811 CHECK_MV(x - dir , y - dia_size + dir);
814 start=
FFMAX(0, -x + dia_size + xmin );
815 end =
FFMIN(dia_size, ymax - y + 1);
816 for(dir= start; dir<
end; dir++){
820 CHECK_MV(x - dia_size + dir, y + dir );
823 if(x!=best[0] || y!=best[1])
830 int src_index,
int ref_index,
int const penalty_factor,
834 return funny_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
836 return sab_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
838 return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
840 return full_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
842 return umh_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
844 return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, c->
dia_size&0xFF);
846 return l2s_dia_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
848 return var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
858 int P[10][2],
int src_index,
int ref_index, int16_t (*
last_mv)[2],
869 unsigned map_generation;
872 const int ref_mv_xy= s->
mb_x + s->
mb_y*ref_mv_stride;
891 dmin=
cmp(s, 0, 0, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
892 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)
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)
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)
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)
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 shift(int a, int b)
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 last_mv[2][2][2]
last MV, used for MV prediction in MPEG1 & B-frame MPEG4
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]
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
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)
static av_cold int end(AVCodecContext *avctx)
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)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
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(* me_cmp_func)(struct MpegEncContext *c, uint8_t *blk1, uint8_t *blk2, ptrdiff_t stride, int h)
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