32 uint32_t av_unused * const score_map= c->score_map;\ 33 const int av_unused xmin= c->xmin;\ 34 const int av_unused ymin= c->ymin;\ 35 const int av_unused xmax= c->xmax;\ 36 const int av_unused ymax= c->ymax;\ 37 const uint8_t *mv_penalty = c->current_mv_penalty; \ 38 const int pred_x= c->pred_x;\ 39 const int pred_y= c->pred_y;\ 41 #define CHECK_HALF_MV(dx, dy, x, y)\ 43 const int hx= 2*(x)+(dx);\ 44 const int hy= 2*(y)+(dy);\ 45 d= cmp_hpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);\ 46 d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\ 47 COPY3_IF_LT(dmin, d, bx, hx, by, hy)\ 51 int *mx_ptr,
int *my_ptr,
int dmin,
52 int src_index,
int ref_index,
56 const int mx = *mx_ptr;
57 const int my = *my_ptr;
77 dmin=
cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
78 if(mx || my || size>0)
82 if (mx > xmin && mx < xmax &&
83 my > ymin && my < ymax) {
95 #if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 1 146 av_assert2(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;
184 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);
186 if(add_rate && (mx || my || size>0))
193 int ref_index,
int size,
int h,
int add_rate)
195 return get_mb_score(s, mx, my, src_index, ref_index, size, h, add_rate);
198 #define CHECK_QUARTER_MV(dx, dy, x, y)\ 200 const int hx= 4*(x)+(dx);\ 201 const int hy= 4*(y)+(dy);\ 202 d= cmp_qpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\ 203 d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\ 204 COPY3_IF_LT(dmin, d, bx, hx, by, hy)\ 208 int *mx_ptr,
int *my_ptr,
int dmin,
209 int src_index,
int ref_index,
213 const int mx = *mx_ptr;
214 const int my = *my_ptr;
239 dmin=
cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);
240 if(mx || my || size>0)
244 if (mx > xmin && mx < xmax &&
245 my > ymin && my < ymax) {
246 int bx=4*mx, by=4*my;
251 const int l= score_map[(index- 1 )&(
ME_MAP_SIZE-1)];
258 memset(best, 64,
sizeof(
int)*8);
265 for(ny= -3; ny <= 3; ny++){
266 for(nx= -3; nx <= 3; nx++){
268 const int64_t
t2= nx*nx*(tr + tl - 2*t) + 4*nx*(tr-tl) + 32*t;
269 const int64_t
c2= nx*nx*( r + l - 2*
c) + 4*nx*( r- l) + 32*
c;
270 const int64_t
b2= nx*nx*(br + bl - 2*
b) + 4*nx*(br-bl) + 32*
b;
271 int score= (ny*ny*(b2 + t2 - 2*
c2) + 4*ny*(b2 - t2) + 32*c2 + 512)>>10;
274 if((nx&3)==0 && (ny&3)==0)
continue;
283 memmove(&best[i+1], &best[i],
sizeof(
int)*(7-i));
284 memmove(&best_pos[i+1][0], &best_pos[i][0],
sizeof(
int)*2*(7-i));
286 best_pos[
i][0]= nx + 4*mx;
287 best_pos[
i][1]= ny + 4*my;
296 const int cx = 4*(r - l);
297 const int cx2= r + l - 2*
c;
298 const int cy = 4*(b - t);
299 const int cy2= b + t - 2*
c;
305 tl=
cmp(s, mx-1, my-1, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
308 cxy= 2*tl + (cx + cy)/4 - (cx2 + cy2) - 2*
c;
314 av_assert2(16*cxy + 16*cy2 + 16*cx2 - 4*cy - 4*cx + 32*c == 32*tl);
316 for(ny= -3; ny <= 3; ny++){
317 for(nx= -3; nx <= 3; nx++){
319 int score= ny*nx*cxy + nx*nx*cx2 + ny*ny*cy2 + nx*cx + ny*cy + 32*
c;
322 if((nx&3)==0 && (ny&3)==0)
continue;
330 memmove(&best[i+1], &best[i],
sizeof(
int)*(7-i));
331 memmove(&best_pos[i+1][0], &best_pos[i][0],
sizeof(
int)*2*(7-i));
333 best_pos[
i][0]= nx + 4*mx;
334 best_pos[
i][1]= ny + 4*my;
341 for(i=0; i<subpel_quality; i++){
347 av_assert2(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);
360 #define CHECK_MV(x,y)\ 362 const unsigned key = ((unsigned)(y)<<ME_MAP_MV_BITS) + (x) + map_generation;\ 363 const int index= (((unsigned)(y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\ 364 av_assert2((x) >= xmin);\ 365 av_assert2((x) <= xmax);\ 366 av_assert2((y) >= ymin);\ 367 av_assert2((y) <= ymax);\ 368 if(map[index]!=key){\ 369 d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\ 371 score_map[index]= d;\ 372 d += (mv_penalty[((x)*(1<<shift))-pred_x] + mv_penalty[((y)*(1<<shift))-pred_y])*penalty_factor;\ 373 COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\ 377 #define CHECK_CLIPPED_MV(ax,ay)\ 381 const int Lx2= FFMAX(xmin, FFMIN(Lx, xmax));\ 382 const int Ly2= FFMAX(ymin, FFMIN(Ly, ymax));\ 386 #define CHECK_MV_DIR(x,y,new_dir)\ 388 const unsigned key = ((unsigned)(y)<<ME_MAP_MV_BITS) + (x) + map_generation;\ 389 const int index= (((unsigned)(y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\ 390 if(map[index]!=key){\ 391 d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\ 393 score_map[index]= d;\ 394 d += (mv_penalty[(int)((unsigned)(x)<<shift)-pred_x] + mv_penalty[(int)((unsigned)(y)<<shift)-pred_y])*penalty_factor;\ 404 #define check(x,y,S,v)\ 405 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);\ 406 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);\ 407 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);\ 408 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);\ 410 #define LOAD_COMMON2\ 411 uint32_t *map= c->map;\ 412 const int qpel= flags&FLAG_QPEL;\ 413 const int shift= 1+qpel;\ 416 int src_index,
int ref_index,
const int penalty_factor,
430 const unsigned key = ((unsigned)best[1]<<
ME_MAP_MV_BITS) + best[0] + map_generation;
432 if (
map[index] != key) {
433 score_map[
index]=
cmp(s, best[0], best[1], 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);
440 const int dir= next_dir;
441 const int x= best[0];
442 const int y= best[1];
457 int src_index,
int ref_index,
const int penalty_factor,
470 for(dia_size=1; dia_size<=4; dia_size++){
472 const int x= best[0];
473 const int y= best[1];
475 if(dia_size&(dia_size-1))
continue;
477 if( x + dia_size > xmax
478 || x - dia_size < xmin
479 || y + dia_size > ymax
480 || y - dia_size < ymin)
483 for(dir= 0; dir<dia_size; dir+=2){
486 CHECK_MV(x + dir , y + dia_size - dir);
487 CHECK_MV(x + dia_size - dir, y - dir );
488 CHECK_MV(x - dir , y - dia_size + dir);
489 CHECK_MV(x - dia_size + dir, y + dir );
492 if(x!=best[0] || y!=best[1])
499 int src_index,
int ref_index,
const int penalty_factor,
508 const int dec= dia_size & (dia_size-1);
513 for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
526 }
while(best[0] != x || best[1] != y);
533 int src_index,
int ref_index,
const int penalty_factor,
543 const int dec= dia_size & (dia_size-1);
544 static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1},
545 { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}};
550 for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
557 }
while(best[0] != x || best[1] != y);
571 int src_index,
int ref_index,
const int penalty_factor,
579 int x,y,x2,y2,
i, j, d;
580 const int dia_size= c->
dia_size&0xFE;
581 static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2},
582 { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2},
583 {-2, 3}, { 0, 4}, { 2, 3},
584 {-2,-3}, { 0,-4}, { 2,-3},};
591 for(x2=
FFMAX(x-dia_size+1, xmin); x2<=
FFMIN(x+dia_size-1,xmax); x2+=2){
594 for(y2=
FFMAX(y-dia_size/2+1, ymin); y2<=
FFMIN(y+dia_size/2-1,ymax); y2+=2){
600 for(y2=
FFMAX(y-2, ymin); y2<=
FFMIN(y+2,ymax); y2++){
601 for(x2=
FFMAX(x-2, xmin); x2<=
FFMIN(x+2,xmax); x2++){
608 for(j=1; j<=dia_size/4; j++){
614 return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2);
618 int src_index,
int ref_index,
const int penalty_factor,
627 const int dia_size= c->
dia_size&0xFF;
632 for(y=
FFMAX(-dia_size, ymin); y<=
FFMIN(dia_size,ymax); y++){
633 for(x=
FFMAX(-dia_size, xmin); x<=
FFMIN(dia_size,xmax); x++){
652 #define SAB_CHECK_MV(ax,ay)\ 654 const unsigned key = ((ay)<<ME_MAP_MV_BITS) + (ax) + map_generation;\ 655 const int index= (((ay)<<ME_MAP_SHIFT) + (ax))&(ME_MAP_SIZE-1);\ 656 if(map[index]!=key){\ 657 d= cmp(s, ax, ay, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\ 659 score_map[index]= d;\ 660 d += (mv_penalty[((ax)<<shift)-pred_x] + mv_penalty[((ay)<<shift)-pred_y])*penalty_factor;\ 661 if(d < minima[minima_count-1].height){\ 664 while(d >= minima[j].height) j++;\ 666 memmove(&minima [j+1], &minima [j], (minima_count - j - 1)*sizeof(Minima));\ 668 minima[j].checked= 0;\ 669 minima[j].height= d;\ 679 #define MAX_SAB_SIZE ME_MAP_SIZE 681 int src_index,
int ref_index,
const int penalty_factor,
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,
const int 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,
const int 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],
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)
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)
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],
995 int ref_mv_scale,
const int size)
1000 unsigned map_generation;
1004 const int ref_mv_xy= s->
mb_x + s->
mb_y *ref_mv_stride;
1021 (
last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1031 (
last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
1035 (
last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
1038 (
last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
1041 dmin=
diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Table of number of bits a motion vector component needs.
static int minima_cmp(const void *a, const void *b)
static unsigned update_map_generation(MotionEstContext *c)
static int shift(int a, int b)
int skip
set if ME is skipped for the current MB
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG-1 & B-frame MPEG-4
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) ...
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 av_cold int end(AVCodecContext *avctx)
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Motion estimation context.
int me_cmp
motion estimation comparison function
int(* me_cmp_func)(struct MpegEncContext *c, uint8_t *blk1, uint8_t *blk2, ptrdiff_t stride, int h)
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 int hex_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, const int penalty_factor, int size, int h, int flags, int dia_size)
static const uint16_t mask[17]
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 diamond_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, const int 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 l2s_dia_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, const int penalty_factor, int size, int h, int flags)
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)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
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.
int first_slice_line
used in MPEG-4 too to handle resync markers
static int full_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, const int penalty_factor, int size, int h, int flags)
static int umh_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, const int penalty_factor, int size, int h, int flags)
const VDPAUPixFmtMap * map
#define CHECK_QUARTER_MV(dx, dy, x, y)
static int funny_diamond_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, const int penalty_factor, int size, int h, int flags)
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
#define flags(name, subs,...)
struct AVCodecContext * avctx
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
static int sab_diamond_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, const int penalty_factor, int size, int h, int flags)
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, const int size)
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, const int penalty_factor, int size, int h, int flags)
int me_subpel_quality
subpel ME quality
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
static av_always_inline int small_diamond_search(MpegEncContext *s, int *best, int dmin, int src_index, int ref_index, const int penalty_factor, int size, int h, int flags)
static double b2(void *priv, double x, double y)