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;
58 const int penalty_factor=
c->sub_penalty_factor;
67 cmp_sub =
s->mecc.me_sub_cmp[
size];
68 chroma_cmp_sub =
s->mecc.me_sub_cmp[
size + 1];
76 if(
c->avctx->me_cmp !=
c->avctx->me_sub_cmp){
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
97 unsigned map_generation=
c->map_generation;
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,
170 const int penalty_factor=
c->mb_penalty_factor;
171 const int flags=
c->mb_flags;
173 const int mask= 1+2*qpel;
181 cmp_sub =
s->mecc.mb_cmp[
size];
182 chroma_cmp_sub =
s->mecc.mb_cmp[
size + 1];
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)
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;
215 const int penalty_factor=
c->sub_penalty_factor;
216 const unsigned map_generation =
c->map_generation;
217 const int subpel_quality=
c->avctx->me_subpel_quality;
218 uint32_t *
map=
c->map;
225 cmpf =
s->mecc.me_cmp[
size];
226 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
229 cmp_sub =
s->mecc.me_sub_cmp[
size];
230 chroma_cmp_sub =
s->mecc.me_sub_cmp[
size + 1];
238 if(
c->avctx->me_cmp !=
c->avctx->me_sub_cmp){
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;
258 memset(best, 64,
sizeof(
int)*8);
259 if(
s->me.dia_size>=2){
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;
306 tl=
cmp(
s, mx-1, my-1, 0, 0,
size,
h, ref_index, src_index, cmpf, chroma_cmpf,
flags);
309 cxy= 2*tl + (cx + cy)/4 - (cx2 + cy2) - 2*
c;
315 av_assert2(16*cxy + 16*cy2 + 16*cx2 - 4*cy - 4*cx + 32*
c == 32*tl);
317 for(ny= -3; ny <= 3; ny++){
318 for(nx= -3; nx <= 3; nx++){
320 int score= ny*nx*cxy + nx*nx*cx2 + ny*ny*cy2 + nx*cx + ny*cy + 32*
c;
323 if((nx&3)==0 && (ny&3)==0)
continue;
331 memmove(&best[
i+1], &best[
i],
sizeof(
int)*(7-
i));
332 memmove(best_pos[
i + 1], best_pos[
i],
sizeof(best_pos[0]) * (7 -
i));
334 best_pos[
i][0]= nx + 4*mx;
335 best_pos[
i][1]= ny + 4*my;
342 for(
i=0;
i<subpel_quality;
i++){
348 av_assert2(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);
361 #define CHECK_MV(x,y)\
363 const unsigned key = ((unsigned)(y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
364 const int index= (((unsigned)(y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
365 av_assert2((x) >= xmin);\
366 av_assert2((x) <= xmax);\
367 av_assert2((y) >= ymin);\
368 av_assert2((y) <= ymax);\
369 if(map[index]!=key){\
370 d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
372 score_map[index]= d;\
373 d += (mv_penalty[((x)*(1<<shift))-pred_x] + mv_penalty[((y)*(1<<shift))-pred_y])*penalty_factor;\
374 COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\
378 #define CHECK_CLIPPED_MV(ax,ay)\
382 const int Lx2= FFMAX(xmin, FFMIN(Lx, xmax));\
383 const int Ly2= FFMAX(ymin, FFMIN(Ly, ymax));\
387 #define CHECK_MV_DIR(x,y,new_dir)\
389 const unsigned key = ((unsigned)(y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
390 const int index= (((unsigned)(y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
391 if(map[index]!=key){\
392 d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
394 score_map[index]= d;\
395 d += (mv_penalty[(int)((unsigned)(x)<<shift)-pred_x] + mv_penalty[(int)((unsigned)(y)<<shift)-pred_y])*penalty_factor;\
405 #define check(x,y,S,v)\
406 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);\
407 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);\
408 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);\
409 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);\
411 #define LOAD_COMMON2\
412 uint32_t *map= c->map;\
413 const int qpel= flags&FLAG_QPEL;\
414 const int shift= 1+qpel;\
417 int src_index,
int ref_index,
const int penalty_factor,
425 unsigned map_generation =
c->map_generation;
427 cmpf =
s->mecc.me_cmp[
size];
428 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
431 const unsigned key = ((unsigned)best[1]<<
ME_MAP_MV_BITS) + best[0] + map_generation;
434 score_map[
index]=
cmp(
s, best[0], best[1], 0, 0,
size,
h, ref_index, src_index, cmpf, chroma_cmpf,
flags);
441 const int dir= next_dir;
442 const int x= best[0];
443 const int y= best[1];
458 int src_index,
int ref_index,
const int penalty_factor,
466 unsigned map_generation =
c->map_generation;
468 cmpf =
s->mecc.me_cmp[
size];
469 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
471 for(dia_size=1; dia_size<=4; dia_size++){
473 const int x= best[0];
474 const int y= best[1];
476 if(dia_size&(dia_size-1))
continue;
478 if( x + dia_size > xmax
479 || x - dia_size < xmin
480 || y + dia_size > ymax
481 || y - dia_size < ymin)
484 for(dir= 0; dir<dia_size; dir+=2){
487 CHECK_MV(x + dir , y + dia_size - dir);
488 CHECK_MV(x + dia_size - dir, y - dir );
489 CHECK_MV(x - dir , y - dia_size + dir);
490 CHECK_MV(x - dia_size + dir, y + dir );
493 if(x!=best[0] || y!=best[1])
500 int src_index,
int ref_index,
const int penalty_factor,
507 unsigned map_generation =
c->map_generation;
509 const int dec= dia_size & (dia_size-1);
511 cmpf =
s->mecc.me_cmp[
size];
512 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
514 for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
527 }
while(best[0] != x || best[1] != y);
534 int src_index,
int ref_index,
const int penalty_factor,
541 unsigned map_generation =
c->map_generation;
543 int dia_size=
c->dia_size&0xFF;
544 const int dec= dia_size & (dia_size-1);
545 static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1},
546 { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}};
548 cmpf =
s->mecc.me_cmp[
size];
549 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
551 for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){
558 }
while(best[0] != x || best[1] != y);
572 int src_index,
int ref_index,
const int penalty_factor,
579 unsigned map_generation =
c->map_generation;
580 int x,y,x2,y2,
i, j, d;
581 const int dia_size=
c->dia_size&0xFE;
582 static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2},
583 { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2},
584 {-2, 3}, { 0, 4}, { 2, 3},
585 {-2,-3}, { 0,-4}, { 2,-3},};
587 cmpf =
s->mecc.me_cmp[
size];
588 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
592 for(x2=
FFMAX(x-dia_size+1, xmin); x2<=
FFMIN(x+dia_size-1,xmax); x2+=2){
595 for(y2=
FFMAX(y-dia_size/2+1, ymin); y2<=
FFMIN(y+dia_size/2-1,ymax); y2+=2){
601 for(y2=
FFMAX(y-2, ymin); y2<=
FFMIN(y+2,ymax); y2++){
602 for(x2=
FFMAX(x-2, xmin); x2<=
FFMIN(x+2,xmax); x2++){
609 for(j=1; j<=dia_size/4; j++){
619 int src_index,
int ref_index,
const int penalty_factor,
626 unsigned map_generation =
c->map_generation;
628 const int dia_size=
c->dia_size&0xFF;
630 cmpf =
s->mecc.me_cmp[
size];
631 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
633 for(y=
FFMAX(-dia_size, ymin); y<=
FFMIN(dia_size,ymax); y++){
634 for(x=
FFMAX(-dia_size, xmin); x<=
FFMIN(dia_size,xmax); x++){
653 #define SAB_CHECK_MV(ax,ay)\
655 const unsigned key = ((ay)<<ME_MAP_MV_BITS) + (ax) + map_generation;\
656 const int index= (((ay)<<ME_MAP_SHIFT) + (ax))&(ME_MAP_SIZE-1);\
657 if(map[index]!=key){\
658 d= cmp(s, ax, ay, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\
660 score_map[index]= d;\
661 d += (mv_penalty[((ax)<<shift)-pred_x] + mv_penalty[((ay)<<shift)-pred_y])*penalty_factor;\
662 if(d < minima[minima_count-1].height){\
665 while(d >= minima[j].height) j++;\
667 memmove(&minima [j+1], &minima [j], (minima_count - j - 1)*sizeof(Minima));\
669 minima[j].checked= 0;\
670 minima[j].height= d;\
680 #define MAX_SAB_SIZE ME_MAP_SIZE
682 int src_index,
int ref_index,
const int penalty_factor,
688 const int minima_count=
FFABS(
c->dia_size);
692 unsigned map_generation =
c->map_generation;
696 cmpf =
s->mecc.me_cmp[
size];
697 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
710 minima[j].
height= score_map[
i];
717 if( minima[j].x > xmax || minima[j].x < xmin
718 || minima[j].y > ymax || minima[j].y < ymin)
722 if(minima[j].x || minima[j].y)
730 for(; j<minima_count; j++){
731 minima[j].
height=256*256*256*64;
733 minima[j].
x= minima[j].
y=0;
736 for(
i=0;
i<minima_count;
i++){
737 const int x= minima[
i].
x;
738 const int y= minima[
i].
y;
741 if(minima[
i].checked)
continue;
743 if( x >= xmax || x <= xmin
744 || y >= ymax || y <= ymin)
755 best[0]= minima[0].
x;
756 best[1]= minima[0].
y;
759 if( best[0] < xmax && best[0] > xmin
760 && best[1] < ymax && best[1] > ymin){
772 int src_index,
int ref_index,
const int penalty_factor,
780 unsigned map_generation =
c->map_generation;
782 cmpf =
s->mecc.me_cmp[
size];
783 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
785 for(dia_size=1; dia_size<=
c->dia_size; dia_size++){
787 const int x= best[0];
788 const int y= best[1];
790 start=
FFMAX(0, y + dia_size - ymax);
791 end =
FFMIN(dia_size, xmax - x + 1);
792 for(dir= start; dir<end; dir++){
796 CHECK_MV(x + dir , y + dia_size - dir);
799 start=
FFMAX(0, x + dia_size - xmax);
800 end =
FFMIN(dia_size, y - ymin + 1);
801 for(dir= start; dir<end; dir++){
805 CHECK_MV(x + dia_size - dir, y - dir );
808 start=
FFMAX(0, -y + dia_size + ymin );
809 end =
FFMIN(dia_size, x - xmin + 1);
810 for(dir= start; dir<end; dir++){
814 CHECK_MV(x - dir , y - dia_size + dir);
817 start=
FFMAX(0, -x + dia_size + xmin );
818 end =
FFMIN(dia_size, ymax - y + 1);
819 for(dir= start; dir<end; dir++){
823 CHECK_MV(x - dia_size + dir, y + dir );
826 if(x!=best[0] || y!=best[1])
833 int src_index,
int ref_index,
const int penalty_factor,
838 else if(
c->dia_size<-1)
840 else if(
c->dia_size<2)
842 else if(
c->dia_size>1024)
844 else if(
c->dia_size>768)
846 else if(
c->dia_size>512)
848 else if(
c->dia_size>256)
861 int P[10][2],
int src_index,
int ref_index, int16_t (*last_mv)[2],
872 unsigned map_generation;
874 const int ref_mv_stride=
s->mb_stride;
875 const int ref_mv_xy =
s->mb_x +
s->mb_y * ref_mv_stride;
882 penalty_factor=
c->pre_penalty_factor;
883 cmpf =
s->mecc.me_pre_cmp[
size];
884 chroma_cmpf =
s->mecc.me_pre_cmp[
size + 1];
886 penalty_factor=
c->penalty_factor;
887 cmpf =
s->mecc.me_cmp[
size];
888 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
894 dmin=
cmp(
s, 0, 0, 0, 0,
size,
h, ref_index, src_index, cmpf, chroma_cmpf,
flags);
895 map[0]= map_generation;
904 if (
s->first_slice_line) {
907 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
909 if(dmin<((
h*
h*
s->avctx->mv0_threshold)>>8)
924 (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
932 (last_mv[ref_mv_xy-1][1]*ref_mv_scale + (1<<15))>>16)
933 if(!
s->first_slice_line)
934 CHECK_CLIPPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
935 (last_mv[ref_mv_xy-ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
938 (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
939 if(
s->mb_y+1<
s->end_mb_y)
940 CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
941 (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
945 if(
c->avctx->last_predictor_count){
946 const int count=
c->avctx->last_predictor_count;
947 const int xstart=
FFMAX(0,
s->mb_x - count);
948 const int ystart=
FFMAX(0,
s->mb_y - count);
949 const int xend=
FFMIN(
s->mb_width ,
s->mb_x + count + 1);
950 const int yend=
FFMIN(
s->mb_height,
s->mb_y + count + 1);
953 for(mb_y=ystart; mb_y<yend; mb_y++){
955 for(mb_x=xstart; mb_x<xend; mb_x++){
956 const int xy= mb_x + 1 + (mb_y + 1)*ref_mv_stride;
957 int mx= (last_mv[xy][0]*ref_mv_scale + (1<<15))>>16;
958 int my= (last_mv[xy][1]*ref_mv_scale + (1<<15))>>16;
960 if(mx>xmax || mx<xmin || my>ymax || my<ymin)
continue;
978 int P[10][2],
int src_index,
int ref_index,
979 int16_t (*last_mv)[2],
int ref_mv_scale,
984 if(
c->flags==0 &&
h==16 &&
size==0){
985 return epzs_motion_search_internal(
s, mx_ptr, my_ptr,
P, src_index, ref_index, last_mv, ref_mv_scale, 0, 0, 16);
989 return epzs_motion_search_internal(
s, mx_ptr, my_ptr,
P, src_index, ref_index, last_mv, ref_mv_scale,
c->flags,
size,
h);
994 int *mx_ptr,
int *my_ptr,
int P[10][2],
995 int src_index,
int ref_index, int16_t (*last_mv)[2],
996 int ref_mv_scale,
const int size)
1001 unsigned map_generation;
1002 const int penalty_factor=
c->penalty_factor;
1004 const int ref_mv_stride=
s->mb_stride;
1005 const int ref_mv_xy=
s->mb_x +
s->mb_y *ref_mv_stride;
1011 cmpf =
s->mecc.me_cmp[
size];
1012 chroma_cmpf =
s->mecc.me_cmp[
size + 1];
1019 if (
s->first_slice_line) {
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)
1037 if(
s->mb_y+1<
s->end_mb_y)
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)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define flags(name, subs,...)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
const VDPAUPixFmtMap * map
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Table of number of bits a motion vector component needs.
static const uint16_t mask[17]
int(* me_cmp_func)(struct MpegEncContext *c, uint8_t *blk1, uint8_t *blk2, ptrdiff_t stride, int h)
static int minima_cmp(const void *a, const void *b)
static unsigned update_map_generation(MotionEstContext *c)
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...
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)
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)
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)
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)
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)
static int get_mb_score(MpegEncContext *s, int mx, int my, int src_index, int ref_index, int size, int h, int add_rate)
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 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 int qpel_motion_search(MpegEncContext *s, int *mx_ptr, int *my_ptr, int dmin, int src_index, int ref_index, int size, int h)
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)
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 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)
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 CHECK_QUARTER_MV(dx, dy, x, y)
#define SAB_CHECK_MV(ax, ay)
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)
#define CHECK_CLIPPED_MV(ax, ay)
#define CHECK_HALF_MV(dx, dy, x, y)
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 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)
#define CHECK_MV_DIR(x, y, new_dir)
#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 int shift(int a, int b)
Motion estimation context.
static double b2(void *priv, double x, double y)