44 #if FF_API_PRIVATE_OPT 63 for(plane_index=0; plane_index<3; plane_index++){
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;
203 return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
224 #define P_TOPRIGHT P[3] 225 #define P_MEDIAN P[4] 227 #define FLAG_QPEL 1 //must be 1 237 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
241 const int index= (x + y*
w) << rem_depth;
243 int trx= (x+1)<<rem_depth;
244 int try= (y+1)<<rem_depth;
250 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->
block[index-w+(1<<rem_depth)] : tl;
251 int pl = left->
color[0];
252 int pcb= left->
color[1];
253 int pcr= left->
color[2];
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);
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;
308 c->
xmin = - x*block_w - 16+3;
309 c->
ymin = - y*block_w - 16+3;
353 if(score > ref_score){
366 pc.bytestream= p_buffer;
370 put_rac(&pc, &p_state[4 + s_context], 1);
373 put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
374 pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
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;
381 sum =
pix_sum(current_data[0], stride, 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;
388 cb= (sum + block_s/2)/block_s;
391 cr= (sum + block_s/2)/block_s;
398 ic.bytestream= i_buffer;
401 put_rac(&ic, &i_state[4 + s_context], 1);
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)
433 if(score2 < score && score2 < iscore)
438 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
439 memcpy(pbbak, i_buffer, i_len);
443 set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0,
BLOCK_INTRA);
447 memcpy(pbbak, p_buffer, p_len);
451 set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
460 const int index= (x + y*
w) << rem_depth;
461 int trx= (x+1)<<rem_depth;
466 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->
block[index-w+(1<<rem_depth)] : tl;
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);
494 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
501 set_blocks(s, level, x, y, b->
color[0], b->
color[1], b->
color[2], pmx, pmy, 0,
BLOCK_INTRA);
503 pred_mv(s, &pmx, &pmy, b->
ref, left, top, tr);
509 set_blocks(s, level, x, y, pl, pcb, pcr, b->
mx, b->
my, b->
ref, 0);
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;
522 uint8_t *
src= s-> input_picture->data[plane_index];
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++){
549 for(x2=
FFMAX(x, 0); x2<
FFMIN(w, x+block_w); x2++){
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;
574 int index= x + y*b_stride;
579 const BlockNode *tr = y && x+w<b_stride ? &s->
block[index-b_stride+
w] : tl;
584 if(x<0 || x>=b_stride || y>=b_height)
600 pred_mv(s, &dmx, &dmy, b->
ref, left, top, tr);
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;
617 uint8_t *
src= s-> input_picture->data[plane_index];
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);
702 rate +=
get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
704 if(mb_x == b_stride-2)
707 return distortion + rate*penalty_factor;
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;
720 uint8_t *
src= s-> input_picture->data[plane_index];
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;
793 int l=0, lt=0, t=0, rt=0;
797 t= src[x + (y-1)*stride];
799 lt= src[x - 1 + (y-1)*stride];
802 rt= src[x + 1 + (y-1)*stride];
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)
844 int l=0, lt=0, t=0, rt=0;
848 t= src[x + (y-1)*stride];
850 lt= src[x - 1 + (y-1)*stride];
853 rt= src[x + 1 + (y-1)*stride];
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);
917 block->
color[0] = p[0];
918 block->
color[1] = p[1];
919 block->
color[2] = p[2];
949 return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
962 backup[0] = block[0];
963 backup[1] = block[1];
964 backup[2] = block[b_stride];
965 backup[3] = block[b_stride + 1];
981 block[1]= block[b_stride]= block[b_stride+1]= *
block;
992 block[b_stride]= backup[2];
993 block[b_stride+1]= backup[3];
999 int pass, mb_x, mb_y;
1002 const int b_stride= b_width;
1009 for(mb_y= 0; mb_y<s->
b_height; mb_y++)
1010 for(mb_x= 0; mb_x<s->
b_width; mb_x++)
1016 for(pass=0; pass<25; pass++){
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;
1033 BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->
block[index+b_stride+1] :
NULL;
1050 for (y = 0; y < b_w * 2; y++)
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){
1079 const int sx= block_w*mb_x - block_w/2;
1080 const int sy= block_h*mb_y - block_h/2;
1086 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1087 for(y=h; y<sy+block_h*2; y++)
1088 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1090 for(y=sy; y<sy+block_h*2; y++)
1091 memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
1093 if(sx+block_w*2 > w){
1094 for(y=sy; y<sy+block_h*2; y++)
1095 memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
1101 color[i]=
get_dc(s, mb_x, mb_y, i);
1106 check_block(s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);
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;
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},};
1151 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx+square[i][0], block->
my+square[i][1], obmc_edged, &best_rd);
1155 mvr[0][0]= block->
mx;
1156 mvr[0][1]= block->
my;
1157 if(ref_rd > best_rd){
1164 check_block(s, mb_x, mb_y, color, 1, obmc_edged, &best_rd);
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;
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)
1252 int x,y, thres1, thres2;
1257 dst[x + y*stride]= src[x + y*stride];
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;
1335 for(y=h-1; y>=0; y--){
1336 for(x=w-1; x>=0; x--){
1341 if(y && x+1<w) src[
i] -=
mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1342 else src[
i] -= src[i - 1];
1344 if(y) src[
i] -=
mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1345 else src[
i] -= src[i - 1];
1348 if(y) src[
i] -= src[i -
stride];
1365 if(y && x+1<w) src[
i] +=
mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1366 else src[
i] += src[i - 1];
1368 if(y) src[
i] +=
mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1369 else src[
i] += src[i - 1];
1372 if(y) src[
i] += src[i -
stride];
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;
1395 memset(kstate,
MID_STATE,
sizeof(kstate));
1405 for(plane_index=0; plane_index<2; plane_index++){
1432 for(plane_index=0; plane_index<
FFMIN(s->
nb_planes, 2); plane_index++){
1440 for(plane_index=0; plane_index<
FFMIN(s->
nb_planes, 2); plane_index++){
1444 for(i= p->
htaps/2; i; i--)
1468 for(plane_index=0; plane_index<2; plane_index++){
1494 uint32_t coef_sum= 0;
1495 int level, orientation, delta_qlog;
1498 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1506 const int qdiv= (1<<16)/qmul;
1511 buf[x+y*stride]= b->
buf[x+y*stride];
1516 coef_sum+=
abs(buf[x+y*stride]) * qdiv >> 16;
1522 coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1537 s->
qlog+= delta_qlog;
1544 int level, orientation, x, y;
1547 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1556 for(x=0; x<
width; x++){
1568 const AVFrame *pict,
int *got_packet)
1575 int level, orientation, plane_index,
i, y,
ret;
1591 AV_CEIL_RSHIFT(width, hshift));
1628 #if FF_API_CODED_FRAME 1638 #if FF_API_CODED_FRAME 1659 #if FF_API_CODED_FRAME 1671 int block_width = (width +15)>>4;
1672 int block_height= (height+15)>>4;
1735 for(plane_index=0; plane_index < s->
nb_planes; plane_index++){
1745 for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1754 if(pict->
data[plane_index])
1762 #if FF_API_PRIVATE_OPT 1799 if (delta_qlog <= INT_MIN)
1812 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1827 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1849 pict->
data[plane_index][y*pict->
linesize[plane_index] + x];
1860 if(pict->
data[plane_index])
1893 #if FF_API_STAT_BITS 1909 #if FF_API_ERROR_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 },
1951 {
"rc_eq",
"Set rate control equation. When computing the expression, besides the standard functions " 1952 "defined in the section 'Expression Evaluation', the following functions are available: " 1953 "bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv " 1954 "fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.",
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
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
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
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
uint64_t error[AV_NUM_DATA_POINTERS]
error
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
int64_t bit_rate
the average bitrate
#define LIBAVUTIL_VERSION_INT
void ff_h263_encode_init(MpegEncContext *s)
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)
static av_cold int init(AVCodecContext *avctx)
#define BLOCK_INTRA
Intra block, inter otherwise.
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)
int mb_lmin
minimum MB Lagrange multiplier
const char * av_default_item_name(void *ptr)
Return the context name.
int scenechange_threshold
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]
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int ff_snow_common_init_after_header(AVCodecContext *avctx)
static void update_last_header_values(SnowContext *s)
static void error(const char *err)
int mb_num
number of MBs of a picture
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)
enum AVPictureType last_picture
const uint8_t(* mv_penalty)[MAX_DMV *2+1]
bit amount needed to encode a MV
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)]
static int get_penalty_factor(int lambda, int lambda2, int type)
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
attribute_deprecated int mv_bits
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
uint8_t ref
Reference frame index.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
static double cb(void *priv, double x, double y)
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
int mb_lmax
maximum MB Lagrange multiplier
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
The exact code depends on how similar the blocks are and how related they are to the block
int16_t mx
Motion vector component X, see mv_scale.
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.
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)
enum OutputFormat out_format
output format
uint32_t * ref_scores[MAX_REF_FRAMES]
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)
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
const uint32_t ff_square_tab[512]
Motion estimation context.
GLsizei GLboolean const GLfloat * value
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)
int16_t my
Motion vector component Y, see mv_scale.
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 mb_height
number of MBs horizontally & vertically
void ff_snow_release_buffer(AVCodecContext *avctx)
char * stats_out
pass1 encoding statistics output buffer
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
attribute_deprecated uint64_t error[AV_NUM_DATA_POINTERS]
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
const uint8_t * current_mv_penalty
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
SubBand band[DWT_LEVELS_3D][4]
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.
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_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)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
const uint8_t *const ff_obmc_tab[4]
int flags
AV_CODEC_FLAG_*.
static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index)
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
uint8_t * emu_edge_buffer
int flags
A combination of AV_PKT_FLAG values.
uint8_t color[3]
Color for intra.
int refs
number of reference frames
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.
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
int display_picture_number
picture number in display order
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
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
static int encode_q_branch(SnowContext *s, int level, int x, int y)
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
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)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
int penalty_factor
an estimate of the bits required to code a given mv value, e.g.
static const float pred[4]
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
attribute_deprecated int misc_bits
uint8_t block_state[128+32 *128]
int coded_picture_number
picture number in bitstream order
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
Libavcodec external API header.
static void encode_header(SnowContext *s)
attribute_deprecated int scenechange_threshold
ptrdiff_t linesize
line size, in bytes, may be different from width
int spatial_decomposition_count
attribute_deprecated int prediction_method
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)
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)
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
static int get_rac_count(RangeCoder *c)
static void encode_q_branch2(SnowContext *s, int level, int x, int y)
Replacements for frequently missing libm functions.
unsigned me_cache[ME_CACHE_SIZE]
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
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
uint64_t encoding_error[AV_NUM_DATA_POINTERS]
attribute_deprecated int p_tex_bits
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
static enum AVPixelFormat pix_fmts[]
static int qscale2qlog(int qscale)
static int pix_sum(uint8_t *pix, int line_size, int w, int h)
static void encode_qlogs(SnowContext *s)
int motion_est
ME algorithm.
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 av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
int ff_init_me(MpegEncContext *s)
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
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
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
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)
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
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
static int ref[MAX_W *MAX_W]
IDWTELEM * temp_idwt_buffer
void ff_spatial_dwt(DWTELEM *buffer, DWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
DWTELEM * spatial_dwt_buffer
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
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
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
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.
attribute_deprecated int frame_bits
#define FF_ENABLE_DEPRECATION_WARNINGS
uint8_t * obmc_scratchpad
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)
int64_t bit_rate
wanted bit rate
int key_frame
1 -> keyframe, 0-> not
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
av_cold void ff_snow_common_end(SnowContext *s)
int frame_number
Frame counter, set by libavcodec.
static uint32_t inverse(uint32_t v)
find multiplicative inverse modulo 2 ^ 32
uint8_t type
Bitfield of BLOCK_*.
static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
AVFrame * last_picture[MAX_REF_FRAMES]
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 cr(void *priv, double x, double y)
AVFrame * input_picture
new_picture with the internal linesizes
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 local context
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)
#define BLOCK_OPT
Block needs no checks in this round of iterative motion estiation.
static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias)
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 multiplier used in rate distortion.
#define AV_CEIL_RSHIFT(a, b)
void * av_mallocz_array(size_t nmemb, size_t size)
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)