X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fmotion_est_template.c;h=8f730ef14fd5a7b7b6c897d8298c48d28a4208c2;hb=dc7e07ac1f015117a3abaa9c5f3a594cc7fd0b7a;hp=8ab6c7be49df4a2930b8f9cb6c9720ab6d4e5b9f;hpb=2750b827b3144a62fdc161a47341dd58764522b7;p=ffmpeg diff --git a/libavcodec/motion_est_template.c b/libavcodec/motion_est_template.c index 8ab6c7be49d..8f730ef14fd 100644 --- a/libavcodec/motion_est_template.c +++ b/libavcodec/motion_est_template.c @@ -1,62 +1,63 @@ /* - * Motion estimation + * Motion estimation * Copyright (c) 2002-2004 Michael Niedermayer * - * This library is free software; you can redistribute it and/or + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. + * version 2.1 of the License, or (at your option) any later version. * - * This library is distributed in the hope that it will be useful, + * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ - + /** - * @file motion_est_template.c + * @file * Motion estimation template. */ -//lets hope gcc will remove the unused vars ...(gcc 3.2.2 seems to do it ...) +//Let us hope gcc will remove the unused vars ...(gcc 3.2.2 seems to do it ...) #define LOAD_COMMON\ - uint32_t * const score_map= s->me.score_map;\ - const int xmin= s->me.xmin;\ - const int ymin= s->me.ymin;\ - const int xmax= s->me.xmax;\ - const int ymax= s->me.ymax;\ - uint8_t *mv_penalty= s->me.current_mv_penalty;\ - const int pred_x= s->me.pred_x;\ - const int pred_y= s->me.pred_y;\ + uint32_t av_unused * const score_map= c->score_map;\ + const int av_unused xmin= c->xmin;\ + const int av_unused ymin= c->ymin;\ + const int av_unused xmax= c->xmax;\ + const int av_unused ymax= c->ymax;\ + uint8_t *mv_penalty= c->current_mv_penalty;\ + const int pred_x= c->pred_x;\ + const int pred_y= c->pred_y;\ #define CHECK_HALF_MV(dx, dy, x, y)\ {\ const int hx= 2*(x)+(dx);\ const int hy= 2*(y)+(dy);\ - d= cmp(s, x, y, dx, dy, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);\ + d= cmp_hpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags);\ d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\ COPY3_IF_LT(dmin, d, bx, hx, by, hy)\ } #if 0 static int hpel_motion_search)(MpegEncContext * s, - int *mx_ptr, int *my_ptr, int dmin, - uint8_t *ref_data[3], + int *mx_ptr, int *my_ptr, int dmin, + uint8_t *ref_data[3], int size) { const int xx = 16 * s->mb_x + 8*(n&1); const int yy = 16 * s->mb_y + 8*(n>>1); const int mx = *mx_ptr; const int my = *my_ptr; - const int penalty_factor= s->me.sub_penalty_factor; - + const int penalty_factor= c->sub_penalty_factor; + LOAD_COMMON - + // INIT; //FIXME factorize me_cmp_func cmp, chroma_cmp, cmp_sub, chroma_cmp_sub; @@ -73,30 +74,30 @@ static int hpel_motion_search)(MpegEncContext * s, cmp_sub= s->dsp.me_sub_cmp[size]; chroma_cmp_sub= s->dsp.me_sub_cmp[size+1]; - if(s->me.skip){ //FIXME somehow move up (benchmark) + if(c->skip){ //FIXME somehow move up (benchmark) *mx_ptr = 0; *my_ptr = 0; return dmin; } - - if(s->avctx->me_cmp != s->avctx->me_sub_cmp){ + + if(c->avctx->me_cmp != c->avctx->me_sub_cmp){ CMP_HPEL(dmin, 0, 0, mx, my, size); if(mx || my) dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor; } - - if (mx > xmin && mx < xmax && + + if (mx > xmin && mx < xmax && my > ymin && my < ymax) { int bx=2*mx, by=2*my; int d= dmin; - + CHECK_HALF_MV(1, 1, mx-1, my-1) - CHECK_HALF_MV(0, 1, mx , my-1) + CHECK_HALF_MV(0, 1, mx , my-1) CHECK_HALF_MV(1, 1, mx , my-1) CHECK_HALF_MV(1, 0, mx-1, my ) CHECK_HALF_MV(1, 0, mx , my ) CHECK_HALF_MV(1, 1, mx-1, my ) - CHECK_HALF_MV(0, 1, mx , my ) + CHECK_HALF_MV(0, 1, mx , my ) CHECK_HALF_MV(1, 1, mx , my ) assert(bx >= xmin*2 || bx <= xmax*2 || by >= ymin*2 || by <= ymax*2); @@ -113,54 +114,55 @@ static int hpel_motion_search)(MpegEncContext * s, #else static int hpel_motion_search(MpegEncContext * s, - int *mx_ptr, int *my_ptr, int dmin, + int *mx_ptr, int *my_ptr, int dmin, int src_index, int ref_index, int size, int h) { + MotionEstContext * const c= &s->me; const int mx = *mx_ptr; - const int my = *my_ptr; - const int penalty_factor= s->me.sub_penalty_factor; + const int my = *my_ptr; + const int penalty_factor= c->sub_penalty_factor; me_cmp_func cmp_sub, chroma_cmp_sub; int bx=2*mx, by=2*my; LOAD_COMMON - int flags= s->me.sub_flags; - + int flags= c->sub_flags; + //FIXME factorize cmp_sub= s->dsp.me_sub_cmp[size]; chroma_cmp_sub= s->dsp.me_sub_cmp[size+1]; - if(s->me.skip){ //FIXME move out of hpel? + if(c->skip){ //FIXME move out of hpel? *mx_ptr = 0; *my_ptr = 0; return dmin; } - - if(s->avctx->me_cmp != s->avctx->me_sub_cmp){ + + if(c->avctx->me_cmp != c->avctx->me_sub_cmp){ dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags); if(mx || my || size>0) dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor; } - - if (mx > xmin && mx < xmax && + + if (mx > xmin && mx < xmax && my > ymin && my < ymax) { int d= dmin; const int index= (my<me.penalty_factor; + const int t= score_map[(index-(1<penalty_factor; const int l= score_map[(index- 1 )&(ME_MAP_SIZE-1)] - + (mv_penalty[bx-2 - pred_x] + mv_penalty[by - pred_y])*s->me.penalty_factor; + + (mv_penalty[bx-2 - pred_x] + mv_penalty[by - pred_y])*c->penalty_factor; const int r= score_map[(index+ 1 )&(ME_MAP_SIZE-1)] - + (mv_penalty[bx+2 - pred_x] + mv_penalty[by - pred_y])*s->me.penalty_factor; + + (mv_penalty[bx+2 - pred_x] + mv_penalty[by - pred_y])*c->penalty_factor; const int b= score_map[(index+(1<me.penalty_factor; - + + (mv_penalty[bx - pred_x] + mv_penalty[by+2 - pred_y])*c->penalty_factor; + #if 1 int key; - int map_generation= s->me.map_generation; + int map_generation= c->map_generation; #ifndef NDEBUG - uint32_t *map= s->me.map; + uint32_t *map= c->map; #endif key= ((my-1)<dsp.me_sub_cmp != s->dsp.mb_cmp; - const int size= 0; - const int h= 16; - const int penalty_factor= s->me.mb_penalty_factor; - const int flags= s->me.mb_flags; + MotionEstContext * const c= &s->me; + const int penalty_factor= c->mb_penalty_factor; + const int flags= c->mb_flags; const int qpel= flags & FLAG_QPEL; const int mask= 1+2*qpel; me_cmp_func cmp_sub, chroma_cmp_sub; int d; LOAD_COMMON - + //FIXME factorize cmp_sub= s->dsp.mb_cmp[size]; chroma_cmp_sub= s->dsp.mb_cmp[size+1]; - - assert(!s->me.skip); - assert(s->avctx->me_sub_cmp != s->avctx->mb_cmp); + +// assert(!c->skip); +// assert(c->avctx->me_sub_cmp != c->avctx->mb_cmp); 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); //FIXME check cbp before adding penalty for (0,0) vector - if(mx || my || size>0) + if(add_rate && (mx || my || size>0)) d += (mv_penalty[mx - pred_x] + mv_penalty[my - pred_y])*penalty_factor; - + return d; } @@ -255,28 +266,29 @@ static int inline get_mb_score(MpegEncContext * s, int mx, int my, int src_index {\ const int hx= 4*(x)+(dx);\ const int hy= 4*(y)+(dy);\ - d= cmp(s, x, y, dx, dy, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\ + d= cmp_qpel(s, x, y, dx, dy, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\ d += (mv_penalty[hx - pred_x] + mv_penalty[hy - pred_y])*penalty_factor;\ COPY3_IF_LT(dmin, d, bx, hx, by, hy)\ } static int qpel_motion_search(MpegEncContext * s, - int *mx_ptr, int *my_ptr, int dmin, - int src_index, int ref_index, + int *mx_ptr, int *my_ptr, int dmin, + int src_index, int ref_index, int size, int h) { + MotionEstContext * const c= &s->me; const int mx = *mx_ptr; - const int my = *my_ptr; - const int penalty_factor= s->me.sub_penalty_factor; - const int map_generation= s->me.map_generation; - const int subpel_quality= s->avctx->me_subpel_quality; - uint32_t *map= s->me.map; + const int my = *my_ptr; + const int penalty_factor= c->sub_penalty_factor; + const int map_generation= c->map_generation; + const int subpel_quality= c->avctx->me_subpel_quality; + uint32_t *map= c->map; me_cmp_func cmpf, chroma_cmpf; me_cmp_func cmp_sub, chroma_cmp_sub; LOAD_COMMON - int flags= s->me.sub_flags; - + int flags= c->sub_flags; + cmpf= s->dsp.me_cmp[size]; chroma_cmpf= s->dsp.me_cmp[size+1]; //factorize FIXME //FIXME factorize @@ -284,19 +296,19 @@ static int qpel_motion_search(MpegEncContext * s, cmp_sub= s->dsp.me_sub_cmp[size]; chroma_cmp_sub= s->dsp.me_sub_cmp[size+1]; - if(s->me.skip){ //FIXME somehow move up (benchmark) + if(c->skip){ //FIXME somehow move up (benchmark) *mx_ptr = 0; *my_ptr = 0; return dmin; } - - if(s->avctx->me_cmp != s->avctx->me_sub_cmp){ + + if(c->avctx->me_cmp != c->avctx->me_sub_cmp){ dmin= cmp(s, mx, my, 0, 0, size, h, ref_index, src_index, cmp_sub, chroma_cmp_sub, flags); if(mx || my || size>0) dmin += (mv_penalty[4*mx - pred_x] + mv_penalty[4*my - pred_y])*penalty_factor; } - - if (mx > xmin && mx < xmax && + + if (mx > xmin && mx < xmax && my > ymin && my < ymax) { int bx=4*mx, by=4*my; int d= dmin; @@ -309,10 +321,10 @@ static int qpel_motion_search(MpegEncContext * s, const int c= score_map[(index )&(ME_MAP_SIZE-1)]; int best[8]; int best_pos[8][2]; - + memset(best, 64, sizeof(int)*8); #if 1 - if(s->me.dia_size>=2){ + if(s->me.dia_size>=2){ const int tl= score_map[(index-(1<>10; int i; - + if((nx&3)==0 && (ny&3)==0) continue; - - score += 1024*(mv_penalty[4*mx + nx - pred_x] + mv_penalty[4*my + ny - pred_y])*penalty_factor; - -// if(nx&1) score-=1024*s->me.penalty_factor; -// if(ny&1) score-=1024*s->me.penalty_factor; - + + score += (mv_penalty[4*mx + nx - pred_x] + mv_penalty[4*my + ny - pred_y])*penalty_factor; + +// if(nx&1) score-=1024*c->penalty_factor; +// if(ny&1) score-=1024*c->penalty_factor; + for(i=0; i<8; i++){ if(score < best[i]){ memmove(&best[i+1], &best[i], sizeof(int)*(7-i)); @@ -347,37 +360,39 @@ static int qpel_motion_search(MpegEncContext * s, } }else{ int tl; + //FIXME this could overflow (unlikely though) const int cx = 4*(r - l); - const int cx2= r + l - 2*c; + const int cx2= r + l - 2*c; const int cy = 4*(b - t); const int cy2= b + t - 2*c; int cxy; - + if(map[(index-(1<me.penalty_factor; - // if(ny&1) score-=32*s->me.penalty_factor; - +// if(nx&1) score-=32*c->penalty_factor; + // if(ny&1) score-=32*c->penalty_factor; + for(i=0; i<8; i++){ if(score < best[i]){ memmove(&best[i+1], &best[i], sizeof(int)*(7-i)); @@ -389,7 +404,7 @@ static int qpel_motion_search(MpegEncContext * s, } } } - } + } } for(i=0; i= xmin);\ + assert((x) <= xmax);\ + assert((y) >= ymin);\ + assert((y) <= ymax);\ /*printf("check_mv %d %d\n", x, y);*/\ if(map[index]!=key){\ d= cmp(s, x, y, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags);\ @@ -495,13 +514,13 @@ static int qpel_motion_search(MpegEncContext * s, }\ } -#define CHECK_CLIPED_MV(ax,ay)\ +#define CHECK_CLIPPED_MV(ax,ay)\ {\ - const int x= ax;\ - const int y= ay;\ - const int x2= FFMAX(xmin, FFMIN(x, xmax));\ - const int y2= FFMAX(ymin, FFMIN(y, ymax));\ - CHECK_MV(x2, y2)\ + const int Lx= ax;\ + const int Ly= ay;\ + const int Lx2= FFMAX(xmin, FFMIN(Lx, xmax));\ + const int Ly2= FFMAX(ymin, FFMIN(Ly, ymax));\ + CHECK_MV(Lx2, Ly2)\ } #define CHECK_MV_DIR(x,y,new_dir)\ @@ -531,20 +550,21 @@ if( (y)<(ymin<<(S)) ) printf("%d %d %d %d %d ymin" #v, ymin, (x), (y), s->mb_x, if( (y)>(ymax<<(S)) ) printf("%d %d %d %d %d ymax" #v, ymax, (x), (y), s->mb_x, s->mb_y);\ #define LOAD_COMMON2\ - uint32_t *map= s->me.map;\ + uint32_t *map= c->map;\ const int qpel= flags&FLAG_QPEL;\ const int shift= 1+qpel;\ -static always_inline int small_diamond_search(MpegEncContext * s, int *best, int dmin, +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) { + MotionEstContext * const c= &s->me; me_cmp_func cmpf, chroma_cmpf; int next_dir=-1; LOAD_COMMON LOAD_COMMON2 - int map_generation= s->me.map_generation; - + int map_generation= c->map_generation; + cmpf= s->dsp.me_cmp[size]; chroma_cmpf= s->dsp.me_cmp[size+1]; @@ -580,12 +600,13 @@ 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) { + MotionEstContext * const c= &s->me; me_cmp_func cmpf, chroma_cmpf; int dia_size; LOAD_COMMON LOAD_COMMON2 - int map_generation= s->me.map_generation; - + int map_generation= c->map_generation; + cmpf= s->dsp.me_cmp[size]; chroma_cmpf= s->dsp.me_cmp[size+1]; @@ -593,7 +614,7 @@ static int funny_diamond_search(MpegEncContext * s, int *best, int dmin, int dir; const int x= best[0]; const int y= best[1]; - + if(dia_size&(dia_size-1)) continue; if( x + dia_size > xmax @@ -601,7 +622,7 @@ static int funny_diamond_search(MpegEncContext * s, int *best, int dmin, || y + dia_size > ymax || y - dia_size < ymin) continue; - + for(dir= 0; dirdx){ dx^=dy; dy^=dx; dx^=dy; } @@ -633,7 +654,161 @@ if(256*256*256*64 % (stats[0]+1)==0){ } #endif } - return dmin; + return dmin; +} + +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) +{ + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; + LOAD_COMMON + LOAD_COMMON2 + int map_generation= c->map_generation; + int x,y,d; + const int dec= dia_size & (dia_size-1); + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + for(;dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){ + do{ + x= best[0]; + y= best[1]; + + CHECK_CLIPPED_MV(x -dia_size , y); + CHECK_CLIPPED_MV(x+ dia_size , y); + CHECK_CLIPPED_MV(x+( dia_size>>1), y+dia_size); + CHECK_CLIPPED_MV(x+( dia_size>>1), y-dia_size); + if(dia_size>1){ + CHECK_CLIPPED_MV(x+(-dia_size>>1), y+dia_size); + CHECK_CLIPPED_MV(x+(-dia_size>>1), y-dia_size); + } + }while(best[0] != x || best[1] != y); + } + + return dmin; +} + +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) +{ + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; + LOAD_COMMON + LOAD_COMMON2 + int map_generation= c->map_generation; + int x,y,i,d; + int dia_size= c->dia_size&0xFF; + const int dec= dia_size & (dia_size-1); + static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1}, + { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}}; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + for(; dia_size; dia_size= dec ? dia_size-1 : dia_size>>1){ + do{ + x= best[0]; + y= best[1]; + for(i=0; i<8; i++){ + CHECK_CLIPPED_MV(x+hex[i][0]*dia_size, y+hex[i][1]*dia_size); + } + }while(best[0] != x || best[1] != y); + } + + x= best[0]; + y= best[1]; + CHECK_CLIPPED_MV(x+1, y); + CHECK_CLIPPED_MV(x, y+1); + CHECK_CLIPPED_MV(x-1, y); + CHECK_CLIPPED_MV(x, y-1); + + return dmin; +} + +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) +{ + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; + LOAD_COMMON + LOAD_COMMON2 + int map_generation= c->map_generation; + int x,y,x2,y2, i, j, d; + const int dia_size= c->dia_size&0xFE; + static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2}, + { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2}, + {-2, 3}, { 0, 4}, { 2, 3}, + {-2,-3}, { 0,-4}, { 2,-3},}; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + x= best[0]; + y= best[1]; + for(x2=FFMAX(x-dia_size+1, xmin); x2<=FFMIN(x+dia_size-1,xmax); x2+=2){ + CHECK_MV(x2, y); + } + for(y2=FFMAX(y-dia_size/2+1, ymin); y2<=FFMIN(y+dia_size/2-1,ymax); y2+=2){ + CHECK_MV(x, y2); + } + + x= best[0]; + y= best[1]; + for(y2=FFMAX(y-2, ymin); y2<=FFMIN(y+2,ymax); y2++){ + for(x2=FFMAX(x-2, xmin); x2<=FFMIN(x+2,xmax); x2++){ + CHECK_MV(x2, y2); + } + } + +//FIXME prevent the CLIP stuff + + for(j=1; j<=dia_size/4; j++){ + for(i=0; i<16; i++){ + CHECK_CLIPPED_MV(x+hex[i][0]*j, y+hex[i][1]*j); + } + } + + return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2); +} + +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) +{ + MotionEstContext * const c= &s->me; + me_cmp_func cmpf, chroma_cmpf; + LOAD_COMMON + LOAD_COMMON2 + int map_generation= c->map_generation; + int x,y, d; + const int dia_size= c->dia_size&0xFF; + + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + + for(y=FFMAX(-dia_size, ymin); y<=FFMIN(dia_size,ymax); y++){ + for(x=FFMAX(-dia_size, xmin); x<=FFMIN(dia_size,xmax); x++){ + CHECK_MV(x, y); + } + } + + x= best[0]; + y= best[1]; + d= dmin; + CHECK_CLIPPED_MV(x , y); + CHECK_CLIPPED_MV(x+1, y); + CHECK_CLIPPED_MV(x, y+1); + CHECK_CLIPPED_MV(x-1, y); + CHECK_CLIPPED_MV(x, y-1); + best[0]= x; + best[1]= y; + + return d; } #define SAB_CHECK_MV(ax,ay)\ @@ -665,58 +840,66 @@ if(256*256*256*64 % (stats[0]+1)==0){ }\ } -#define MAX_SAB_SIZE 16 +#define MAX_SAB_SIZE ME_MAP_SIZE 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) { + MotionEstContext * const c= &s->me; me_cmp_func cmpf, chroma_cmpf; Minima minima[MAX_SAB_SIZE]; - const int minima_count= ABS(s->me.dia_size); + const int minima_count= FFABS(c->dia_size); int i, j; LOAD_COMMON LOAD_COMMON2 - int map_generation= s->me.map_generation; - + int map_generation= c->map_generation; + cmpf= s->dsp.me_cmp[size]; chroma_cmpf= s->dsp.me_cmp[size+1]; - - for(j=i=0; i>=ME_MAP_MV_BITS; minima[j].y= key & ((1< xmax || minima[j].x < xmin + || minima[j].y > ymax || minima[j].y < ymin) + continue; + minima[j].checked=0; if(minima[j].x || minima[j].y) minima[j].height+= (mv_penalty[((minima[j].x)<= xmax || x <= xmin || y >= ymax || y <= ymin) continue; @@ -725,14 +908,14 @@ static int sab_diamond_search(MpegEncContext * s, int *best, int dmin, SAB_CHECK_MV(x+1, y) SAB_CHECK_MV(x , y-1) SAB_CHECK_MV(x , y+1) - + minima[i].checked= 1; } - + best[0]= minima[0].x; best[1]= minima[0].y; dmin= minima[0].height; - + if( best[0] < xmax && best[0] > xmin && best[1] < ymax && best[1] > ymin){ int d; @@ -742,23 +925,24 @@ static int sab_diamond_search(MpegEncContext * s, int *best, int dmin, CHECK_MV(best[0], best[1]-1) CHECK_MV(best[0], best[1]+1) } - return dmin; + return dmin; } 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) { + MotionEstContext * const c= &s->me; me_cmp_func cmpf, chroma_cmpf; int dia_size; LOAD_COMMON LOAD_COMMON2 - int map_generation= s->me.map_generation; - + int map_generation= c->map_generation; + cmpf= s->dsp.me_cmp[size]; chroma_cmpf= s->dsp.me_cmp[size+1]; - for(dia_size=1; dia_size<=s->me.dia_size; dia_size++){ + for(dia_size=1; dia_size<=c->dia_size; dia_size++){ int dir, start, end; const int x= best[0]; const int y= best[1]; @@ -805,8 +989,8 @@ static int var_diamond_search(MpegEncContext * s, int *best, int dmin, { int dx, dy, i; static int stats[8*8]; -dx= ABS(x-best[0]); -dy= ABS(y-best[1]); +dx= FFABS(x-best[0]); +dy= FFABS(y-best[1]); stats[dy*8 + dx] ++; if(256*256*256*64 % (stats[0]+1)==0){ for(i=0; i<64; i++){ @@ -818,89 +1002,123 @@ if(256*256*256*64 % (stats[0]+1)==0){ } #endif } - return dmin; + return dmin; } -static always_inline int diamond_search(MpegEncContext * s, int *best, int dmin, +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){ - if(s->me.dia_size==-1) + MotionEstContext * const c= &s->me; + if(c->dia_size==-1) return funny_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); - else if(s->me.dia_size<-1) + else if(c->dia_size<-1) return sab_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); - else if(s->me.dia_size<2) + else if(c->dia_size<2) return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + else if(c->dia_size>1024) + return full_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + else if(c->dia_size>768) + return umh_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); + else if(c->dia_size>512) + return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, c->dia_size&0xFF); + else if(c->dia_size>256) + return l2s_dia_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); else return var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); } -static 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) +/*! + \param P[10][2] a list of candidate mvs to check before starting the + iterative search. If one of the candidates is close to the optimal mv, then + it takes fewer iterations. And it increases the chance that we find the + optimal mv. + */ +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) { - int best[2]={0, 0}; - int d, dmin; + MotionEstContext * const c= &s->me; + int best[2]={0, 0}; /*!< x and y coordinates of the best motion vector. + i.e. the difference between the position of the + block currently being encoded and the position of + the block chosen to predict it from. */ + int d; ///< the score (cmp + penalty) of any given mv + int dmin; /*!< the best value of d, i.e. the score + corresponding to the mv stored in best[]. */ int map_generation; - const int penalty_factor= s->me.penalty_factor; - const int size=0; - const int h=16; + int penalty_factor; const int ref_mv_stride= s->mb_stride; //pass as arg FIXME const int ref_mv_xy= s->mb_x + s->mb_y*ref_mv_stride; //add to last_mv beforepassing FIXME me_cmp_func cmpf, chroma_cmpf; - + LOAD_COMMON LOAD_COMMON2 - - cmpf= s->dsp.me_cmp[size]; - chroma_cmpf= s->dsp.me_cmp[size+1]; - - map_generation= update_map_generation(s); + if(c->pre_pass){ + penalty_factor= c->pre_penalty_factor; + cmpf= s->dsp.me_pre_cmp[size]; + chroma_cmpf= s->dsp.me_pre_cmp[size+1]; + }else{ + penalty_factor= c->penalty_factor; + cmpf= s->dsp.me_cmp[size]; + chroma_cmpf= s->dsp.me_cmp[size+1]; + } + + map_generation= update_map_generation(c); + + assert(cmpf); dmin= cmp(s, 0, 0, 0, 0, size, h, ref_index, src_index, cmpf, chroma_cmpf, flags); map[0]= map_generation; score_map[0]= dmin; + //FIXME precalc first term below? + if((s->pict_type == FF_B_TYPE && !(c->flags & FLAG_DIRECT)) || s->flags&CODEC_FLAG_MV0) + dmin += (mv_penalty[pred_x] + mv_penalty[pred_y])*penalty_factor; + /* first line */ if (s->first_slice_line) { CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) - CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) }else{ - if(dmin<256 && ( P_LEFT[0] |P_LEFT[1] + if(dmin<((h*h*s->avctx->mv0_threshold)>>8) + && ( P_LEFT[0] |P_LEFT[1] |P_TOP[0] |P_TOP[1] |P_TOPRIGHT[0]|P_TOPRIGHT[1])==0){ *mx_ptr= 0; *my_ptr= 0; - s->me.skip=1; + c->skip=1; return dmin; } - CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift) - if(dmin>256*2){ - CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, - (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) - CHECK_MV(P_LEFT[0] >>shift, P_LEFT[1] >>shift) - CHECK_MV(P_TOP[0] >>shift, P_TOP[1] >>shift) - CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) - } + CHECK_MV( P_MEDIAN[0] >>shift , P_MEDIAN[1] >>shift) + CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift) , (P_MEDIAN[1]>>shift)-1) + CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift) , (P_MEDIAN[1]>>shift)+1) + CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)-1, (P_MEDIAN[1]>>shift) ) + CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)+1, (P_MEDIAN[1]>>shift) ) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) + CHECK_MV(P_LEFT[0] >>shift, P_LEFT[1] >>shift) + CHECK_MV(P_TOP[0] >>shift, P_TOP[1] >>shift) + CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) } - if(dmin>256*4){ - if(s->me.pre_pass){ - CHECK_CLIPED_MV((last_mv[ref_mv_xy-1][0]*ref_mv_scale + (1<<15))>>16, + if(dmin>h*h*4){ + if(c->pre_pass){ + CHECK_CLIPPED_MV((last_mv[ref_mv_xy-1][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy-1][1]*ref_mv_scale + (1<<15))>>16) if(!s->first_slice_line) - CHECK_CLIPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, + CHECK_CLIPPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy-ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16) }else{ - CHECK_CLIPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16, + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16) if(s->mb_y+1end_mb_y) //FIXME replace at least with last_slice_line - CHECK_CLIPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16) } } - if(s->avctx->last_predictor_count){ - const int count= s->avctx->last_predictor_count; + if(c->avctx->last_predictor_count){ + const int count= c->avctx->last_predictor_count; const int xstart= FFMAX(0, s->mb_x - count); const int ystart= FFMAX(0, s->mb_y - count); const int xend= FFMIN(s->mb_width , s->mb_x + count + 1); @@ -925,83 +1143,82 @@ static always_inline int epzs_motion_search_internal(MpegEncContext * s, int *mx //check(best[0],best[1],0, b1) *mx_ptr= best[0]; - *my_ptr= best[1]; + *my_ptr= best[1]; // printf("%d %d %d \n", best[0], best[1], dmin); return dmin; } //this function is dedicated to the braindamaged gcc -static inline int 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) +inline 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) { + MotionEstContext * const c= &s->me; //FIXME convert other functions in the same way if faster - switch(s->me.flags){ - case 0: - return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, 0); + if(c->flags==0 && h==16 && size==0){ + return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, 0, 0, 16); // case FLAG_QPEL: // return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, FLAG_QPEL); - default: - return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, s->me.flags); + }else{ + return epzs_motion_search_internal(s, mx_ptr, my_ptr, P, src_index, ref_index, last_mv, ref_mv_scale, c->flags, size, h); } } 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 src_index, int ref_index, int16_t (*last_mv)[2], int ref_mv_scale) { + MotionEstContext * const c= &s->me; int best[2]={0, 0}; - int d, dmin; + int d, dmin; int map_generation; - const int penalty_factor= s->me.penalty_factor; + const int penalty_factor= c->penalty_factor; const int size=1; const int h=8; const int ref_mv_stride= s->mb_stride; const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride; me_cmp_func cmpf, chroma_cmpf; LOAD_COMMON - int flags= s->me.flags; + int flags= c->flags; LOAD_COMMON2 - + cmpf= s->dsp.me_cmp[size]; chroma_cmpf= s->dsp.me_cmp[size+1]; - map_generation= update_map_generation(s); + map_generation= update_map_generation(c); dmin = 1000000; -//printf("%d %d %d %d //",xmin, ymin, xmax, ymax); +//printf("%d %d %d %d //",xmin, ymin, xmax, ymax); /* first line */ if (s->first_slice_line) { - CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) - CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift) }else{ CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift) //FIXME try some early stop - if(dmin>64*2){ - CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift) - CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) - CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift) - CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) - CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, - (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) - } + CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift) + CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) + CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift) + CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) } if(dmin>64*4){ - CHECK_CLIPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16, + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16) if(s->mb_y+1end_mb_y) //FIXME replace at least with last_slice_line - CHECK_CLIPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16) } dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); *mx_ptr= best[0]; - *my_ptr= best[1]; + *my_ptr= best[1]; // printf("%d %d %d \n", best[0], best[1], dmin); return dmin; @@ -1010,59 +1227,58 @@ static int epzs_motion_search4(MpegEncContext * s, //try to merge with above FIXME (needs PSNR test) 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 src_index, int ref_index, int16_t (*last_mv)[2], int ref_mv_scale) { + MotionEstContext * const c= &s->me; int best[2]={0, 0}; - int d, dmin; + int d, dmin; int map_generation; - const int penalty_factor= s->me.penalty_factor; + const int penalty_factor= c->penalty_factor; const int size=0; //FIXME pass as arg const int h=8; const int ref_mv_stride= s->mb_stride; const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride; me_cmp_func cmpf, chroma_cmpf; LOAD_COMMON - int flags= s->me.flags; + int flags= c->flags; LOAD_COMMON2 - + cmpf= s->dsp.me_cmp[size]; chroma_cmpf= s->dsp.me_cmp[size+1]; - map_generation= update_map_generation(s); + map_generation= update_map_generation(c); dmin = 1000000; -//printf("%d %d %d %d //",xmin, ymin, xmax, ymax); +//printf("%d %d %d %d //",xmin, ymin, xmax, ymax); /* first line */ if (s->first_slice_line) { - CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) - CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift) }else{ CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift) //FIXME try some early stop - if(dmin>64*2){ - CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift) - CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) - CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift) - CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) - CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, - (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) - } + CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift) + CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift) + CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift) + CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift) + CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16, + (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16) } if(dmin>64*4){ - CHECK_CLIPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16, + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16) if(s->mb_y+1end_mb_y) //FIXME replace at least with last_slice_line - CHECK_CLIPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, + CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16, (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16) } dmin= diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags); *mx_ptr= best[0]; - *my_ptr= best[1]; + *my_ptr= best[1]; // printf("%d %d %d \n", best[0], best[1], dmin); return dmin;