22 #include "libavutil/log.h"
23 #include "libavutil/opt.h"
42 av_log(avctx,
AV_LOG_ERROR,
"This codec is under development, files encoded with it may not be decodable with future versions!!!\n"
43 "Use vstrict=-2 / -strict -2 to use it anyway.\n");
59 for(plane_index=0; plane_index<3; plane_index++){
156 for (i = 0; i < h; i++) {
157 for (j = 0; j < w; j++) {
161 pix += line_size - w;
173 for (i = 0; i < w; i++) {
174 for (j = 0; j < w; j ++) {
178 pix += line_size - w;
189 return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
210 #define P_TOPRIGHT P[3]
211 #define P_MEDIAN P[4]
213 #define FLAG_QPEL 1 //must be 1
223 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
227 const int index= (x + y*w) << rem_depth;
229 int trx= (x+1)<<rem_depth;
230 int try= (y+1)<<rem_depth;
236 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->
block[index-w+(1<<rem_depth)] : tl;
237 int pl = left->
color[0];
238 int pcb= left->
color[1];
239 int pcr= left->
color[2];
249 int16_t last_mv[3][2];
251 const int shift= 1+qpel;
257 int ref, best_ref, ref_score, ref_mx, ref_my;
261 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
276 last_mv[1][0]= right->
mx;
277 last_mv[1][1]= right->
my;
278 last_mv[2][0]= bottom->
mx;
279 last_mv[2][1]= bottom->
my;
294 c->
xmin = - x*block_w - 16+3;
295 c->
ymin = - y*block_w - 16+3;
339 if(score > ref_score){
352 pc.bytestream= p_buffer;
356 put_rac(&pc, &p_state[4 + s_context], 1);
359 put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
360 pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
361 put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
362 put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
363 p_len= pc.bytestream - pc.bytestream_start;
366 block_s= block_w*block_w;
367 sum =
pix_sum(current_data[0], stride, block_w, block_w);
368 l= (sum + block_s/2)/block_s;
369 iscore =
pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
374 cb= (sum + block_s/2)/block_s;
377 cr= (sum + block_s/2)/block_s;
384 ic.bytestream= i_buffer;
387 put_rac(&ic, &i_state[4 + s_context], 1);
394 i_len= ic.bytestream - ic.bytestream_start;
398 av_assert1(iscore < 255*255*256 + s->lambda2*10);
404 int varc= iscore >> 8;
405 int vard= score >> 8;
406 if (vard <= 64 || vard < varc)
420 if(score2 < score && score2 < iscore)
425 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
426 memcpy(pbbak, i_buffer, i_len);
430 set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0,
BLOCK_INTRA);
434 memcpy(pbbak, p_buffer, p_len);
438 set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
447 const int index= (x + y*w) << rem_depth;
448 int trx= (x+1)<<rem_depth;
453 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->
block[index-w+(1<<rem_depth)] : tl;
454 int pl = left->
color[0];
455 int pcb= left->
color[1];
456 int pcr= left->
color[2];
464 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
481 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
488 set_blocks(s, level, x, y, b->
color[0], b->
color[1], b->
color[2], pmx, pmy, 0,
BLOCK_INTRA);
490 pred_mv(s, &pmx, &pmy, b->
ref, left, top, tr);
496 set_blocks(s, level, x, y, pl, pcb, pcr, b->
mx, b->
my, b->
ref, 0);
504 const int block_w = plane_index ? block_size>>s->
chroma_h_shift : block_size;
505 const int block_h = plane_index ? block_size>>s->
chroma_v_shift : block_size;
507 const int obmc_stride= plane_index ? (2*block_size)>>s->
chroma_h_shift : 2*block_size;
509 uint8_t *
src= s-> input_picture->data[plane_index];
512 const int w= p->
width;
514 int index= mb_x + mb_y*b_stride;
523 b->
color[plane_index]= 0;
524 memset(dst, 0, obmc_stride*obmc_stride*
sizeof(
IDWTELEM));
527 int mb_x2= mb_x + (i &1) - 1;
528 int mb_y2= mb_y + (i>>1) - 1;
529 int x= block_w*mb_x2 + block_w/2;
530 int y= block_h*mb_y2 + block_h/2;
532 add_yblock(s, 0, NULL, dst + (i&1)*block_w + (i>>1)*obmc_stride*block_h, NULL, obmc,
533 x, y, block_w, block_h, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
535 for(y2=
FFMAX(y, 0); y2<
FFMIN(h, y+block_h); y2++){
536 for(x2=
FFMAX(x, 0); x2<
FFMIN(w, x+block_w); x2++){
537 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;
538 int obmc_v= obmc[
index];
540 if(y<0) obmc_v += obmc[index + block_h*obmc_stride];
541 if(x<0) obmc_v += obmc[index + block_w];
542 if(y+block_h>h) obmc_v += obmc[index - block_h*obmc_stride];
543 if(x+block_w>w) obmc_v += obmc[index - block_w];
548 ab += (
src[x2 + y2*ref_stride] - (d>>
FRAC_BITS)) * obmc_v;
549 aa += obmc_v * obmc_v;
561 int index= x + y*b_stride;
565 const BlockNode *tl = y && x ? &s->
block[index-b_stride-1] : left;
566 const BlockNode *tr = y && x+w<b_stride ? &s->
block[index-b_stride+w] : tl;
571 if(x<0 || x>=b_stride || y>=b_height)
587 pred_mv(s, &dmx, &dmy, b->
ref, left, top, tr);
599 const int block_w = plane_index ? block_size>>s->
chroma_h_shift : block_size;
600 const int block_h = plane_index ? block_size>>s->
chroma_v_shift : block_size;
601 const int obmc_stride= plane_index ? (2*block_size)>>s->
chroma_h_shift : 2*block_size;
604 uint8_t *
src= s-> input_picture->data[plane_index];
610 const int w= p->
width;
615 int sx= block_w*mb_x - block_w/2;
616 int sy= block_h*mb_y - block_h/2;
617 int x0=
FFMAX(0,-sx);
618 int y0=
FFMAX(0,-sy);
619 int x1=
FFMIN(block_w*2, w-sx);
620 int y1=
FFMIN(block_h*2, h-sy);
625 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);
627 for(y=y0; y<y1; y++){
628 const uint8_t *obmc1= obmc_edged[
y];
630 uint8_t *cur1 = cur + y*ref_stride;
631 uint8_t *dst1 = dst + sx + (sy+
y)*ref_stride;
632 for(x=x0; x<x1; x++){
633 #if FRAC_BITS >= LOG2_OBMC_MAX
639 if(v&(~255)) v= ~(v>>31);
646 && (mb_x == 0 || mb_x == b_stride-1)
647 && (mb_y == 0 || mb_y == b_height-1)){
657 memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
668 distortion =
ff_w97_32_c(&s->
m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
670 distortion =
ff_w53_32_c(&s->
m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
674 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
680 distortion = s->
dsp.
me_cmp[0](&s->
m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
689 rate +=
get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
691 if(mb_x == b_stride-2)
694 return distortion + rate*penalty_factor;
701 const int block_w = plane_index ? block_size>>s->
chroma_h_shift : block_size;
702 const int block_h = plane_index ? block_size>>s->
chroma_v_shift : block_size;
704 const int obmc_stride= plane_index ? (2*block_size)>>s->
chroma_h_shift : 2*block_size;
707 uint8_t *
src= s-> input_picture->data[plane_index];
712 const int w= p->
width;
721 int mb_x2= mb_x + (i%3) - 1;
722 int mb_y2= mb_y + (i/3) - 1;
723 int x= block_w*mb_x2 + block_w/2;
724 int y= block_h*mb_y2 + block_h/2;
727 x, y, block_w, block_h, w, h, 0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
730 for(y2= y; y2<0; y2++)
731 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, block_w);
732 for(y2= h; y2<y+block_h; y2++)
733 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, block_w);
735 for(y2= y; y2<y+block_h; y2++)
736 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, -x);
739 for(y2= y; y2<y+block_h; y2++)
740 memcpy(dst + w + y2*ref_stride,
src + w + y2*ref_stride, x+block_w - w);
744 distortion += s->
dsp.
me_cmp[block_w==8](&s->
m,
src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
758 for(i=merged?4:0; i<9; i++){
759 static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
763 return distortion + rate*penalty_factor;
767 const int w= b->
width;
780 int l=0, lt=0,
t=0, rt=0;
784 t= src[x + (y-1)*stride];
786 lt= src[x - 1 + (y-1)*stride];
789 rt= src[x + 1 + (y-1)*stride];
802 if(px<b->parent->width && py<b->parent->height)
803 p= parent[px + py*2*
stride];
807 runs[run_index++]=
run;
815 max_index= run_index;
816 runs[run_index++]=
run;
818 run= runs[run_index++];
821 if(run_index <= max_index)
831 int l=0, lt=0,
t=0, rt=0;
835 t= src[x + (y-1)*stride];
837 lt= src[x - 1 + (y-1)*stride];
840 rt= src[x + 1 + (y-1)*stride];
853 if(px<b->parent->width && py<b->parent->height)
854 p= parent[px + py*2*
stride];
862 run= runs[run_index++];
864 if(run_index <= max_index)
874 int l2= 2*
FFABS(l) + (l<0);
904 block->
color[0] = p[0];
905 block->
color[1] = p[1];
906 block->
color[2] = p[2];
936 return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
949 backup[0] = block[0];
950 backup[1] = block[1];
951 backup[2] = block[b_stride];
952 backup[3] = block[b_stride + 1];
968 block[1]= block[b_stride]= block[b_stride+1]= *
block;
979 block[b_stride]= backup[2];
980 block[b_stride+1]= backup[3];
986 int pass, mb_x, mb_y;
989 const int b_stride= b_width;
996 for(mb_y= 0; mb_y<s->
b_height; mb_y++)
997 for(mb_x= 0; mb_x<s->
b_width; mb_x++)
1003 for(pass=0; pass<25; pass++){
1006 for(mb_y= 0; mb_y<b_height; mb_y++){
1007 for(mb_x= 0; mb_x<b_width; mb_x++){
1008 int dia_change, i, j, ref;
1009 int best_rd= INT_MAX, ref_rd;
1011 const int index= mb_x + mb_y * b_stride;
1016 BlockNode *bb = mb_y+1<b_height ? &s->
block[index+b_stride ] : NULL;
1017 BlockNode *tlb= mb_x && mb_y ? &s->
block[index-b_stride-1] : NULL;
1018 BlockNode *trb= mb_x+1<b_width && mb_y ? &s->
block[index-b_stride+1] : NULL;
1019 BlockNode *blb= mb_x && mb_y+1<b_height ? &s->
block[index+b_stride-1] : NULL;
1020 BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->
block[index+b_stride+1] : NULL;
1037 for (y = 0; y < b_w * 2; y++)
1040 for(y=0; y<b_w*2; y++)
1041 memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1042 if(mb_x==b_stride-1)
1043 for(y=0; y<b_w*2; y++)
1044 memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1046 for(x=0; x<b_w*2; x++)
1047 obmc_edged[0][x] += obmc_edged[b_w-1][x];
1048 for(y=1; y<b_w; y++)
1049 memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1051 if(mb_y==b_height-1){
1052 for(x=0; x<b_w*2; x++)
1053 obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
1054 for(y=b_w; y<b_w*2-1; y++)
1055 memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1060 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
1066 const int sx= block_w*mb_x - block_w/2;
1067 const int sy= block_h*mb_y - block_h/2;
1073 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1074 for(y=h; y<sy+block_h*2; y++)
1075 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1077 for(y=sy; y<sy+block_h*2; y++)
1078 memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
1080 if(sx+block_w*2 > w){
1081 for(y=sy; y<sy+block_h*2; y++)
1082 memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
1088 color[i]=
get_dc(s, mb_x, mb_y, i);
1093 check_block(s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);
1109 check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1115 check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1123 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx+4*(i-j), block->
my+(4*j), obmc_edged, &best_rd);
1124 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx-4*(i-j), block->
my-(4*j), obmc_edged, &best_rd);
1125 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx+4*(i-j), block->
my-(4*j), obmc_edged, &best_rd);
1126 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx-4*(i-j), block->
my+(4*j), obmc_edged, &best_rd);
1132 static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1135 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx+square[i][0], block->
my+square[i][1], obmc_edged, &best_rd);
1139 mvr[0][0]= block->
mx;
1140 mvr[0][1]= block->
my;
1141 if(ref_rd > best_rd){
1148 check_block(s, mb_x, mb_y, color, 1, obmc_edged, &best_rd);
1170 for(mb_y= 0; mb_y<b_height; mb_y+=2){
1171 for(mb_x= 0; mb_x<b_width; mb_x+=2){
1173 int best_rd, init_rd;
1174 const int index= mb_x + mb_y * b_stride;
1179 b[2]= b[0]+b_stride;
1194 (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,
1195 (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);
1201 if(init_rd != best_rd)
1232 const int w= b->
width;
1241 dst[x + y*stride]= src[x + y*stride];
1245 bias= bias ? 0 : (3*qmul)>>3;
1252 int i= src[x + y*
stride];
1254 if((
unsigned)(i+thres1) > thres2){
1272 int i= src[x + y*
stride];
1274 if((
unsigned)(i+thres1) > thres2){
1277 i= (i + bias) / qmul;
1282 i= (i + bias) / qmul;
1293 const int w= b->
width;
1304 int i= src[x + y*
stride];
1315 const int w= b->
width;
1319 for(y=h-1; y>=0; y--){
1320 for(x=w-1; x>=0; x--){
1325 if(y && x+1<w) src[i] -=
mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1326 else src[i] -= src[i - 1];
1328 if(y) src[i] -=
mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1329 else src[i] -= src[i - 1];
1332 if(y) src[i] -= src[i -
stride];
1339 const int w= b->
width;
1349 if(y && x+1<w) src[i] +=
mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1350 else src[i] += src[i - 1];
1352 if(y) src[i] +=
mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1353 else src[i] += src[i - 1];
1356 if(y) src[i] += src[i -
stride];
1363 int plane_index,
level, orientation;
1365 for(plane_index=0; plane_index<
FFMIN(s->
nb_planes, 2); plane_index++){
1367 for(orientation=level ? 1:0; orientation<4; orientation++){
1368 if(orientation==2)
continue;
1379 memset(kstate,
MID_STATE,
sizeof(kstate));
1389 for(plane_index=0; plane_index<2; plane_index++){
1416 for(plane_index=0; plane_index<
FFMIN(s->
nb_planes, 2); plane_index++){
1424 for(plane_index=0; plane_index<
FFMIN(s->
nb_planes, 2); plane_index++){
1428 for(i= p->
htaps/2; i; i--)
1452 for(plane_index=0; plane_index<2; plane_index++){
1478 uint32_t coef_sum= 0;
1479 int level, orientation, delta_qlog;
1482 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1485 const int w= b->
width;
1487 const int stride= b->
stride;
1490 const int qdiv= (1<<16)/qmul;
1495 buf[x+y*stride]= b->
buf[x+y*stride];
1500 coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
1505 coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1521 s->
qlog+= delta_qlog;
1528 int level, orientation, x,
y;
1531 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1540 for(x=0; x<
width; x++){
1546 b->
qlog= (int)(log(352256.0/sqrt(error)) / log(pow(2.0, 1.0/
QROOT))+0.5);
1552 AVFrame *pict,
int *got_packet)
1559 int level, orientation, plane_index, i,
y,
ret;
1572 for(y=0; y<(height>>vshift); y++)
1577 width >> hshift, height >> vshift,
1617 int block_width = (width +15)>>4;
1618 int block_height= (height+15)>>4;
1627 s->
m. new_picture.f.data[0] = s-> input_picture->data[0];
1628 s->
m. last_picture_ptr= &s->
m. last_picture;
1687 for(plane_index=0; plane_index < s->
nb_planes; plane_index++){
1697 for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1706 if(pict->
data[plane_index])
1744 if (delta_qlog <= INT_MIN)
1757 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1772 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1794 pict->
data[plane_index][y*pict->
linesize[plane_index] + x];
1805 if(pict->
data[plane_index])
1864 #define OFFSET(x) offsetof(SnowContext, x)
1865 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1867 {
"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 },
1868 {
"no_bitstream",
"Skip final bitstream writeout.",
OFFSET(no_bitstream),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1,
VE },
1902 #include "libavutil/lfg.h"
1903 #include "libavutil/mathematics.h"
1920 printf(
"testing 5/3 DWT\n");
1922 buffer[0][i] = buffer[1][i] =
av_lfg_get(&prng) % 54321 - 12345;
1928 if(buffer[0][i]!= buffer[1][i]) printf(
"fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
1930 printf(
"testing 9/7 DWT\n");
1933 buffer[0][i] = buffer[1][i] =
av_lfg_get(&prng) % 54321 - 12345;
1939 if(
FFABS(buffer[0][i] - buffer[1][i])>20) printf(
"fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
1942 int level, orientation, x,
y;
1943 int64_t errors[8][4];
1946 memset(errors, 0,
sizeof(errors));
1950 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1957 if(orientation&1) buf+=w;
1958 if(orientation>1) buf+=stride>>1;
1960 memset(buffer[0], 0,
sizeof(
int)*
width*height);
1961 buf[w/2 + h/2*
stride]= 256*256;
1964 for(x=0; x<
width; x++){
1965 int64_t d= buffer[0][x + y*
width];
1967 if(
FFABS(width/2-x)<9 &&
FFABS(height/2-y)<9 && level==2) printf(
"%8"PRId64
" ", d);
1969 if(
FFABS(height/2-y)<9 && level==2) printf(
"\n");
1971 error= (int)(sqrt(error)+0.5);
1972 errors[
level][orientation]= error;
1973 if(g) g=
av_gcd(g, error);
1977 printf(
"static int const visual_weight[][4]={\n");
1980 for(orientation=0; orientation<4; orientation++){
1981 printf(
"%8"PRId64
",", errors[level][orientation]/g);
1997 memset(buffer[0], 0,
sizeof(
int)*width*height);
1999 for(x=0; x<
width; x++){
2000 int tab[4]={0,2,3,1};
2001 buffer[0][x+width*
y]= 256*256*tab[(x&1) + 2*(y&1)];
2006 for(x=0; x<
width; x++){
2007 int64_t d= buffer[0][x + y*
width];
2009 if(
FFABS(width/2-x)<9 &&
FFABS(height/2-y)<9) printf(
"%8"PRId64
" ", d);
2011 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)
av_cold int ff_snow_common_init(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)
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
#define LIBAVUTIL_VERSION_INT
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
void ff_h263_encode_init(MpegEncContext *s)
static av_cold int init(AVCodecContext *avctx)
uint8_t * current_mv_penalty
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
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.
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.
static double cb(void *priv, double x, double y)
const char * av_default_item_name(void *ctx)
Return the context name.
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
enum OutputFormat out_format
output format
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
uint32_t * ref_scores[MAX_REF_FRAMES]
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Motion estimation context.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
int misc_bits
cbp, mb_type
const char * name
Name of the codec implementation.
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
void ff_set_cmp(DSPContext *c, me_cmp_func *cmp, int type)
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)
const OptionDef options[]
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
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 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. ...
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
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_const av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
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
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Libavcodec external API header.
AVPixelFormat
Pixel format.
uint8_t * emu_edge_buffer
int flags
A combination of AV_PKT_FLAG values.
int ff_w97_32_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
int refs
number of reference frames
uint32_t ff_squareTbl[512]
int bit_rate
the average bitrate
const int8_t ff_quant3bA[256]
enum AVPictureType pict_type
Picture type of the frame.
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.
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)
uint64_t error[AV_NUM_DATA_POINTERS]
error
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))
char * stats_out
pass1 encoding statistics output buffer
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.
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
int AC3_NAME() encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
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)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
uint8_t block_state[128+32 *128]
int coded_picture_number
picture number in bitstream order
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
static void encode_header(SnowContext *s)
void av_lfg_init(AVLFG *c, unsigned int seed)
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 frame_bits
number of bits used for the previously encoded frame
main external API structure.
int8_t hcoeff[HTAPS_MAX/2]
static void close(AVCodecParserContext *s)
int height
picture size. must be a multiple of 16
int ff_snow_alloc_blocks(SnowContext *s)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
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
Describe the class of an AVClass context structure.
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
int ff_w53_32_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
AVFrame * coded_frame
the picture in the bitstream
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
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
DSPContext dsp
pointers for accelerated dsp functions
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
DWTELEM * temp_dwt_buffer
uint64_t error[AV_NUM_DATA_POINTERS]
error
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)
#define ROUNDED_DIV(a, b)
static int pix_sum(uint8_t *pix, int line_size, int w, int h)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static void encode_qlogs(SnowContext *s)
int global_quality
Global quality for codecs which cannot change it per frame.
int ff_init_me(MpegEncContext *s)
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)
int mb_cmp
macroblock comparison function (not supported yet)
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)
Picture last_picture
copy of the previous picture structure.
uint8_t * obmc_scratchpad
int prediction_method
prediction method (needed for huffyuv)
DWTELEM * spatial_dwt_buffer
static av_cold int encode_init(AVCodecContext *avctx)
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, BlockNode *block, int plane_index, int w, int h)
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.
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 struct twinvq_data tab
av_cold void ff_snow_common_end(SnowContext *s)
int mb_var_sum
sum of MB variance for current frame
int frame_number
Frame counter, set by libavcodec.
int flags
AVCodecContext.flags (HQ, MV4, ...)
int mc_mb_var_sum
motion compensated MB variance for current frame
static int thres2[99][16]
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static uint32_t inverse(uint32_t v)
find multiplicative inverse modulo 2 ^ 32
int me_method
Motion estimation algorithm used for video coding.
me_cmp_func me_sub_cmp[6]
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
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)
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias)
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
int last_spatial_decomposition_type
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
unsigned int lambda
lagrange multipler used in rate distortion
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
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)