Go to the documentation of this file.
44 #if FF_API_PRIVATE_OPT
58 s->spatial_decomposition_type=
s->pred;
63 for(plane_index=0; plane_index<3; plane_index++){
64 s->plane[plane_index].diag_mc= 1;
65 s->plane[plane_index].htaps= 6;
66 s->plane[plane_index].hcoeff[0]= 40;
67 s->plane[plane_index].hcoeff[1]= -10;
68 s->plane[plane_index].hcoeff[2]= 2;
69 s->plane[plane_index].fast_mc= 1;
85 s->m.mb_num = (avctx->
width * avctx->
height + 255) / 256;
92 if (!
s->m.me.scratchpad || !
s->m.me.map || !
s->m.me.score_map || !
s->m.sc.obmc_scratchpad)
120 s->colorspace_type= 0;
124 s->colorspace_type = 1;
142 ff_set_cmp(&
s->mecc,
s->mecc.me_sub_cmp,
s->avctx->me_sub_cmp);
145 if (!
s->input_picture)
152 int size=
s->b_width *
s->b_height << 2*
s->block_max_depth;
153 for(
i=0;
i<
s->max_ref_frames;
i++){
156 if (!
s->ref_mvs[
i] || !
s->ref_scores[
i])
170 for (
i = 0;
i <
h;
i++) {
171 for (j = 0; j <
w; j++) {
175 pix += line_size -
w;
187 for (
i = 0;
i <
w;
i++) {
188 for (j = 0; j <
w; j ++) {
192 pix += line_size -
w;
224 #define P_TOPRIGHT P[3]
225 #define P_MEDIAN P[4]
227 #define FLAG_QPEL 1 //must be 1
232 uint8_t p_state[
sizeof(
s->block_state)];
233 uint8_t i_state[
sizeof(
s->block_state)];
236 uint8_t *pbbak_start=
s->c.bytestream_start;
237 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
238 const int w=
s->b_width <<
s->block_max_depth;
239 const int h=
s->b_height <<
s->block_max_depth;
240 const int rem_depth=
s->block_max_depth -
level;
241 const int index= (
x + y*
w) << rem_depth;
243 int trx= (
x+1)<<rem_depth;
244 int try= (y+1)<<rem_depth;
251 int pl =
left->color[0];
252 int pcb=
left->color[1];
253 int pcr=
left->color[2];
257 const int stride=
s->current_picture->linesize[0];
258 const int uvstride=
s->current_picture->linesize[1];
259 uint8_t *current_data[3]= {
s->input_picture->data[0] + (
x + y*
stride)*block_w,
260 s->input_picture->data[1] + ((
x*block_w)>>
s->chroma_h_shift) + ((y*uvstride*block_w)>>
s->chroma_v_shift),
261 s->input_picture->data[2] + ((
x*block_w)>>
s->chroma_h_shift) + ((y*uvstride*block_w)>>
s->chroma_v_shift)};
263 int16_t last_mv[3][2];
265 const int shift= 1+qpel;
271 int ref, best_ref, ref_score, ref_mx, ref_my;
275 set_blocks(
s,
level,
x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
288 last_mv[0][0]=
s->block[
index].mx;
289 last_mv[0][1]=
s->block[
index].my;
290 last_mv[1][0]= right->
mx;
291 last_mv[1][1]= right->
my;
292 last_mv[2][0]= bottom->
mx;
293 last_mv[2][1]= bottom->
my;
306 c->current_mv_penalty=
c->mv_penalty[
s->m.f_code=1] +
MAX_DMV;
308 c->xmin = -
x*block_w - 16+3;
309 c->ymin = - y*block_w - 16+3;
310 c->xmax = - (
x+1)*block_w + (
w<<(
LOG2_MB_SIZE -
s->block_max_depth)) + 16-3;
311 c->ymax = - (y+1)*block_w + (
h<<(
LOG2_MB_SIZE -
s->block_max_depth)) + 16-3;
345 ref_score=
c->sub_motion_search(&
s->m, &ref_mx, &ref_my, ref_score, 0, 0,
level-
LOG2_MB_SIZE+4, block_w);
353 if(score > ref_score){
363 base_bits=
get_rac_count(&
s->c) - 8*(
s->c.bytestream -
s->c.bytestream_start);
366 pc.bytestream= p_buffer;
367 memcpy(p_state,
s->block_state,
sizeof(
s->block_state));
369 if(
level!=
s->block_max_depth)
370 put_rac(&pc, &p_state[4 + s_context], 1);
372 if(
s->ref_frames > 1)
373 put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
375 put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
376 put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
377 p_len= pc.bytestream - pc.bytestream_start;
380 block_s= block_w*block_w;
382 l= (sum + block_s/2)/block_s;
383 iscore =
pix_norm1(current_data[0],
stride, block_w) - 2*l*sum + l*l*block_s;
385 if (
s->nb_planes > 2) {
386 block_s= block_w*block_w>>(
s->chroma_h_shift +
s->chroma_v_shift);
387 sum =
pix_sum(current_data[1], uvstride, block_w>>
s->chroma_h_shift, block_w>>
s->chroma_v_shift);
388 cb= (sum + block_s/2)/block_s;
390 sum =
pix_sum(current_data[2], uvstride, block_w>>
s->chroma_h_shift, block_w>>
s->chroma_v_shift);
391 cr= (sum + block_s/2)/block_s;
398 ic.bytestream= i_buffer;
399 memcpy(i_state,
s->block_state,
sizeof(
s->block_state));
400 if(
level!=
s->block_max_depth)
401 put_rac(&ic, &i_state[4 + s_context], 1);
404 if (
s->nb_planes > 2) {
408 i_len= ic.bytestream - ic.bytestream_start;
411 av_assert1(iscore < 255*255*256 + s->lambda2*10);
417 int varc= iscore >> 8;
418 int vard= score >> 8;
419 if (vard <= 64 || vard < varc)
422 c->scene_change_score+=
s->m.qscale;
425 if(
level!=
s->block_max_depth){
426 put_rac(&
s->c, &
s->block_state[4 + s_context], 0);
433 if(score2 < score && score2 < iscore)
439 memcpy(pbbak, i_buffer, i_len);
441 s->c.bytestream_start= pbbak_start;
442 s->c.bytestream= pbbak + i_len;
443 set_blocks(
s,
level,
x, y, l,
cb,
cr, pmx, pmy, 0,
BLOCK_INTRA);
444 memcpy(
s->block_state, i_state,
sizeof(
s->block_state));
447 memcpy(pbbak, p_buffer, p_len);
449 s->c.bytestream_start= pbbak_start;
450 s->c.bytestream= pbbak + p_len;
451 set_blocks(
s,
level,
x, y, pl, pcb, pcr, mx, my, best_ref, 0);
452 memcpy(
s->block_state, p_state,
sizeof(
s->block_state));
458 const int w=
s->b_width <<
s->block_max_depth;
459 const int rem_depth=
s->block_max_depth -
level;
460 const int index= (
x + y*
w) << rem_depth;
461 int trx= (
x+1)<<rem_depth;
467 int pl =
left->color[0];
468 int pcb=
left->color[1];
469 int pcr=
left->color[2];
477 set_blocks(
s,
level,
x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
481 if(
level!=
s->block_max_depth){
483 put_rac(&
s->c, &
s->block_state[4 + s_context], 1);
485 put_rac(&
s->c, &
s->block_state[4 + s_context], 0);
497 if (
s->nb_planes > 2) {
501 set_blocks(
s,
level,
x, y,
b->color[0],
b->color[1],
b->color[2], pmx, pmy, 0,
BLOCK_INTRA);
505 if(
s->ref_frames > 1)
506 put_symbol(&
s->c, &
s->block_state[128 + 1024 + 32*ref_context],
b->ref, 0);
507 put_symbol(&
s->c, &
s->block_state[128 + 32*mx_context],
b->mx - pmx, 1);
508 put_symbol(&
s->c, &
s->block_state[128 + 32*my_context],
b->my - pmy, 1);
509 set_blocks(
s,
level,
x, y, pl, pcb, pcr,
b->mx,
b->my,
b->ref, 0);
515 Plane *p= &
s->plane[plane_index];
516 const int block_size =
MB_SIZE >>
s->block_max_depth;
517 const int block_w = plane_index ? block_size>>
s->chroma_h_shift : block_size;
518 const int block_h = plane_index ? block_size>>
s->chroma_v_shift : block_size;
520 const int obmc_stride= plane_index ? (2*block_size)>>
s->chroma_h_shift : 2*block_size;
521 const int ref_stride=
s->current_picture->linesize[plane_index];
522 uint8_t *
src=
s-> input_picture->data[plane_index];
523 IDWTELEM *dst= (
IDWTELEM*)
s->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4;
524 const int b_stride =
s->b_width <<
s->block_max_depth;
527 int index= mb_x + mb_y*b_stride;
536 b->color[plane_index]= 0;
537 memset(dst, 0, obmc_stride*obmc_stride*
sizeof(
IDWTELEM));
540 int mb_x2= mb_x + (
i &1) - 1;
541 int mb_y2= mb_y + (
i>>1) - 1;
542 int x= block_w*mb_x2 + block_w/2;
543 int y= block_h*mb_y2 + block_h/2;
546 x, y, block_w, block_h,
w,
h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
548 for(y2=
FFMAX(y, 0); y2<
FFMIN(
h, y+block_h); y2++){
550 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;
551 int obmc_v= obmc[
index];
553 if(y<0) obmc_v += obmc[
index + block_h*obmc_stride];
554 if(
x<0) obmc_v += obmc[
index + block_w];
555 if(y+block_h>
h) obmc_v += obmc[
index - block_h*obmc_stride];
556 if(
x+block_w>
w) obmc_v += obmc[
index - block_w];
561 ab += (
src[x2 + y2*ref_stride] - (d>>
FRAC_BITS)) * obmc_v;
562 aa += obmc_v * obmc_v;
572 const int b_stride =
s->b_width <<
s->block_max_depth;
573 const int b_height =
s->b_height<<
s->block_max_depth;
574 int index=
x + y*b_stride;
584 if(x<0 || x>=b_stride || y>=b_height)
610 Plane *p= &
s->plane[plane_index];
611 const int block_size =
MB_SIZE >>
s->block_max_depth;
612 const int block_w = plane_index ? block_size>>
s->chroma_h_shift : block_size;
613 const int block_h = plane_index ? block_size>>
s->chroma_v_shift : block_size;
614 const int obmc_stride= plane_index ? (2*block_size)>>
s->chroma_h_shift : 2*block_size;
615 const int ref_stride=
s->current_picture->linesize[plane_index];
616 uint8_t *dst=
s->current_picture->data[plane_index];
617 uint8_t *
src=
s-> input_picture->data[plane_index];
621 const int b_stride =
s->b_width <<
s->block_max_depth;
622 const int b_height =
s->b_height<<
s->block_max_depth;
628 int sx= block_w*mb_x - block_w/2;
629 int sy= block_h*mb_y - block_h/2;
630 int x0=
FFMAX(0,-sx);
631 int y0=
FFMAX(0,-sy);
632 int x1=
FFMIN(block_w*2,
w-sx);
633 int y1=
FFMIN(block_h*2,
h-sy);
638 ff_snow_pred_block(
s, cur,
tmp, ref_stride, sx, sy, block_w*2, block_h*2, &
s->block[mb_x + mb_y*b_stride], plane_index,
w,
h);
640 for(y=y0; y<y1; y++){
641 const uint8_t *obmc1= obmc_edged[y];
643 uint8_t *cur1 = cur + y*ref_stride;
644 uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
645 for(
x=x0;
x<x1;
x++){
646 #if FRAC_BITS >= LOG2_OBMC_MAX
652 if(v&(~255)) v= ~(v>>31);
659 && (mb_x == 0 || mb_x == b_stride-1)
660 && (mb_y == 0 || mb_y == b_height-1)){
670 memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
681 distortion =
ff_w97_32_c(&
s->m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
683 distortion =
ff_w53_32_c(&
s->m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
687 int off = sx+16*(
i&1) + (sy+16*(
i>>1))*ref_stride;
688 distortion +=
s->mecc.me_cmp[0](&
s->m,
src + off, dst + off, ref_stride, 16);
693 distortion =
s->mecc.me_cmp[0](&
s->m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
704 if(mb_x == b_stride-2)
707 return distortion + rate*penalty_factor;
712 Plane *p= &
s->plane[plane_index];
713 const int block_size =
MB_SIZE >>
s->block_max_depth;
714 const int block_w = plane_index ? block_size>>
s->chroma_h_shift : block_size;
715 const int block_h = plane_index ? block_size>>
s->chroma_v_shift : block_size;
717 const int obmc_stride= plane_index ? (2*block_size)>>
s->chroma_h_shift : 2*block_size;
718 const int ref_stride=
s->current_picture->linesize[plane_index];
719 uint8_t *dst=
s->current_picture->data[plane_index];
720 uint8_t *
src=
s-> input_picture->data[plane_index];
724 const int b_stride =
s->b_width <<
s->block_max_depth;
734 int mb_x2= mb_x + (
i%3) - 1;
735 int mb_y2= mb_y + (
i/3) - 1;
736 int x= block_w*mb_x2 + block_w/2;
737 int y= block_h*mb_y2 + block_h/2;
740 x, y, block_w, block_h,
w,
h, 0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
743 for(y2= y; y2<0; y2++)
744 memcpy(dst +
x + y2*ref_stride,
src +
x + y2*ref_stride, block_w);
745 for(y2=
h; y2<y+block_h; y2++)
746 memcpy(dst +
x + y2*ref_stride,
src +
x + y2*ref_stride, block_w);
748 for(y2= y; y2<y+block_h; y2++)
749 memcpy(dst +
x + y2*ref_stride,
src +
x + y2*ref_stride, -
x);
752 for(y2= y; y2<y+block_h; y2++)
753 memcpy(dst +
w + y2*ref_stride,
src +
w + y2*ref_stride,
x+block_w -
w);
757 distortion +=
s->mecc.me_cmp[block_w==8](&
s->m,
src +
x + y*ref_stride, dst +
x + y*ref_stride, ref_stride, block_h);
771 for(
i=merged?4:0;
i<9;
i++){
772 static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
776 return distortion + rate*penalty_factor;
780 const int w=
b->width;
781 const int h=
b->height;
786 int *runs =
s->run_buffer;
793 int l=0, lt=0, t=0, rt=0;
815 if(px<b->parent->width && py<b->parent->height)
816 p= parent[px + py*2*
stride];
820 runs[run_index++]=
run;
828 max_index= run_index;
829 runs[run_index++]=
run;
831 run= runs[run_index++];
834 if(run_index <= max_index)
838 if(
s->c.bytestream_end -
s->c.bytestream <
w*40){
844 int l=0, lt=0, t=0, rt=0;
866 if(px<b->parent->width && py<b->parent->height)
867 p= parent[px + py*2*
stride];
875 run= runs[run_index++];
877 if(run_index <= max_index)
887 int l2= 2*
FFABS(l) + (l<0);
907 const int b_stride=
s->b_width <<
s->block_max_depth;
917 block->color[0] = p[0];
918 block->color[1] = p[1];
919 block->color[2] = p[2];
923 value=
s->me_cache_generation + (p[0]>>10) + (p[1]<<6) + (
block->ref<<12);
933 rd=
get_block_rd(
s, mb_x, mb_y, 0, obmc_edged) +
s->intra_penalty * !!intra;
949 return check_block(
s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
953 const int b_stride=
s->b_width <<
s->block_max_depth;
962 backup[0] =
block[0];
963 backup[1] =
block[1];
964 backup[2] =
block[b_stride];
965 backup[3] =
block[b_stride + 1];
972 value=
s->me_cache_generation + (p0>>10) + (p1<<6) + (
block->ref<<12);
992 block[b_stride]= backup[2];
993 block[b_stride+1]= backup[3];
999 int pass, mb_x, mb_y;
1000 const int b_width =
s->b_width <<
s->block_max_depth;
1001 const int b_height=
s->b_height <<
s->block_max_depth;
1002 const int b_stride= b_width;
1008 memcpy(
state,
s->block_state,
sizeof(
s->block_state));
1009 for(mb_y= 0; mb_y<
s->b_height; mb_y++)
1010 for(mb_x= 0; mb_x<
s->b_width; mb_x++)
1013 memcpy(
s->block_state,
state,
sizeof(
s->block_state));
1019 for(mb_y= 0; mb_y<b_height; mb_y++){
1020 for(mb_x= 0; mb_x<b_width; mb_x++){
1021 int dia_change,
i, j,
ref;
1022 int best_rd= INT_MAX, ref_rd;
1024 const int index= mb_x + mb_y * b_stride;
1034 const int b_w= (
MB_SIZE >>
s->block_max_depth);
1043 if(!
s->me_cache_generation)
1044 memset(
s->me_cache, 0,
sizeof(
s->me_cache));
1045 s->me_cache_generation += 1<<22;
1050 for (y = 0; y < b_w * 2; y++)
1051 memcpy(obmc_edged[y],
ff_obmc_tab[
s->block_max_depth] + y * b_w * 2, b_w * 2);
1053 for(y=0; y<b_w*2; y++)
1054 memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1055 if(mb_x==b_stride-1)
1056 for(y=0; y<b_w*2; y++)
1057 memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1059 for(
x=0;
x<b_w*2;
x++)
1060 obmc_edged[0][
x] += obmc_edged[b_w-1][
x];
1061 for(y=1; y<b_w; y++)
1062 memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1064 if(mb_y==b_height-1){
1065 for(
x=0;
x<b_w*2;
x++)
1066 obmc_edged[b_w*2-1][
x] += obmc_edged[b_w][
x];
1067 for(y=b_w; y<b_w*2-1; y++)
1068 memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1073 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
1075 uint8_t *dst=
s->current_picture->data[0];
1076 const int stride=
s->current_picture->linesize[0];
1077 const int block_w=
MB_SIZE >>
s->block_max_depth;
1078 const int block_h=
MB_SIZE >>
s->block_max_depth;
1079 const int sx= block_w*mb_x - block_w/2;
1080 const int sy= block_h*mb_y - block_h/2;
1081 const int w=
s->plane[0].width;
1082 const int h=
s->plane[0].height;
1087 for(y=
h; y<sy+block_h*2; y++)
1090 for(y=sy; y<sy+block_h*2; y++)
1093 if(sx+block_w*2 >
w){
1094 for(y=sy; y<sy+block_h*2; y++)
1100 for(
i=0;
i <
s->nb_planes;
i++)
1106 check_block(
s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);
1113 int16_t (*mvr)[2]= &
s->ref_mvs[
ref][
index];
1122 check_block_inter(
s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1128 check_block_inter(
s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1133 int newx =
block->mx;
1134 int newy =
block->my;
1135 int dia_size =
s->iterative_dia_size ?
s->iterative_dia_size :
FFMAX(
s->avctx->dia_size, 1);
1137 for(
i=0;
i < dia_size;
i++){
1139 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx+4*(
i-j), newy+(4*j), obmc_edged, &best_rd);
1140 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx-4*(
i-j), newy-(4*j), obmc_edged, &best_rd);
1141 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx-(4*j), newy+4*(
i-j), obmc_edged, &best_rd);
1142 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx+(4*j), newy-4*(
i-j), obmc_edged, &best_rd);
1148 static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1155 mvr[0][0]=
block->mx;
1156 mvr[0][1]=
block->my;
1157 if(ref_rd > best_rd){
1184 if(
s->block_max_depth == 1){
1186 for(mb_y= 0; mb_y<b_height; mb_y+=2){
1187 for(mb_x= 0; mb_x<b_width; mb_x+=2){
1189 int best_rd, init_rd;
1190 const int index= mb_x + mb_y * b_stride;
1195 b[2]=
b[0]+b_stride;
1202 if(!
s->me_cache_generation)
1203 memset(
s->me_cache, 0,
sizeof(
s->me_cache));
1204 s->me_cache_generation += 1<<22;
1210 (
b[0]->mx +
b[1]->mx +
b[2]->mx +
b[3]->mx + 2) >> 2,
1211 (
b[0]->my +
b[1]->my +
b[2]->my +
b[3]->my + 2) >> 2, 0, &best_rd);
1217 if(init_rd != best_rd)
1248 const int w=
b->width;
1249 const int h=
b->height;
1250 const int qlog= av_clip(
s->qlog +
b->qlog, 0,
QROOT*16);
1252 int x,y, thres1, thres2;
1261 bias= bias ? 0 : (3*qmul)>>3;
1270 if((
unsigned)(
i+thres1) > thres2){
1290 if((
unsigned)(
i+thres1) > thres2){
1293 i= (
i + bias) / qmul;
1298 i= (
i + bias) / qmul;
1309 const int w=
b->width;
1310 const int h=
b->height;
1311 const int qlog= av_clip(
s->qlog +
b->qlog, 0,
QROOT*16);
1331 const int w=
b->width;
1332 const int h=
b->height;
1335 for(y=
h-1; y>=0; y--){
1336 for(
x=
w-1;
x>=0;
x--){
1355 const int w=
b->width;
1356 const int h=
b->height;
1379 int plane_index,
level, orientation;
1381 for(plane_index=0; plane_index<
FFMIN(
s->nb_planes, 2); plane_index++){
1383 for(orientation=
level ? 1:0; orientation<4; orientation++){
1384 if(orientation==2)
continue;
1385 put_symbol(&
s->c,
s->header_state,
s->plane[plane_index].band[
level][orientation].qlog, 1);
1395 memset(kstate,
MID_STATE,
sizeof(kstate));
1398 if(
s->keyframe ||
s->always_reset){
1400 s->last_spatial_decomposition_type=
1404 s->last_block_max_depth= 0;
1405 for(plane_index=0; plane_index<2; plane_index++){
1406 Plane *p= &
s->plane[plane_index];
1414 put_rac(&
s->c,
s->header_state,
s->always_reset);
1415 put_symbol(&
s->c,
s->header_state,
s->temporal_decomposition_type, 0);
1416 put_symbol(&
s->c,
s->header_state,
s->temporal_decomposition_count, 0);
1417 put_symbol(&
s->c,
s->header_state,
s->spatial_decomposition_count, 0);
1419 if (
s->nb_planes > 2) {
1423 put_rac(&
s->c,
s->header_state,
s->spatial_scalability);
1432 for(plane_index=0; plane_index<
FFMIN(
s->nb_planes, 2); plane_index++){
1433 Plane *p= &
s->plane[plane_index];
1438 put_rac(&
s->c,
s->header_state, update_mc);
1440 for(plane_index=0; plane_index<
FFMIN(
s->nb_planes, 2); plane_index++){
1441 Plane *p= &
s->plane[plane_index];
1448 if(
s->last_spatial_decomposition_count !=
s->spatial_decomposition_count){
1450 put_symbol(&
s->c,
s->header_state,
s->spatial_decomposition_count, 0);
1456 put_symbol(&
s->c,
s->header_state,
s->spatial_decomposition_type -
s->last_spatial_decomposition_type, 1);
1458 put_symbol(&
s->c,
s->header_state,
s->mv_scale -
s->last_mv_scale, 1);
1459 put_symbol(&
s->c,
s->header_state,
s->qbias -
s->last_qbias , 1);
1460 put_symbol(&
s->c,
s->header_state,
s->block_max_depth -
s->last_block_max_depth, 1);
1468 for(plane_index=0; plane_index<2; plane_index++){
1469 Plane *p= &
s->plane[plane_index];
1476 s->last_spatial_decomposition_type =
s->spatial_decomposition_type;
1477 s->last_qlog =
s->qlog;
1478 s->last_qbias =
s->qbias;
1479 s->last_mv_scale =
s->mv_scale;
1480 s->last_block_max_depth =
s->block_max_depth;
1481 s->last_spatial_decomposition_count =
s->spatial_decomposition_count;
1494 uint32_t coef_sum= 0;
1495 int level, orientation, delta_qlog;
1498 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1501 const int w=
b->width;
1502 const int h=
b->height;
1504 const int qlog= av_clip(2*
QROOT +
b->qlog, 0,
QROOT*16);
1506 const int qdiv= (1<<16)/qmul;
1516 coef_sum+=
abs(buf[
x+y*
stride]) * qdiv >> 16;
1522 coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1525 s->m.current_picture.mb_var_sum= coef_sum;
1526 s->m.current_picture.mc_mb_var_sum= 0;
1528 s->m.current_picture.mc_mb_var_sum= coef_sum;
1529 s->m.current_picture.mb_var_sum= 0;
1537 s->qlog+= delta_qlog;
1544 int level, orientation,
x, y;
1547 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1552 memset(
s->spatial_idwt_buffer, 0,
sizeof(*
s->spatial_idwt_buffer)*
width*
height);
1553 ibuf[
b->width/2 +
b->height/2*
b->stride]= 256*16;
1557 int64_t d=
s->spatial_idwt_buffer[
x + y*
width]*16;
1568 const AVFrame *pict,
int *got_packet)
1573 const int width=
s->avctx->width;
1574 const int height=
s->avctx->height;
1575 int level, orientation, plane_index,
i, y,
ret;
1576 uint8_t rc_header_bak[
sizeof(
s->header_state)];
1577 uint8_t rc_block_bak[
sizeof(
s->block_state)];
1585 for(
i=0;
i <
s->nb_planes;
i++){
1586 int hshift=
i ?
s->chroma_h_shift : 0;
1587 int vshift=
i ?
s->chroma_v_shift : 0;
1589 memcpy(&
s->input_picture->data[
i][y *
s->input_picture->linesize[
i]],
1592 s->mpvencdsp.draw_edges(
s->input_picture->data[
i],
s->input_picture->linesize[
i],
1599 pic =
s->input_picture;
1628 #if FF_API_CODED_FRAME
1634 if (
s->current_picture->data[0]) {
1635 int w =
s->avctx->width;
1636 int h =
s->avctx->height;
1638 #if FF_API_CODED_FRAME
1644 s->mpvencdsp.draw_edges(
s->current_picture->data[0],
1645 s->current_picture->linesize[0],
w ,
h ,
1647 if (
s->current_picture->data[2]) {
1648 s->mpvencdsp.draw_edges(
s->current_picture->data[1],
1649 s->current_picture->linesize[1],
w>>
s->chroma_h_shift,
h>>
s->chroma_v_shift,
1651 s->mpvencdsp.draw_edges(
s->current_picture->data[2],
1652 s->current_picture->linesize[2],
w>>
s->chroma_h_shift,
h>>
s->chroma_v_shift,
1659 #if FF_API_CODED_FRAME
1667 s->m.current_picture_ptr= &
s->m.current_picture;
1668 s->m.current_picture.f =
s->current_picture;
1669 s->m.current_picture.f->pts = pict->
pts;
1671 int block_width = (
width +15)>>4;
1672 int block_height= (
height+15)>>4;
1673 int stride=
s->current_picture->linesize[0];
1678 s->m.avctx=
s->avctx;
1680 s->m. new_picture.f =
s->input_picture;
1683 s->m.uvlinesize=
s->current_picture->linesize[1];
1686 s->m.mb_width = block_width;
1687 s->m.mb_height= block_height;
1688 s->m.mb_stride=
s->m.mb_width+1;
1689 s->m.b8_stride= 2*
s->m.mb_width+1;
1692 s->m.motion_est=
s->motion_est;
1693 s->m.me.scene_change_score=0;
1697 s->m.unrestricted_mv= 1;
1699 s->m.lambda =
s->lambda;
1705 s->m.hdsp =
s->hdsp;
1707 s->hdsp =
s->m.hdsp;
1712 memcpy(rc_header_bak,
s->header_state,
sizeof(
s->header_state));
1713 memcpy(rc_block_bak,
s->block_state,
sizeof(
s->block_state));
1718 s->spatial_decomposition_count= 5;
1720 while( !(
width >>(
s->chroma_h_shift +
s->spatial_decomposition_count))
1721 || !(
height>>(
s->chroma_v_shift +
s->spatial_decomposition_count)))
1722 s->spatial_decomposition_count--;
1724 if (
s->spatial_decomposition_count <= 0) {
1734 if(
s->last_spatial_decomposition_count !=
s->spatial_decomposition_count){
1735 for(plane_index=0; plane_index <
s->nb_planes; plane_index++){
1741 s->m.misc_bits = 8*(
s->c.bytestream -
s->c.bytestream_start);
1743 s->m.mv_bits = 8*(
s->c.bytestream -
s->c.bytestream_start) -
s->m.misc_bits;
1745 for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1746 Plane *p= &
s->plane[plane_index];
1752 if (!
s->memc_only) {
1754 if(pict->
data[plane_index])
1762 #if FF_API_PRIVATE_OPT
1764 if(
s->avctx->scenechange_threshold)
1765 s->scenechange_threshold =
s->avctx->scenechange_threshold;
1772 &&
s->m.me.scene_change_score >
s->scenechange_threshold){
1777 s->current_picture->key_frame=1;
1795 ff_spatial_dwt(
s->spatial_dwt_buffer,
s->temp_dwt_buffer,
w,
h,
w,
s->spatial_decomposition_type,
s->spatial_decomposition_count);
1797 if(
s->pass1_rc && plane_index==0){
1799 if (delta_qlog <= INT_MIN)
1804 memcpy(
s->header_state, rc_header_bak,
sizeof(
s->header_state));
1805 memcpy(
s->block_state, rc_block_bak,
sizeof(
s->block_state));
1812 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1818 if (!
s->no_bitstream)
1827 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1834 ff_spatial_idwt(
s->spatial_idwt_buffer,
s->temp_idwt_buffer,
w,
h,
w,
s->spatial_decomposition_type,
s->spatial_decomposition_count);
1848 s->current_picture->data[plane_index][y*
s->current_picture->linesize[plane_index] +
x]=
1853 memset(
s->spatial_idwt_buffer, 0,
sizeof(
IDWTELEM)*
w*
h);
1860 if(pict->
data[plane_index])
1863 int d=
s->current_picture->data[plane_index][y*
s->current_picture->linesize[plane_index] +
x] - pict->
data[plane_index][y*pict->
linesize[plane_index] +
x];
1867 s->avctx->error[plane_index] +=
error;
1868 s->encoding_error[plane_index] =
error;
1878 s->current_picture->coded_picture_number = avctx->
frame_number;
1879 s->current_picture->pict_type = pic->
pict_type;
1880 s->current_picture->quality = pic->
quality;
1881 s->m.frame_bits = 8*(
s->c.bytestream -
s->c.bytestream_start);
1882 s->m.p_tex_bits =
s->m.frame_bits -
s->m.misc_bits -
s->m.mv_bits;
1883 s->m.current_picture.f->display_picture_number =
1884 s->m.current_picture.f->coded_picture_number = avctx->
frame_number;
1885 s->m.current_picture.f->quality = pic->
quality;
1886 s->m.total_bits += 8*(
s->c.bytestream -
s->c.bytestream_start);
1892 s->m.last_pict_type =
s->m.pict_type;
1893 #if FF_API_STAT_BITS
1907 s->current_picture->pict_type);
1909 #if FF_API_ERROR_FRAME
1911 memcpy(
s->current_picture->error,
s->encoding_error,
sizeof(
s->encoding_error));
1916 if (
s->current_picture->key_frame)
1935 #define OFFSET(x) offsetof(SnowContext, x)
1936 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1943 {
"memc_only",
"Only do ME/MC (I frames -> ref, P frame -> ME+MC).",
OFFSET(memc_only),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VE },
1944 {
"no_bitstream",
"Skip final bitstream writeout.",
OFFSET(no_bitstream),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VE },
1945 {
"intra_penalty",
"Penalty for intra blocks in block decission",
OFFSET(intra_penalty),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
VE },
1946 {
"iterative_dia_size",
"Dia size for the iterative ME",
OFFSET(iterative_dia_size),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
VE },
1947 {
"sc_threshold",
"Scene change threshold",
OFFSET(scenechange_threshold),
AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX,
VE },
static void error(const char *err)
#define FF_ENABLE_DEPRECATION_WARNINGS
static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
static void set_blocks(SnowContext *s, int level, int x, int y, int l, int cb, int cr, int mx, int my, int ref, int type)
AVPixelFormat
Pixel format.
static void iterative_me(SnowContext *s)
static av_cold int init(AVCodecContext *avctx)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static double cb(void *priv, double x, double y)
static av_cold int encode_end(AVCodecContext *avctx)
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Motion estimation context.
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)
int ff_w97_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
This structure describes decoded (raw) audio or video data.
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
static void update_last_header_values(SnowContext *s)
enum AVPictureType last_picture
static int get_penalty_factor(int lambda, int lambda2, int type)
static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
attribute_deprecated int p_tex_bits
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
av_cold int ff_rate_control_init(MpegEncContext *s)
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
av_cold void ff_snow_common_end(SnowContext *s)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
void ff_spatial_dwt(DWTELEM *buffer, DWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
uint8_t type
Bitfield of BLOCK_*.
attribute_deprecated int frame_bits
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
attribute_deprecated int prediction_method
void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo x
int refs
number of reference frames
SubBand band[DWT_LEVELS][4]
int flags
AV_CODEC_FLAG_*.
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride, int sx, int sy, int b_w, int b_h, const BlockNode *block, int plane_index, int w, int h)
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 type
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
int ff_snow_common_init_after_header(AVCodecContext *avctx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
void ff_h263_encode_init(MpegEncContext *s)
static void encode_blocks(SnowContext *s, int search)
int global_quality
Global quality for codecs which cannot change it per frame.
#define AV_CEIL_RSHIFT(a, b)
#define BLOCK_OPT
Block needs no checks in this round of iterative motion estiation.
static void calculate_visual_weight(SnowContext *s, Plane *p)
attribute_deprecated int mv_bits
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static enum AVPixelFormat pix_fmts[]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static av_always_inline void add_yblock(SnowContext *s, int sliced, slice_buffer *sb, IDWTELEM *dst, uint8_t *dst8, const uint8_t *obmc, int src_x, int src_y, int b_w, int b_h, int w, int h, int dst_stride, int src_stride, int obmc_stride, int b_x, int b_y, int add, int offset_dst, int plane_index)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
#define AV_INPUT_BUFFER_MIN_SIZE
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
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 default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
#define LIBAVUTIL_VERSION_INT
void ff_write_pass1_stats(MpegEncContext *s)
Describe the class of an AVClass context structure.
static av_always_inline int check_block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, uint8_t(*obmc_edged)[MB_SIZE *2], int *best_rd)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
attribute_deprecated int misc_bits
int16_t my
Motion vector component Y, see mv_scale.
int64_t bit_rate
the average bitrate
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
#define ROUNDED_DIV(a, b)
const char * av_default_item_name(void *ptr)
Return the context name.
@ AV_PICTURE_TYPE_I
Intra.
void ff_snow_release_buffer(AVCodecContext *avctx)
static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index)
static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
int ff_snow_common_init(AVCodecContext *avctx)
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
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 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)
char * stats_out
pass1 encoding statistics output buffer
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
enum AVPictureType pict_type
Picture type of the frame.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
static void encode_header(SnowContext *s)
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
int8_t last_hcoeff[HTAPS_MAX/2]
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
static int encode_q_branch(SnowContext *s, int level, int x, int y)
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
int flags
A combination of AV_PKT_FLAG values.
static void encode_q_branch2(SnowContext *s, int level, int x, int y)
int ff_get_mb_score(struct MpegEncContext *s, int mx, int my, int src_index, int ref_index, int size, int h, int add_rate)
const int8_t ff_quant3bA[256]
int8_t hcoeff[HTAPS_MAX/2]
const uint8_t *const ff_obmc_tab[4]
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define ENCODER_EXTRA_BITS
#define i(width, name, range_min, range_max)
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
static int get_block_bits(SnowContext *s, int x, int y, int w)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
const uint32_t ff_square_tab[512]
#define BLOCK_INTRA
Intra block, inter otherwise.
static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t(*obmc_edged)[MB_SIZE *2])
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static int qscale2qlog(int qscale)
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 default value
int dia_size
ME diamond size & shape.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int mb_lmin
minimum MB Lagrange multiplier
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
static int pix_sum(uint8_t *pix, int line_size, int w, int h)
const char * name
Name of the codec implementation.
int ff_snow_frame_start(SnowContext *s)
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
int ff_init_me(MpegEncContext *s)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
av_cold void ff_rate_control_uninit(MpegEncContext *s)
static const float pred[4]
static float search(FOCContext *foc, int pass, int maxpass, int xmin, int xmax, int ymin, int ymax, int *best_x, int *best_y, float best_score)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
static av_cold int encode_init(AVCodecContext *avctx)
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo ug o o w
static const AVOption options[]
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
void ff_snow_reset_contexts(SnowContext *s)
static void encode_qlogs(SnowContext *s)
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
main external API structure.
static av_always_inline int check_4block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, int ref, int *best_rd)
static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index)
static int ref[MAX_W *MAX_W]
static int get_rac_count(RangeCoder *c)
int mb_lmax
maximum MB Lagrange multiplier
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static int shift(int a, int b)
#define FF_DISABLE_DEPRECATION_WARNINGS
@ AV_PICTURE_TYPE_P
Predicted.
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
int16_t mx
Motion vector component X, see mv_scale.
int frame_number
Frame counter, set by libavcodec.
This structure stores compressed data.
static double cr(void *priv, double x, double y)
static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias)
static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride)
static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
int width
picture width / height.
static uint32_t inverse(uint32_t v)
find multiplicative inverse modulo 2 ^ 32
static const BlockNode null_block
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
The exact code depends on how similar the blocks are and how related they are to the block
int ff_w53_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
static int pix_norm1(uint8_t *pix, int line_size, int w)
static const AVClass snowenc_class
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
static av_always_inline int check_block(SnowContext *s, int mb_x, int mb_y, int p[3], int intra, uint8_t(*obmc_edged)[MB_SIZE *2], int *best_rd)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
int ff_snow_alloc_blocks(SnowContext *s)
uint8_t ref
Reference frame index.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.