53 for(plane_index=0; plane_index<3; plane_index++){
153 for (i = 0; i < h; i++) {
154 for (j = 0; j < w; j++) {
158 pix += line_size - w;
170 for (i = 0; i < w; i++) {
171 for (j = 0; j < w; j ++) {
175 pix += line_size - w;
186 return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
207 #define P_TOPRIGHT P[3]
208 #define P_MEDIAN P[4]
210 #define FLAG_QPEL 1 //must be 1
220 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
224 const int index= (x + y*w) << rem_depth;
226 int trx= (x+1)<<rem_depth;
227 int try= (y+1)<<rem_depth;
233 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->
block[index-w+(1<<rem_depth)] : tl;
234 int pl = left->
color[0];
235 int pcb= left->
color[1];
236 int pcr= left->
color[2];
246 int16_t last_mv[3][2];
248 const int shift= 1+qpel;
254 int ref, best_ref, ref_score, ref_mx, ref_my;
258 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
273 last_mv[1][0]= right->
mx;
274 last_mv[1][1]= right->
my;
275 last_mv[2][0]= bottom->
mx;
276 last_mv[2][1]= bottom->
my;
291 c->
xmin = - x*block_w - 16+3;
292 c->
ymin = - y*block_w - 16+3;
336 if(score > ref_score){
349 pc.bytestream= p_buffer;
353 put_rac(&pc, &p_state[4 + s_context], 1);
356 put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
357 pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
358 put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
359 put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
360 p_len= pc.bytestream - pc.bytestream_start;
363 block_s= block_w*block_w;
364 sum =
pix_sum(current_data[0], stride, block_w, block_w);
365 l= (sum + block_s/2)/block_s;
366 iscore =
pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
371 cb= (sum + block_s/2)/block_s;
374 cr= (sum + block_s/2)/block_s;
381 ic.bytestream= i_buffer;
384 put_rac(&ic, &i_state[4 + s_context], 1);
391 i_len= ic.bytestream - ic.bytestream_start;
394 av_assert1(iscore < 255*255*256 + s->lambda2*10);
400 int varc= iscore >> 8;
401 int vard= score >> 8;
402 if (vard <= 64 || vard < varc)
416 if(score2 < score && score2 < iscore)
421 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
422 memcpy(pbbak, i_buffer, i_len);
426 set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0,
BLOCK_INTRA);
430 memcpy(pbbak, p_buffer, p_len);
434 set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
443 const int index= (x + y*w) << rem_depth;
444 int trx= (x+1)<<rem_depth;
449 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->
block[index-w+(1<<rem_depth)] : tl;
450 int pl = left->
color[0];
451 int pcb= left->
color[1];
452 int pcr= left->
color[2];
460 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
477 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
484 set_blocks(s, level, x, y, b->
color[0], b->
color[1], b->
color[2], pmx, pmy, 0,
BLOCK_INTRA);
486 pred_mv(s, &pmx, &pmy, b->
ref, left, top, tr);
492 set_blocks(s, level, x, y, pl, pcb, pcr, b->
mx, b->
my, b->
ref, 0);
500 const int block_w = plane_index ? block_size>>s->
chroma_h_shift : block_size;
501 const int block_h = plane_index ? block_size>>s->
chroma_v_shift : block_size;
503 const int obmc_stride= plane_index ? (2*block_size)>>s->
chroma_h_shift : 2*block_size;
505 uint8_t *
src= s-> input_picture->data[plane_index];
508 const int w= p->
width;
510 int index= mb_x + mb_y*b_stride;
519 b->
color[plane_index]= 0;
520 memset(dst, 0, obmc_stride*obmc_stride*
sizeof(
IDWTELEM));
523 int mb_x2= mb_x + (i &1) - 1;
524 int mb_y2= mb_y + (i>>1) - 1;
525 int x= block_w*mb_x2 + block_w/2;
526 int y= block_h*mb_y2 + block_h/2;
529 x, y, block_w, block_h, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
531 for(y2=
FFMAX(y, 0); y2<
FFMIN(h, y+block_h); y2++){
532 for(x2=
FFMAX(x, 0); x2<
FFMIN(w, x+block_w); x2++){
533 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;
534 int obmc_v= obmc[
index];
536 if(y<0) obmc_v += obmc[index + block_h*obmc_stride];
537 if(x<0) obmc_v += obmc[index + block_w];
538 if(y+block_h>h) obmc_v += obmc[index - block_h*obmc_stride];
539 if(x+block_w>w) obmc_v += obmc[index - block_w];
544 ab += (
src[x2 + y2*ref_stride] - (d>>
FRAC_BITS)) * obmc_v;
545 aa += obmc_v * obmc_v;
557 int index= x + y*b_stride;
561 const BlockNode *tl = y && x ? &s->
block[index-b_stride-1] : left;
562 const BlockNode *tr = y && x+w<b_stride ? &s->
block[index-b_stride+w] : tl;
567 if(x<0 || x>=b_stride || y>=b_height)
583 pred_mv(s, &dmx, &dmy, b->
ref, left, top, tr);
595 const int block_w = plane_index ? block_size>>s->
chroma_h_shift : block_size;
596 const int block_h = plane_index ? block_size>>s->
chroma_v_shift : block_size;
597 const int obmc_stride= plane_index ? (2*block_size)>>s->
chroma_h_shift : 2*block_size;
600 uint8_t *
src= s-> input_picture->data[plane_index];
606 const int w= p->
width;
611 int sx= block_w*mb_x - block_w/2;
612 int sy= block_h*mb_y - block_h/2;
613 int x0=
FFMAX(0,-sx);
614 int y0=
FFMAX(0,-sy);
615 int x1=
FFMIN(block_w*2, w-sx);
616 int y1=
FFMIN(block_h*2, h-sy);
621 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);
623 for(y=y0; y<y1; y++){
624 const uint8_t *obmc1= obmc_edged[
y];
626 uint8_t *cur1 = cur + y*ref_stride;
627 uint8_t *dst1 = dst + sx + (sy+
y)*ref_stride;
628 for(x=x0; x<x1; x++){
629 #if FRAC_BITS >= LOG2_OBMC_MAX
635 if(v&(~255)) v= ~(v>>31);
642 && (mb_x == 0 || mb_x == b_stride-1)
643 && (mb_y == 0 || mb_y == b_height-1)){
653 memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
664 distortion =
ff_w97_32_c(&s->
m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
666 distortion =
ff_w53_32_c(&s->
m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
670 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
671 distortion += s->
mecc.
me_cmp[0](&s->
m,
src + off, dst + off, ref_stride, 16);
676 distortion = s->
mecc.
me_cmp[0](&s->
m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
685 rate +=
get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
687 if(mb_x == b_stride-2)
690 return distortion + rate*penalty_factor;
697 const int block_w = plane_index ? block_size>>s->
chroma_h_shift : block_size;
698 const int block_h = plane_index ? block_size>>s->
chroma_v_shift : block_size;
700 const int obmc_stride= plane_index ? (2*block_size)>>s->
chroma_h_shift : 2*block_size;
703 uint8_t *
src= s-> input_picture->data[plane_index];
708 const int w= p->
width;
717 int mb_x2= mb_x + (i%3) - 1;
718 int mb_y2= mb_y + (i/3) - 1;
719 int x= block_w*mb_x2 + block_w/2;
720 int y= block_h*mb_y2 + block_h/2;
723 x, y, block_w, block_h, w, h, 0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
726 for(y2= y; y2<0; y2++)
727 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, block_w);
728 for(y2= h; y2<y+block_h; y2++)
729 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, block_w);
731 for(y2= y; y2<y+block_h; y2++)
732 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, -x);
735 for(y2= y; y2<y+block_h; y2++)
736 memcpy(dst + w + y2*ref_stride,
src + w + y2*ref_stride, x+block_w - w);
740 distortion += s->
mecc.
me_cmp[block_w==8](&s->
m,
src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
754 for(i=merged?4:0; i<9; i++){
755 static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
759 return distortion + rate*penalty_factor;
763 const int w= b->
width;
776 int l=0, lt=0, t=0, rt=0;
780 t= src[x + (y-1)*stride];
782 lt= src[x - 1 + (y-1)*stride];
785 rt= src[x + 1 + (y-1)*stride];
798 if(px<b->parent->width && py<b->parent->height)
799 p= parent[px + py*2*
stride];
803 runs[run_index++]=
run;
811 max_index= run_index;
812 runs[run_index++]=
run;
814 run= runs[run_index++];
817 if(run_index <= max_index)
827 int l=0, lt=0, t=0, rt=0;
831 t= src[x + (y-1)*stride];
833 lt= src[x - 1 + (y-1)*stride];
836 rt= src[x + 1 + (y-1)*stride];
849 if(px<b->parent->width && py<b->parent->height)
850 p= parent[px + py*2*
stride];
858 run= runs[run_index++];
860 if(run_index <= max_index)
870 int l2= 2*
FFABS(l) + (l<0);
900 block->
color[0] = p[0];
901 block->
color[1] = p[1];
902 block->
color[2] = p[2];
932 return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
945 backup[0] = block[0];
946 backup[1] = block[1];
947 backup[2] = block[b_stride];
948 backup[3] = block[b_stride + 1];
964 block[1]= block[b_stride]= block[b_stride+1]= *
block;
975 block[b_stride]= backup[2];
976 block[b_stride+1]= backup[3];
982 int pass, mb_x, mb_y;
985 const int b_stride= b_width;
992 for(mb_y= 0; mb_y<s->
b_height; mb_y++)
993 for(mb_x= 0; mb_x<s->
b_width; mb_x++)
999 for(pass=0; pass<25; pass++){
1002 for(mb_y= 0; mb_y<b_height; mb_y++){
1003 for(mb_x= 0; mb_x<b_width; mb_x++){
1004 int dia_change, i, j, ref;
1005 int best_rd= INT_MAX, ref_rd;
1007 const int index= mb_x + mb_y * b_stride;
1016 BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->
block[index+b_stride+1] :
NULL;
1033 for (y = 0; y < b_w * 2; y++)
1036 for(y=0; y<b_w*2; y++)
1037 memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1038 if(mb_x==b_stride-1)
1039 for(y=0; y<b_w*2; y++)
1040 memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1042 for(x=0; x<b_w*2; x++)
1043 obmc_edged[0][x] += obmc_edged[b_w-1][x];
1044 for(y=1; y<b_w; y++)
1045 memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1047 if(mb_y==b_height-1){
1048 for(x=0; x<b_w*2; x++)
1049 obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
1050 for(y=b_w; y<b_w*2-1; y++)
1051 memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1056 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
1062 const int sx= block_w*mb_x - block_w/2;
1063 const int sy= block_h*mb_y - block_h/2;
1069 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1070 for(y=h; y<sy+block_h*2; y++)
1071 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1073 for(y=sy; y<sy+block_h*2; y++)
1074 memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
1076 if(sx+block_w*2 > w){
1077 for(y=sy; y<sy+block_h*2; y++)
1078 memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
1084 color[i]=
get_dc(s, mb_x, mb_y, i);
1089 check_block(s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);
1105 check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1111 check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1119 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx+4*(i-j), block->
my+(4*j), obmc_edged, &best_rd);
1120 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx-4*(i-j), block->
my-(4*j), obmc_edged, &best_rd);
1121 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx+4*(i-j), block->
my-(4*j), obmc_edged, &best_rd);
1122 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx-4*(i-j), block->
my+(4*j), obmc_edged, &best_rd);
1128 static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1131 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx+square[i][0], block->
my+square[i][1], obmc_edged, &best_rd);
1135 mvr[0][0]= block->
mx;
1136 mvr[0][1]= block->
my;
1137 if(ref_rd > best_rd){
1144 check_block(s, mb_x, mb_y, color, 1, obmc_edged, &best_rd);
1166 for(mb_y= 0; mb_y<b_height; mb_y+=2){
1167 for(mb_x= 0; mb_x<b_width; mb_x+=2){
1169 int best_rd, init_rd;
1170 const int index= mb_x + mb_y * b_stride;
1175 b[2]= b[0]+b_stride;
1190 (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,
1191 (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);
1197 if(init_rd != best_rd)
1228 const int w= b->
width;
1232 int x,
y, thres1, thres2;
1237 dst[x + y*stride]= src[x + y*stride];
1241 bias= bias ? 0 : (3*qmul)>>3;
1248 int i= src[x + y*
stride];
1250 if((
unsigned)(i+thres1) > thres2){
1268 int i= src[x + y*
stride];
1270 if((
unsigned)(i+thres1) > thres2){
1273 i= (i + bias) / qmul;
1278 i= (i + bias) / qmul;
1289 const int w= b->
width;
1300 int i= src[x + y*
stride];
1311 const int w= b->
width;
1315 for(y=h-1; y>=0; y--){
1316 for(x=w-1; x>=0; x--){
1321 if(y && x+1<w) src[i] -=
mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1322 else src[i] -= src[i - 1];
1324 if(y) src[i] -=
mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1325 else src[i] -= src[i - 1];
1328 if(y) src[i] -= src[i -
stride];
1335 const int w= b->
width;
1345 if(y && x+1<w) src[i] +=
mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1346 else src[i] += src[i - 1];
1348 if(y) src[i] +=
mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1349 else src[i] += src[i - 1];
1352 if(y) src[i] += src[i -
stride];
1359 int plane_index,
level, orientation;
1361 for(plane_index=0; plane_index<
FFMIN(s->
nb_planes, 2); plane_index++){
1363 for(orientation=level ? 1:0; orientation<4; orientation++){
1364 if(orientation==2)
continue;
1375 memset(kstate,
MID_STATE,
sizeof(kstate));
1385 for(plane_index=0; plane_index<2; plane_index++){
1412 for(plane_index=0; plane_index<
FFMIN(s->
nb_planes, 2); plane_index++){
1420 for(plane_index=0; plane_index<
FFMIN(s->
nb_planes, 2); plane_index++){
1424 for(i= p->
htaps/2; i; i--)
1448 for(plane_index=0; plane_index<2; plane_index++){
1474 uint32_t coef_sum= 0;
1475 int level, orientation, delta_qlog;
1478 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1481 const int w= b->
width;
1483 const int stride= b->
stride;
1486 const int qdiv= (1<<16)/qmul;
1491 buf[x+y*stride]= b->
buf[x+y*stride];
1496 coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
1502 coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1517 s->
qlog+= delta_qlog;
1524 int level, orientation, x,
y;
1527 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1536 for(x=0; x<
width; x++){
1542 b->
qlog= (int)(log(352256.0/sqrt(error)) / log(pow(2.0, 1.0/
QROOT))+0.5);
1548 const AVFrame *pict,
int *got_packet)
1555 int level, orientation, plane_index, i,
y,
ret;
1568 for(y=0; y<(height>>vshift); y++)
1573 width >> hshift, height >> vshift,
1631 int block_width = (width +15)>>4;
1632 int block_height= (height+15)>>4;
1641 s->
m. last_picture_ptr= &s->
m. last_picture;
1695 for(plane_index=0; plane_index < s->
nb_planes; plane_index++){
1705 for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1714 if(pict->
data[plane_index])
1752 if (delta_qlog <= INT_MIN)
1765 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1780 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1802 pict->
data[plane_index][y*pict->
linesize[plane_index] + x];
1813 if(pict->
data[plane_index])
1873 #define OFFSET(x) offsetof(SnowContext, x)
1874 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1877 {
"memc_only",
"Only do ME/MC (I frames -> ref, P frame -> ME+MC).",
OFFSET(memc_only),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1,
VE },
1878 {
"no_bitstream",
"Skip final bitstream writeout.",
OFFSET(no_bitstream),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1,
VE },
1929 fprintf(stderr,
"Failed to allocate memory\n");
1935 printf(
"testing 5/3 DWT\n");
1937 buffer[0][i] = buffer[1][i] =
av_lfg_get(&prng) % 54321 - 12345;
1943 if(buffer[0][i]!= buffer[1][i]) printf(
"fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
1945 printf(
"testing 9/7 DWT\n");
1948 buffer[0][i] = buffer[1][i] =
av_lfg_get(&prng) % 54321 - 12345;
1954 if(
FFABS(buffer[0][i] - buffer[1][i])>20) printf(
"fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
1957 int level, orientation, x,
y;
1958 int64_t errors[8][4];
1961 memset(errors, 0,
sizeof(errors));
1965 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1972 if(orientation&1) buf+=w;
1973 if(orientation>1) buf+=stride>>1;
1975 memset(buffer[0], 0,
sizeof(
int)*
width*height);
1976 buf[w/2 + h/2*
stride]= 256*256;
1979 for(x=0; x<
width; x++){
1980 int64_t d= buffer[0][x + y*
width];
1982 if(
FFABS(width/2-x)<9 &&
FFABS(height/2-y)<9 && level==2) printf(
"%8"PRId64
" ", d);
1984 if(
FFABS(height/2-y)<9 && level==2) printf(
"\n");
1986 error= (int)(sqrt(error)+0.5);
1987 errors[
level][orientation]= error;
1988 if(g) g=
av_gcd(g, error);
1992 printf(
"static int const visual_weight[][4]={\n");
1995 for(orientation=0; orientation<4; orientation++){
1996 printf(
"%8"PRId64
",", errors[level][orientation]/g);
2012 memset(buffer[0], 0,
sizeof(
int)*width*height);
2014 for(x=0; x<
width; x++){
2015 int tab[4]={0,2,3,1};
2016 buffer[0][x+width*
y]= 256*256*tab[(x&1) + 2*(y&1)];
2021 for(x=0; x<
width; x++){
2022 int64_t d= buffer[0][x + y*
width];
2024 if(
FFABS(width/2-x)<9 &&
FFABS(height/2-y)<9) printf(
"%8"PRId64
" ", d);
2026 if(
FFABS(height/2-y)<9) printf(
"\n");
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free
static const AVClass snowenc_class
static av_cold int encode_end(AVCodecContext *avctx)
int frame_bits
bits used for the current frame
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
int ff_snow_frame_start(SnowContext *s)
av_cold void ff_rate_control_uninit(MpegEncContext *s)
int last_spatial_decomposition_count
static int shift(int a, int b)
This structure describes decoded (raw) audio or video data.
int skip
set if ME is skipped for the current MB
static double rint(double x)
uint64_t error[AV_NUM_DATA_POINTERS]
error
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define LIBAVUTIL_VERSION_INT
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
void ff_h263_encode_init(MpegEncContext *s)
AVFrame * coded_frame
the picture in the bitstream
static av_cold int init(AVCodecContext *avctx)
uint8_t * current_mv_penalty
#define FF_MPV_COMMON_OPTS
const AVFrame * new_picture
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
uint32_t * score_map
map to store the scores
int8_t last_hcoeff[HTAPS_MAX/2]
int ff_snow_common_init_after_header(AVCodecContext *avctx)
static void update_last_header_values(SnowContext *s)
void ff_snow_reset_contexts(SnowContext *s)
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)
#define CODEC_FLAG_QPEL
Use qpel MC.
int scenechange_threshold
scene change detection threshold 0 is default, larger means fewer detected scene changes.
uint32_t ff_square_tab[512]
static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
int qlog
log(qscale)/log[2^(1/6)]
int ff_rac_terminate(RangeCoder *c)
static int get_penalty_factor(int lambda, int lambda2, int type)
#define CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static double cb(void *priv, double x, double y)
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
enum OutputFormat out_format
output format
uint32_t * ref_scores[MAX_REF_FRAMES]
Motion estimation context.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
int misc_bits
cbp, mb_type
int me_cmp
motion estimation comparison function
Picture current_picture
copy of the current picture structure.
#define ENCODER_EXTRA_BITS
static void calculate_visual_weight(SnowContext *s, Plane *p)
uint8_t(* mv_penalty)[MAX_MV *2+1]
amount of bits needed to encode a MV
int ff_w97_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
static const BlockNode null_block
static void encode_blocks(SnowContext *s, int search)
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)
int mb_height
number of MBs horizontally & vertically
void ff_snow_release_buffer(AVCodecContext *avctx)
char * stats_out
pass1 encoding statistics output buffer
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
#define ROUNDED_DIV(a, b)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
MpegvideoEncDSPContext mpvencdsp
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int ff_get_mb_score(MpegEncContext *s, int mx, int my, int src_index, int ref_index, int size, int h, int add_rate)
int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]
unsigned me_cache_generation
av_cold int ff_rate_control_init(MpegEncContext *s)
int me_sub_cmp
subpixel motion estimation comparison function
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
void ff_write_pass1_stats(MpegEncContext *s)
int unrestricted_mv
mv can point outside of the coded picture
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
const uint8_t *const ff_obmc_tab[4]
static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index)
#define CODEC_FLAG_QSCALE
Use fixed qscale.
int64_t av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
const char * name
Name of the codec implementation.
static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
int quarter_sample
1->qpel, 0->half pel ME/MC
Libavcodec external API header.
uint8_t * emu_edge_buffer
int flags
A combination of AV_PKT_FLAG values.
int refs
number of reference frames
int bit_rate
the average bitrate
const int8_t ff_quant3bA[256]
enum AVPictureType pict_type
Picture type of the frame.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
int display_picture_number
picture number in display order
#define FF_MIN_BUFFER_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
int me_method
ME algorithm.
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)
int width
picture width / height.
GLsizei GLboolean const GLfloat * value
Picture * current_picture_ptr
pointer to the current picture
static int encode_q_branch(SnowContext *s, int level, int x, int y)
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
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 ff_build_rac_states(RangeCoder *c, int factor, int max_p)
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
void avcodec_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.
int penalty_factor
an estimate of the bits required to code a given mv value, e.g.
static const float pred[4]
SubBand band[MAX_DWT_LEVELS][4]
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
uint8_t block_state[128+32 *128]
int coded_picture_number
picture number in bitstream order
uint64_t error[AV_NUM_DATA_POINTERS]
error
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
static void encode_header(SnowContext *s)
ptrdiff_t linesize
line size, in bytes, may be different from width
int spatial_decomposition_count
static av_const unsigned int ff_sqrt(unsigned int a)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
int frame_bits
number of bits used for the previously encoded frame
main external API structure.
int8_t hcoeff[HTAPS_MAX/2]
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)
int height
picture size. must be a multiple of 16
int ff_snow_alloc_blocks(SnowContext *s)
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
static int get_rac_count(RangeCoder *c)
static void encode_q_branch2(SnowContext *s, int level, int x, int y)
unsigned me_cache[ME_CACHE_SIZE]
BYTE int const BYTE int int int height
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Describe the class of an AVClass context structure.
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
int64_t mc_mb_var_sum
motion compensated MB variance for current frame
static int get_block_bits(SnowContext *s, int x, int y, int w)
void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
int ff_w53_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
DWTELEM * temp_dwt_buffer
int f_code
forward MV resolution
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
int bit_rate
wanted bit rate
static int qscale2qlog(int qscale)
static int pix_sum(uint8_t *pix, int line_size, int w, int h)
int ff_snow_common_init(AVCodecContext *avctx)
static void encode_qlogs(SnowContext *s)
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int global_quality
Global quality for codecs which cannot change it per frame.
int ff_init_me(MpegEncContext *s)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int spatial_decomposition_type
AVFrame * current_picture
static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t(*obmc_edged)[MB_SIZE *2])
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
struct AVCodecContext * avctx
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index)
#define CODEC_FLAG_EMU_EDGE
GLint GLenum GLboolean GLsizei stride
int mb_cmp
macroblock comparison function (not supported yet)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
int temporal_decomposition_type
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
IDWTELEM * temp_idwt_buffer
void ff_spatial_dwt(DWTELEM *buffer, DWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
uint8_t * obmc_scratchpad
int prediction_method
prediction method (needed for huffyuv)
DWTELEM * spatial_dwt_buffer
static av_cold int encode_init(AVCodecContext *avctx)
me_cmp_func me_sub_cmp[6]
static const AVOption options[]
uint32_t * map
map to avoid duplicate evaluations
IDWTELEM * spatial_idwt_buffer
uint8_t * bytestream_start
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 void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride)
int dia_size
ME diamond size & shape.
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
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 key_frame
1 -> keyframe, 0-> not
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
static const struct twinvq_data tab
av_cold void ff_snow_common_end(SnowContext *s)
static void * av_mallocz_array(size_t nmemb, size_t size)
int frame_number
Frame counter, set by libavcodec.
int flags
AVCodecContext.flags (HQ, MV4, ...)
static uint32_t inverse(uint32_t v)
find multiplicative inverse modulo 2 ^ 32
int me_method
Motion estimation algorithm used for video coding.
int main(int argc, char **argv)
static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
AVFrame * last_picture[MAX_REF_FRAMES]
static double cr(void *priv, double x, double y)
AVFrame * input_picture
new_picture with the internal linesizes
#define CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
static int pix_norm1(uint8_t *pix, int line_size, int w)
int temporal_decomposition_count
int64_t mb_var_sum
sum of MB variance for current frame
AVPixelFormat
Pixel format.
This structure stores compressed data.
static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
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)
static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias)
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
int last_spatial_decomposition_type
unsigned int lambda
lagrange multipler used in rate distortion
static void iterative_me(SnowContext *s)
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)