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 =
c->me_sub_cmp[
size];
68 chroma_cmp_sub =
c->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);
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 =
c->mb_cmp[
size];
182 chroma_cmp_sub =
c->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 =
c->me_cmp[
size];
226 chroma_cmpf =
c->me_cmp[
size + 1];
229 cmp_sub =
c->me_sub_cmp[
size];
230 chroma_cmp_sub =
c->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);
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], &best_pos[
i],
sizeof(*best_pos) * (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 =
c->me_cmp[
size];
428 chroma_cmpf =
c->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 =
c->me_cmp[
size];
469 chroma_cmpf =
c->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 =
c->me_cmp[
size];
512 chroma_cmpf =
c->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 =
c->me_cmp[
size];
549 chroma_cmpf =
c->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 =
c->me_cmp[
size];
588 chroma_cmpf =
c->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 =
c->me_cmp[
size];
631 chroma_cmpf =
c->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 =
c->me_cmp[
size];
697 chroma_cmpf =
c->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 =
c->me_cmp[
size];
783 chroma_cmpf =
c->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,
const 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 =
c->me_pre_cmp[
size];
884 chroma_cmpf =
c->me_pre_cmp[
size + 1];
886 penalty_factor=
c->penalty_factor;
887 cmpf =
c->me_cmp[
size];
888 chroma_cmpf =
c->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)
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)
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);
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 const 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,
const 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 =
c->me_cmp[
size];
1012 chroma_cmpf =
c->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)
1039 (
last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)