43 #define P_TOPRIGHT P[3] 47 #define ME_MAP_SHIFT 3 48 #define ME_MAP_MV_BITS 11 51 int *mx_ptr,
int *my_ptr,
int dmin,
52 int src_index,
int ref_index,
79 #define FLAG_QPEL 1 //must be 1 91 c->
src[0][
i]= src [
i] + offset[
i];
92 c->
ref[0][
i]= ref [
i] + offset[
i];
96 c->
ref[ref_index][
i]= ref2[
i] + offset[
i];
108 const int size,
const int h,
int ref_index,
int src_index,
112 const int hx= subx + (x<<(1+qpel));
113 const int hy= suby + (y<<(1+qpel));
118 av_assert2(x >= c->
xmin && hx <= c->xmax<<(qpel+1) && y >= c->
ymin && hy <= c->ymax<<(qpel+1));
119 if(x >= c->
xmin && hx <= c->xmax<<(qpel+1) && y >= c->
ymin && hy <= c->ymax<<(qpel+1)){
122 const int mask= 2*qpel+1;
130 int fxy= (fx&
mask) + ((fy&mask)<<(qpel+1));
131 int bxy= (bx&
mask) + ((by&mask)<<(qpel+1));
147 int fxy= (fx&
mask) + ((fy&mask)<<(qpel+1));
148 int bxy= (bx&
mask) + ((by&mask)<<(qpel+1));
180 const int size,
const int h,
int ref_index,
int src_index,
185 const int dxy= subx + (suby<<(1+qpel));
186 const int hx= subx + x*(1<<(1+qpel));
187 const int hy= suby + y*(1<<(1+qpel));
195 if (h << size == 16) {
197 }
else if (size == 0 && h == 8) {
207 uvdxy= (cx&1) + 2*(cy&1);
213 uvdxy= dxy | (x&1) | (2*(y&1));
217 d =
cmp_func(s, src[0], ref[0] + x + y*stride, stride, h);
219 uvdxy= (x&1) + 2*(y&1);
223 c->
hpel_put[size+1][uvdxy](uvtemp , ref[1] + (x>>1) + (y>>1)*uvstride, uvstride, h>>1);
224 c->
hpel_put[size+1][uvdxy](uvtemp+8, ref[2] + (x>>1) + (y>>1)*uvstride, uvstride, h>>1);
225 d += chroma_cmp_func(s, uvtemp , src[1], uvstride, h>>1);
226 d += chroma_cmp_func(s, uvtemp+8, src[2], uvstride, h>>1);
232 int ref_index,
int src_index,
234 return cmp_inline(s,x,y,0,0,0,16,ref_index,src_index, cmp_func, chroma_cmp_func, 0, 0);
238 const int size,
const int h,
int ref_index,
int src_index,
241 return cmp_direct_inline(s,x,y,0,0,size,h,ref_index,src_index, cmp_func, chroma_cmp_func, flags&
FLAG_QPEL);
243 return cmp_inline(s,x,y,0,0,size,h,ref_index,src_index, cmp_func, chroma_cmp_func, 0, flags&
FLAG_CHROMA);
248 const int size,
const int h,
int ref_index,
int src_index,
251 return cmp_direct_inline(s,x,y,subx,suby,size,h,ref_index,src_index, cmp_func, chroma_cmp_func, flags&
FLAG_QPEL);
253 return cmp_inline(s,x,y,subx,suby,size,h,ref_index,src_index, cmp_func, chroma_cmp_func, flags&
FLAG_QPEL, flags&
FLAG_CHROMA);
261 const int size,
const int h,
int ref_index,
int src_index,
265 && flags==0 && h==16 && size==0 && subx==0 && suby==0){
266 return cmp_simple(s,x,y,ref_index,src_index, cmp_func, chroma_cmp_func);
268 && subx==0 && suby==0){
269 return cmp_fpel_internal(s,x,y,size,h,ref_index,src_index, cmp_func, chroma_cmp_func,flags);
271 return cmp_internal(s,x,y,subx,suby,size,h,ref_index,src_index, cmp_func, chroma_cmp_func, flags);
276 const int size,
const int h,
int ref_index,
int src_index,
279 return cmp_direct_inline(s,x,y,subx,suby,size,h,ref_index,src_index, cmp_func, chroma_cmp_func, 0);
281 return cmp_inline(s,x,y,subx,suby,size,h,ref_index,src_index, cmp_func, chroma_cmp_func, 0, flags&
FLAG_CHROMA);
286 const int size,
const int h,
int ref_index,
int src_index,
289 return cmp_direct_inline(s,x,y,subx,suby,size,h,ref_index,src_index, cmp_func, chroma_cmp_func, 1);
291 return cmp_inline(s,x,y,subx,suby,size,h,ref_index,src_index, cmp_func, chroma_cmp_func, 1, flags&
FLAG_CHROMA);
321 if(cache_size < 2*dia_size && !c->
stride){
385 #define CHECK_SAD_HALF_MV(suffix, x, y) \ 387 d = s->mecc.pix_abs[size][(x ? 1 : 0) + (y ? 2 : 0)](NULL, pix, ptr + ((x) >> 1), stride, h); \ 388 d += (mv_penalty[pen_x + x] + mv_penalty[pen_y + y])*penalty_factor;\ 389 COPY3_IF_LT(dminh, d, dx, x, dy, y)\ 393 int *mx_ptr,
int *my_ptr,
int dmin,
394 int src_index,
int ref_index,
412 pix = c->
src[src_index][0];
416 ptr = c->
ref[ref_index][0] + (my *
stride) + mx;
420 if (mx > xmin && mx < xmax &&
421 my > ymin && my < ymax) {
426 const int l= score_map[(index- 1 )&(
ME_MAP_SIZE-1)];
540 c->
xmin = (x > 15) ? - 15 : 0;
541 c->
ymin = (y > 15) ? - 15 : 0;
550 if(!range || range > max_range)
563 c->
ref[1][0] = c->
ref[0][0] + 8;
565 c->
ref[3][0] = c->
ref[2][0] + 8;
566 c->
src[1][0] = c->
src[0][0] + 8;
568 c->
src[3][0] = c->
src[2][0] + 8;
578 int dmin_sum=0, mx4_sum=0, my4_sum=0,
i;
586 for(block=0; block<4; block++){
588 int pred_x4, pred_y4;
590 static const int off[4]= {2, 1, 1, -1};
633 if(P[
i][1] > (c->
ymax<<shift)) P[
i][1]= (c->
ymax<<shift);
646 dxy = ((my4 & 3) << 2) | (mx4 & 3);
654 dxy = ((my4 & 1) << 1) | (mx4 & 1);
661 dmin_sum+= (mv_penalty[mx4-pred_x4] + mv_penalty[my4-pred_y4])*c->
mb_penalty_factor;
676 if(mx4 != mx || my4 != my) same=0;
696 dxy = ((my & 1) << 1) | (mx & 1);
739 int16_t (*mv_tables[2][2])[2],
uint8_t *field_select_tables[2],
int mx,
int my,
int user_field_select)
751 const int xy= s->
mb_x + s->
mb_y*mot_stride;
759 for(block=0; block<2; block++){
761 int best_dmin= INT_MAX;
764 for(field_select=0; field_select<2; field_select++){
765 int dmin, mx_i, my_i;
766 int16_t (*mv_table)[2]= mv_tables[
block][field_select];
768 if(user_field_select){
769 av_assert1(field_select==0 || field_select==1);
770 av_assert1(field_select_tables[block][xy]==0 || field_select_tables[block][xy]==1);
771 if(field_select_tables[block][xy] != field_select)
775 P_LEFT[0] = mv_table[xy - 1][0];
776 P_LEFT[1] = mv_table[xy - 1][1];
783 P_TOP[0] = mv_table[xy - mot_stride][0];
784 P_TOP[1] = mv_table[xy - mot_stride][1];
785 P_TOPRIGHT[0] = mv_table[xy - mot_stride + 1][0];
786 P_TOPRIGHT[1] = mv_table[xy - mot_stride + 1][1];
798 dmin =
epzs_motion_search2(s, &mx_i, &my_i, P, block, field_select+ref_index, mv_table, (1<<16)>>1, 0);
800 dmin= c->
sub_motion_search(s, &mx_i, &my_i, dmin, block, field_select+ref_index, size, h);
802 mv_table[xy][0]= mx_i;
803 mv_table[xy][1]= my_i;
810 dxy = ((my_i & 1) << 1) | (mx_i & 1);
822 dmin += field_select !=
block;
824 if(dmin < best_dmin){
826 best_field= field_select;
830 int16_t (*mv_table)[2]= mv_tables[
block][best_field];
832 if(mv_table[xy][0] != mx) same=0;
833 if(mv_table[xy][1]&1) same=0;
834 if(mv_table[xy][1]*2 != my) same=0;
835 if(best_field != block) same=0;
838 field_select_tables[
block][xy]= best_field;
839 dmin_sum += best_dmin;
866 return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
890 int sum, mx = 0, my = 0, dmin = 0;
916 (((unsigned) sum * sum) >> 8) + 500;
976 if (varc*2 + 200*256 > vard || s->
qscale > 24){
988 && !c->
skip && varc>50<<8 && vard>10<<8){
1009 && !c->
skip && varc>50<<8 && vard>10<<8){
1029 intra_score= varc - 500;
1031 unsigned mean = (sum+128)>>8;
1034 for(i=0; i<16; i++){
1045 if(intra_score < dmin){
1115 int16_t (*mv_table)[2],
int ref_index,
int f_code)
1118 int mx = 0, my = 0, dmin = 0;
1122 const int mot_xy = mb_y*mot_stride + mb_x;
1134 P_LEFT[0] = mv_table[mot_xy - 1][0];
1135 P_LEFT[1] = mv_table[mot_xy - 1][1];
1141 P_TOP[0] = mv_table[mot_xy - mot_stride ][0];
1142 P_TOP[1] = mv_table[mot_xy - mot_stride ][1];
1143 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1][0];
1144 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1][1];
1170 mv_table[mot_xy][0]= mx;
1171 mv_table[mot_xy][1]= my;
1177 int motion_fx,
int motion_fy,
1178 int motion_bx,
int motion_by,
1179 int pred_fx,
int pred_fy,
1180 int pred_bx,
int pred_by,
1200 dxy = ((motion_fy & 3) << 2) | (motion_fx & 3);
1201 src_x = motion_fx >> 2;
1202 src_y = motion_fy >> 2;
1204 ptr = ref_data[0] + (src_y *
stride) + src_x;
1207 dxy = ((motion_by & 3) << 2) | (motion_bx & 3);
1208 src_x = motion_bx >> 2;
1209 src_y = motion_by >> 2;
1211 ptr = ref2_data[0] + (src_y *
stride) + src_x;
1214 dxy = ((motion_fy & 1) << 1) | (motion_fx & 1);
1215 src_x = motion_fx >> 1;
1216 src_y = motion_fy >> 1;
1218 ptr = ref_data[0] + (src_y *
stride) + src_x;
1221 dxy = ((motion_by & 1) << 1) | (motion_bx & 1);
1222 src_x = motion_bx >> 1;
1223 src_y = motion_by >> 1;
1225 ptr = ref2_data[0] + (src_y *
stride) + src_x;
1229 fbmin = (mv_penalty_f[motion_fx-pred_fx] + mv_penalty_f[motion_fy-pred_fy])*c->
mb_penalty_factor 1230 +(mv_penalty_b[motion_bx-pred_bx] + mv_penalty_b[motion_by-pred_by])*c->
mb_penalty_factor 1245 const int xy = mb_y *mot_stride + mb_x;
1257 const int shift= 1+qpel;
1262 #define HASH(fx,fy,bx,by) ((fx)+17*(fy)+63*(bx)+117*(by)) 1263 #define HASH8(fx,fy,bx,by) ((uint8_t)HASH(fx,fy,bx,by)) 1264 int hashidx=
HASH(motion_fx,motion_fy, motion_bx, motion_by);
1267 map[hashidx&255] = 1;
1270 motion_bx, motion_by,
1277 static const uint8_t limittab[5]={0,8,32,64,80};
1279 static const int8_t vect[][4]={
1280 { 0, 0, 0, 1}, { 0, 0, 0,-1}, { 0, 0, 1, 0}, { 0, 0,-1, 0}, { 0, 1, 0, 0}, { 0,-1, 0, 0}, { 1, 0, 0, 0}, {-1, 0, 0, 0},
1282 { 0, 0, 1, 1}, { 0, 0,-1,-1}, { 0, 1, 1, 0}, { 0,-1,-1, 0}, { 1, 1, 0, 0}, {-1,-1, 0, 0}, { 1, 0, 0, 1}, {-1, 0, 0,-1},
1283 { 0, 1, 0, 1}, { 0,-1, 0,-1}, { 1, 0, 1, 0}, {-1, 0,-1, 0},
1284 { 0, 0,-1, 1}, { 0, 0, 1,-1}, { 0,-1, 1, 0}, { 0, 1,-1, 0}, {-1, 1, 0, 0}, { 1,-1, 0, 0}, { 1, 0, 0,-1}, {-1, 0, 0, 1},
1285 { 0,-1, 0, 1}, { 0, 1, 0,-1}, {-1, 0, 1, 0}, { 1, 0,-1, 0},
1287 { 0, 1, 1, 1}, { 0,-1,-1,-1}, { 1, 1, 1, 0}, {-1,-1,-1, 0}, { 1, 1, 0, 1}, {-1,-1, 0,-1}, { 1, 0, 1, 1}, {-1, 0,-1,-1},
1288 { 0,-1, 1, 1}, { 0, 1,-1,-1}, {-1, 1, 1, 0}, { 1,-1,-1, 0}, { 1, 1, 0,-1}, {-1,-1, 0, 1}, { 1, 0,-1, 1}, {-1, 0, 1,-1},
1289 { 0, 1,-1, 1}, { 0,-1, 1,-1}, { 1,-1, 1, 0}, {-1, 1,-1, 0}, {-1, 1, 0, 1}, { 1,-1, 0,-1}, { 1, 0, 1,-1}, {-1, 0,-1, 1},
1290 { 0, 1, 1,-1}, { 0,-1,-1, 1}, { 1, 1,-1, 0}, {-1,-1, 1, 0}, { 1,-1, 0, 1}, {-1, 1, 0,-1}, {-1, 0, 1, 1}, { 1, 0,-1,-1},
1292 { 1, 1, 1, 1}, {-1,-1,-1,-1},
1293 { 1, 1, 1,-1}, {-1,-1,-1, 1}, { 1, 1,-1, 1}, {-1,-1, 1,-1}, { 1,-1, 1, 1}, {-1, 1,-1,-1}, {-1, 1, 1, 1}, { 1,-1,-1,-1},
1294 { 1, 1,-1,-1}, {-1,-1, 1, 1}, { 1,-1,-1, 1}, {-1, 1, 1,-1}, { 1,-1, 1,-1}, {-1, 1,-1, 1},
1297 HASH8( 0, 0, 0, 1),
HASH8( 0, 0, 0,-1),
HASH8( 0, 0, 1, 0),
HASH8( 0, 0,-1, 0),
HASH8( 0, 1, 0, 0),
HASH8( 0,-1, 0, 0),
HASH8( 1, 0, 0, 0),
HASH8(-1, 0, 0, 0),
1299 HASH8( 0, 0, 1, 1),
HASH8( 0, 0,-1,-1),
HASH8( 0, 1, 1, 0),
HASH8( 0,-1,-1, 0),
HASH8( 1, 1, 0, 0),
HASH8(-1,-1, 0, 0),
HASH8( 1, 0, 0, 1),
HASH8(-1, 0, 0,-1),
1300 HASH8( 0, 1, 0, 1),
HASH8( 0,-1, 0,-1),
HASH8( 1, 0, 1, 0),
HASH8(-1, 0,-1, 0),
1301 HASH8( 0, 0,-1, 1),
HASH8( 0, 0, 1,-1),
HASH8( 0,-1, 1, 0),
HASH8( 0, 1,-1, 0),
HASH8(-1, 1, 0, 0),
HASH8( 1,-1, 0, 0),
HASH8( 1, 0, 0,-1),
HASH8(-1, 0, 0, 1),
1302 HASH8( 0,-1, 0, 1),
HASH8( 0, 1, 0,-1),
HASH8(-1, 0, 1, 0),
HASH8( 1, 0,-1, 0),
1304 HASH8( 0, 1, 1, 1),
HASH8( 0,-1,-1,-1),
HASH8( 1, 1, 1, 0),
HASH8(-1,-1,-1, 0),
HASH8( 1, 1, 0, 1),
HASH8(-1,-1, 0,-1),
HASH8( 1, 0, 1, 1),
HASH8(-1, 0,-1,-1),
1305 HASH8( 0,-1, 1, 1),
HASH8( 0, 1,-1,-1),
HASH8(-1, 1, 1, 0),
HASH8( 1,-1,-1, 0),
HASH8( 1, 1, 0,-1),
HASH8(-1,-1, 0, 1),
HASH8( 1, 0,-1, 1),
HASH8(-1, 0, 1,-1),
1306 HASH8( 0, 1,-1, 1),
HASH8( 0,-1, 1,-1),
HASH8( 1,-1, 1, 0),
HASH8(-1, 1,-1, 0),
HASH8(-1, 1, 0, 1),
HASH8( 1,-1, 0,-1),
HASH8( 1, 0, 1,-1),
HASH8(-1, 0,-1, 1),
1307 HASH8( 0, 1, 1,-1),
HASH8( 0,-1,-1, 1),
HASH8( 1, 1,-1, 0),
HASH8(-1,-1, 1, 0),
HASH8( 1,-1, 0, 1),
HASH8(-1, 1, 0,-1),
HASH8(-1, 0, 1, 1),
HASH8( 1, 0,-1,-1),
1310 HASH8( 1, 1, 1,-1),
HASH8(-1,-1,-1, 1),
HASH8( 1, 1,-1, 1),
HASH8(-1,-1, 1,-1),
HASH8( 1,-1, 1, 1),
HASH8(-1, 1,-1,-1),
HASH8(-1, 1, 1, 1),
HASH8( 1,-1,-1,-1),
1311 HASH8( 1, 1,-1,-1),
HASH8(-1,-1, 1, 1),
HASH8( 1,-1,-1, 1),
HASH8(-1, 1, 1,-1),
HASH8( 1,-1, 1,-1),
HASH8(-1, 1,-1, 1),
1314 #define CHECK_BIDIR(fx,fy,bx,by)\ 1315 if( !map[(hashidx+HASH(fx,fy,bx,by))&255]\ 1316 &&(fx<=0 || motion_fx+fx<=xmax) && (fy<=0 || motion_fy+fy<=ymax) && (bx<=0 || motion_bx+bx<=xmax) && (by<=0 || motion_by+by<=ymax)\ 1317 &&(fx>=0 || motion_fx+fx>=xmin) && (fy>=0 || motion_fy+fy>=ymin) && (bx>=0 || motion_bx+bx>=xmin) && (by>=0 || motion_by+by>=ymin)){\ 1319 map[(hashidx+HASH(fx,fy,bx,by))&255] = 1;\ 1320 score= check_bidir_mv(s, motion_fx+fx, motion_fy+fy, motion_bx+bx, motion_by+by, pred_fx, pred_fy, pred_bx, pred_by, 0, 16);\ 1322 hashidx += HASH(fx,fy,bx,by);\ 1331 #define CHECK_BIDIR2(a,b,c,d)\ 1332 CHECK_BIDIR(a,b,c,d)\ 1333 CHECK_BIDIR(-(a),-(b),-(c),-(d)) 1345 for(i=8; i<limit; i++){
1346 int fx= motion_fx+vect[
i][0];
1347 int fy= motion_fy+vect[
i][1];
1348 int bx= motion_bx+vect[
i][2];
1349 int by= motion_by+vect[
i][3];
1351 int a= (xmax -
FFMAX(fx,bx))|(
FFMIN(fx,bx) - xmin);
1352 int b= (ymax -
FFMAX(fy,by))|(
FFMIN(fy,by) - ymin);
1354 map[(hashidx+hash[i])&255] = 1;
1356 if(!map[(hashidx+hash[i])&255]){
1358 map[(hashidx+hash[
i])&255] = 1;
1359 score=
check_bidir_mv(s, fx, fy, bx, by, pred_fx, pred_fy, pred_bx, pred_by, 0, 16);
1372 borderdist=
FFMIN(a,b);
1393 const int mot_xy = mb_y*mot_stride + mb_x;
1396 const int time_pp= s->
pp_time;
1397 const int time_pb= s->
pb_time;
1398 int mx, my, xmin, xmax, ymin, ymax;
1402 ymin= xmin=(-32)>>shift;
1403 ymax= xmax= 31>>
shift;
1427 xmin=
FFMAX(xmin, - 16 - min);
1434 ymin=
FFMAX(ymin, - 16 - min);
1439 av_assert2(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16);
1441 if(xmax < 0 || xmin >0 || ymax < 0 || ymin > 0){
1445 return 256*256*256*64;
1457 P_LEFT[0] =
av_clip(mv_table[mot_xy - 1][0], xmin<<shift, xmax<<shift);
1458 P_LEFT[1] =
av_clip(mv_table[mot_xy - 1][1], ymin<<shift, ymax<<shift);
1462 P_TOP[0] =
av_clip(mv_table[mot_xy - mot_stride ][0], xmin<<shift, xmax<<shift);
1463 P_TOP[1] =
av_clip(mv_table[mot_xy - mot_stride ][1], ymin<<shift, ymax<<shift);
1464 P_TOPRIGHT[0] =
av_clip(mv_table[mot_xy - mot_stride + 1 ][0], xmin<<shift, xmax<<shift);
1465 P_TOPRIGHT[1] =
av_clip(mv_table[mot_xy - mot_stride + 1 ][1], ymin<<shift, ymax<<shift);
1482 mv_table[mot_xy][0]= mx;
1483 mv_table[mot_xy][1]= my;
1495 int fmin, bmin, dmin, fbmin, bimin, fimin;
1497 const int xy = mb_y*s->
mb_stride + mb_x;
1508 score= ((unsigned)(score*score + 128*256))>>16;
1532 ff_dlog(s,
"%d %d %d %d\n", dmin, fmin, bmin, fbmin);
1546 fimin= bimin= INT_MAX;
1573 score= ((unsigned)(score*score + 128*256))>>16;
1584 if(fimin < INT_MAX && bimin < INT_MAX){
1605 int best_score=-10000000;
1608 range=
FFMIN(range, 16);
1610 range=
FFMIN(range, 256);
1612 for(i=0; i<8; i++) score[i]= s->
mb_num*(8-i);
1619 int mx= mv_table[xy][0];
1620 int my= mv_table[xy][1];
1625 if(mx >= range || mx < -range ||
1626 my >= range || my < -range)
1629 for(j=0; j<fcode && j<8; j++){
1639 if(score[i] > best_score){
1640 best_score= score[
i];
1654 const int f_code= s->
f_code;
1660 av_assert0(range <= 16 || !s->msmpeg4_version);
1677 for(block=0; block<4; block++){
1678 int off= (block& 1) + (block>>1)*
wrap;
1682 if( mx >=range || mx <-range
1683 || my >=range || my <-range){
1684 s->
mb_type[
i] &= ~CANDIDATE_MB_TYPE_INTER4V;
1701 int16_t (*mv_table)[2],
int f_code,
int type,
int truncate)
1704 int y, h_range, v_range;
1712 v_range= field_select_table ? range>>1 : range;
1720 if (!field_select_table || field_select_table[xy] == field_select) {
1721 if( mv_table[xy][0] >=h_range || mv_table[xy][0] <-h_range
1722 || mv_table[xy][1] >=v_range || mv_table[xy][1] <-v_range){
1725 if (mv_table[xy][0] > h_range-1) mv_table[xy][0]= h_range-1;
1726 else if(mv_table[xy][0] < -h_range ) mv_table[xy][0]= -h_range;
1727 if (mv_table[xy][1] > v_range-1) mv_table[xy][1]= v_range-1;
1728 else if(mv_table[xy][1] < -v_range ) mv_table[xy][1]= -v_range;
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free.
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Table of number of bits a motion vector component needs.
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
static int minima_cmp(const void *a, const void *b)
static int cmp_qpel(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)
static unsigned update_map_generation(MotionEstContext *c)
void ff_estimate_b_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
qpel_mc_func avg_qpel_pixels_tab[2][16]
#define CANDIDATE_MB_TYPE_SKIPPED
static int shift(int a, int b)
static av_always_inline void mv_scale(Mv *dst, Mv *src, int td, int tb)
static int check_bidir_mv(MpegEncContext *s, int motion_fx, int motion_fy, int motion_bx, int motion_by, int pred_fx, int pred_fy, int pred_bx, int pred_by, int size, int h)
int skip
set if ME is skipped for the current MB
int16_t(* p_mv_table)[2]
MV table (1MV per MB) P-frame encoding.
static void get_limits(MpegEncContext *s, int x, int y)
get fullpel ME search limits.
void ff_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
uint8_t * mb_mean
Table for MB luminance.
op_pixels_func avg_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
static void init_mv4_ref(MotionEstContext *c)
qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16]
#define CANDIDATE_MB_TYPE_INTER_I
int ff_epzs_motion_search(struct 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)
uint16_t * mb_var
Table for MB variances.
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
int(* sub_motion_search)(struct MpegEncContext *s, int *mx_ptr, int *my_ptr, int dmin, int src_index, int ref_index, int size, int h)
#define CANDIDATE_MB_TYPE_BIDIR
static int cmp_simple(MpegEncContext *s, const int x, const int y, int ref_index, int src_index, me_cmp_func cmp_func, me_cmp_func chroma_cmp_func)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
int16_t(*[2][2] p_field_mv_table)[2]
MV table (2MV per MB) interlaced P-frame encoding.
static int bidir_refine(MpegEncContext *s, int mb_x, int mb_y)
int mpv_flags
flags set by private options
int mb_num
number of MBs of a picture
me_cmp_func me_pre_cmp[6]
int16_t(* b_back_mv_table)[2]
MV table (1MV per MB) backward mode B-frame encoding.
const uint8_t(* mv_penalty)[MAX_DMV *2+1]
bit amount needed to encode a MV
static int cmp_internal(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)
#define CANDIDATE_MB_TYPE_INTER
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static int zero_cmp(MpegEncContext *s, uint8_t *a, uint8_t *b, ptrdiff_t stride, int h)
op_pixels_func(* hpel_put)[4]
The exact code depends on how similar the blocks are and how related they are to the block
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define CANDIDATE_MB_TYPE_INTER4V
enum OutputFormat out_format
output format
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
#define CANDIDATE_MB_TYPE_FORWARD_I
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
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
int pre_dia_size
ME prepass diamond size & shape.
Motion estimation context.
qpel_mc_func(* qpel_put)[16]
int no_rounding
apply no rounding to motion compensation (MPEG-4, msmpeg4, ...) for B-frames rounding mode is always ...
#define CANDIDATE_MB_TYPE_BACKWARD_I
int me_cmp
motion estimation comparison function
Picture current_picture
copy of the current picture structure.
int16_t(* b_bidir_forw_mv_table)[2]
MV table (1MV per MB) bidir mode B-frame encoding.
static int get_flags(MotionEstContext *c, int direct, int chroma)
uint16_t pp_time
time distance between the last 2 p,s,i frames
int(* me_cmp_func)(struct MpegEncContext *c, uint8_t *blk1, uint8_t *blk2, ptrdiff_t stride, int h)
op_pixels_func(* hpel_avg)[4]
int mb_height
number of MBs horizontally & vertically
#define CHECK_BIDIR2(a, b, c, d)
const uint8_t * current_mv_penalty
#define FF_CMP_MEDIAN_SAD
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
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 uint8_t fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need.
int unrestricted_mv
mv can point outside of the coded picture
static int get_penalty_factor(int lambda, int lambda2, int type)
int flags
AV_CODEC_FLAG_*.
static void direct(const float *in, const FFTComplex *ir, int len, float *out)
static void init_interlaced_ref(MpegEncContext *s, int ref_index)
MpegvideoEncDSPContext mpvencdsp
int quarter_sample
1->qpel, 0->half pel ME/MC
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
qpel_mc_func put_qpel_pixels_tab[2][16]
uint8_t *[2][2] b_field_select_table
static float mean(const float *input, int size)
int(* pix_norm1)(uint8_t *pix, int line_size)
int(* pix_sum)(uint8_t *pix, int line_size)
int(* cmp_func)(const void *, const void *)
Motion estimation template.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static int cmp_fpel_internal(MpegEncContext *s, const int x, const int y, 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)
Picture new_picture
copy of the source picture structure for encoding.
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)
int16_t(*[2] motion_val)[2]
#define FF_MB_DECISION_SIMPLE
uses mb_cmp
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static int interlaced_search(MpegEncContext *s, int ref_index, int16_t(*mv_tables[2][2])[2], uint8_t *field_select_tables[2], int mx, int my, int user_field_select)
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 mb_decision
macroblock decision mode
static int get_mb_score(MpegEncContext *s, int mx, int my, int src_index, int ref_index, int size, int h, int add_rate)
preferred ID for MPEG-1/2 video decoding
const uint8_t * fcode_tab
smallest fcode needed for each MV
int block_index[6]
index to current MB in block based arrays with edges
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 estimate_motion_b(MpegEncContext *s, int mb_x, int mb_y, int16_t(*mv_table)[2], int ref_index, int f_code)
#define HASH8(fx, fy, bx, by)
#define MV_TYPE_16X16
1 vector for the whole mb
int first_slice_line
used in MPEG-4 too to handle resync markers
uint16_t * mc_mb_var
Table for motion compensated MB variances.
#define AV_LOG_INFO
Standard information.
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
Libavcodec external API header.
ptrdiff_t linesize
line size, in bytes, may be different from width
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
#define CHECK_SAD_HALF_MV(suffix, x, y)
int height
picture size. must be a multiple of 16
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
static int direct_search(MpegEncContext *s, int mb_x, int mb_y)
op_pixels_func put_no_rnd_pixels_tab[4][4]
Halfpel motion compensation with no rounding (a+b)>>1.
int16_t(*[2][2][2] b_field_mv_table)[2]
MV table (4MV per MB) interlaced B-frame encoding.
#define FF_COMPLIANCE_NORMAL
#define CANDIDATE_MB_TYPE_DIRECT
static av_always_inline int cmp_direct_inline(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, int qpel)
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
const VDPAUPixFmtMap * map
static int ff_h263_round_chroma(int x)
#define CANDIDATE_MB_TYPE_BIDIR_I
int f_code
forward MV resolution
int ff_pre_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
#define CANDIDATE_MB_TYPE_DIRECT0
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
static void set_p_mv_tables(MpegEncContext *s, int mx, int my, int mv4)
int motion_est
ME algorithm.
static int sad_hpel_motion_search(MpegEncContext *s, int *mx_ptr, int *my_ptr, int dmin, int src_index, int ref_index, int size, int h)
int16_t(* b_bidir_back_mv_table)[2]
MV table (1MV per MB) bidir mode B-frame encoding.
#define flags(name, subs,...)
int ff_init_me(MpegEncContext *s)
uint8_t *[2] p_field_select_table
int16_t(* b_direct_mv_table)[2]
MV table (1MV per MB) direct mode B-frame encoding.
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define av_builtin_constant_p
qpel_mc_func(* qpel_avg)[16]
int64_t mc_mb_var_sum_temp
int16_t(* b_forw_mv_table)[2]
MV table (1MV per MB) forward mode B-frame encoding.
static void zero_hpel(uint8_t *a, const uint8_t *b, ptrdiff_t stride, int h)
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
struct AVCodecContext * avctx
GLint GLenum GLboolean GLsizei stride
int mb_cmp
macroblock comparison function (not supported yet)
int direct_basis_mv[4][2]
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
static int ref[MAX_W *MAX_W]
#define CANDIDATE_MB_TYPE_FORWARD
Picture last_picture
copy of the previous picture structure.
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)
int co_located_mv[4][2]
mv from last P-frame for direct mode ME
double fmin(double, double)
me_cmp_func me_sub_cmp[6]
uint32_t * map
map to avoid duplicate evaluations
static int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift)
#define CANDIDATE_MB_TYPE_INTRA
int dia_size
ME diamond size & shape.
static void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index)
static int cmp_hpel(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)
int ff_get_best_fcode(MpegEncContext *s, int16_t(*mv_table)[2], int type)
Picture next_picture
copy of the next picture structure.
void ff_fix_long_mvs(MpegEncContext *s, uint8_t *field_select_table, int field_select, int16_t(*mv_table)[2], int f_code, int type, int truncate)
void ff_fix_long_p_mvs(MpegEncContext *s, int type)
uint32_t * mb_type
types and macros are defined in mpegutils.h
static av_always_inline int cmp_inline(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, int qpel, int chroma)
#define CANDIDATE_MB_TYPE_BACKWARD
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
int b_code
backward MV resolution for B-frames (MPEG-4)
int me_pre_cmp
motion estimation prepass comparison function
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
unsigned int lambda
Lagrange multiplier used in rate distortion.
#define HASH(fx, fy, bx, by)
uint16_t pb_time
time distance between the last b and p,s,i frame