58 memset(score, 0,
sizeof(*score)*score_stride*((p->
height + Q2_STEP-1)/Q2_STEP));
59 for(y=0; y<p->
height; y++){
60 for(x=0; x<p->
width; x++){
61 int sx= (x-xo + step/2) / step / Q2_STEP;
62 int sy= (y-yo + step/2) / step / Q2_STEP;
63 int v= r0[x + y*p->
width] - r1[x + y*p->
width];
64 assert(sx>=0 && sy>=0 && sx < score_stride);
66 score[sx + sy*score_stride] += v*v;
67 assert(score[sx + sy*score_stride] >= 0);
73 int level, orientation;
76 for(orientation=level ? 1 : 0; orientation<4; orientation++){
86 int level, orientation, ys, xs, x, y,
pass;
89 const int score_stride= (width + 10)/Q2_STEP;
90 int best_score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP];
91 int score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP];
100 for(orientation=level ? 1 : 0; orientation<4; orientation++){
104 assert(src == b->
buf);
109 for(pass=0; pass<1; pass++){
113 for(orientation=level ? 1 : 0; orientation<4; orientation++){
118 for(ys= 0; ys<Q2_STEP; ys++){
119 for(xs= 0; xs<Q2_STEP; xs++){
120 memcpy(idwt2_buffer, best_dequant, height * stride *
sizeof(
IDWTELEM));
121 dequantize_all(s, p, idwt2_buffer, width, height);
123 find_sse(s, p, best_score, score_stride, idwt2_buffer, s->
spatial_idwt_buffer, level, orientation);
124 memcpy(idwt2_buffer, best_dequant, height * stride *
sizeof(
IDWTELEM));
125 for(y=ys; y<b->
height; y+= Q2_STEP){
126 for(x=xs; x<b->
width; x+= Q2_STEP){
132 dequantize_all(s, p, idwt2_buffer, width, height);
134 find_sse(s, p, score, score_stride, idwt2_buffer, s->
spatial_idwt_buffer, level, orientation);
135 for(y=ys; y<b->
height; y+= Q2_STEP){
136 for(x=xs; x<b->
width; x+= Q2_STEP){
137 int score_idx= x/Q2_STEP + (y/Q2_STEP)*score_stride;
138 if(score[score_idx] <= best_score[score_idx] + threshold){
139 best_score[score_idx]= score[score_idx];
140 if(best_dst[x + y*b->
stride]<0) best_dst[x + y*b->
stride]++;
141 if(best_dst[x + y*b->
stride]>0) best_dst[x + y*b->
stride]--;
159 int plane_index, ret;
162 av_log(avctx,
AV_LOG_ERROR,
"This codec is under development, files encoded with it may not be decodable with future versions!!!\n"
163 "Use vstrict=-2 / -strict -2 to use it anyway.\n");
179 for(plane_index=0; plane_index<3; plane_index++){
263 for (i = 0; i < w; i++) {
264 for (j = 0; j < w; j++) {
268 pix += line_size - w;
280 for (i = 0; i < w; i++) {
281 for (j = 0; j < w; j ++) {
285 pix += line_size - w;
293 #define P_TOPRIGHT P[3]
294 #define P_MEDIAN P[4]
296 #define FLAG_QPEL 1 //must be 1
306 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
310 const int index= (x + y*w) << rem_depth;
312 int trx= (x+1)<<rem_depth;
313 int try= (y+1)<<rem_depth;
319 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->
block[index-w+(1<<rem_depth)] : tl;
320 int pl = left->
color[0];
321 int pcb= left->
color[1];
322 int pcr= left->
color[2];
332 int16_t last_mv[3][2];
334 const int shift= 1+qpel;
340 int ref, best_ref, ref_score, ref_mx, ref_my;
344 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
359 last_mv[1][0]= right->
mx;
360 last_mv[1][1]= right->
my;
361 last_mv[2][0]= bottom->
mx;
362 last_mv[2][1]= bottom->
my;
369 assert(c-> stride == stride);
377 c->
xmin = - x*block_w - 16+3;
378 c->
ymin = - y*block_w - 16+3;
409 assert(ref_mx >= c->
xmin);
410 assert(ref_mx <= c->xmax);
411 assert(ref_my >= c->
ymin);
412 assert(ref_my <= c->ymax);
422 if(score > ref_score){
435 pc.bytestream= p_buffer;
439 put_rac(&pc, &p_state[4 + s_context], 1);
442 put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
443 pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
444 put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
445 put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
446 p_len= pc.bytestream - pc.bytestream_start;
449 block_s= block_w*block_w;
450 sum =
pix_sum(current_data[0], stride, block_w);
451 l= (sum + block_s/2)/block_s;
452 iscore =
pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
454 block_s= block_w*block_w>>2;
455 sum =
pix_sum(current_data[1], uvstride, block_w>>1);
456 cb= (sum + block_s/2)/block_s;
458 sum =
pix_sum(current_data[2], uvstride, block_w>>1);
459 cr= (sum + block_s/2)/block_s;
464 ic.bytestream= i_buffer;
467 put_rac(&ic, &i_state[4 + s_context], 1);
472 i_len= ic.bytestream - ic.bytestream_start;
476 assert(iscore < 255*255*256 + s->lambda2*10);
478 assert(l>=0 && l<=255);
479 assert(pl>=0 && pl<=255);
482 int varc= iscore >> 8;
483 int vard= score >> 8;
484 if (vard <= 64 || vard < varc)
498 if(score2 < score && score2 < iscore)
503 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
504 memcpy(pbbak, i_buffer, i_len);
508 set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0,
BLOCK_INTRA);
512 memcpy(pbbak, p_buffer, p_len);
516 set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
525 const int index= (x + y*w) << rem_depth;
526 int trx= (x+1)<<rem_depth;
531 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->
block[index-w+(1<<rem_depth)] : tl;
532 int pl = left->
color[0];
533 int pcb= left->
color[1];
534 int pcr= left->
color[2];
542 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
559 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
564 set_blocks(s, level, x, y, b->
color[0], b->
color[1], b->
color[2], pmx, pmy, 0,
BLOCK_INTRA);
566 pred_mv(s, &pmx, &pmy, b->
ref, left, top, tr);
572 set_blocks(s, level, x, y, pl, pcb, pcr, b->
mx, b->
my, b->
ref, 0);
580 const int block_w = plane_index ? block_size/2 : block_size;
582 const int obmc_stride= plane_index ? block_size : 2*block_size;
584 uint8_t *src= s-> input_picture.data[plane_index];
587 const int w= p->
width;
589 int index= mb_x + mb_y*b_stride;
596 b->color[plane_index]= 0;
597 memset(dst, 0, obmc_stride*obmc_stride*
sizeof(
IDWTELEM));
600 int mb_x2= mb_x + (i &1) - 1;
601 int mb_y2= mb_y + (i>>1) - 1;
602 int x= block_w*mb_x2 + block_w/2;
603 int y= block_w*mb_y2 + block_w/2;
606 x, y, block_w, block_w, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
608 for(y2=
FFMAX(y, 0); y2<
FFMIN(h, y+block_w); y2++){
609 for(x2=
FFMAX(x, 0); x2<
FFMIN(w, x+block_w); x2++){
610 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_w*mb_y - block_w/2))*obmc_stride;
611 int obmc_v= obmc[
index];
613 if(y<0) obmc_v += obmc[index + block_w*obmc_stride];
614 if(x<0) obmc_v += obmc[index + block_w];
615 if(y+block_w>h) obmc_v += obmc[index - block_w*obmc_stride];
616 if(x+block_w>w) obmc_v += obmc[index - block_w];
621 ab += (src[x2 + y2*ref_stride] - (d>>
FRAC_BITS)) * obmc_v;
622 aa += obmc_v * obmc_v;
634 int index= x + y*b_stride;
638 const BlockNode *tl = y && x ? &s->
block[index-b_stride-1] : left;
639 const BlockNode *tr = y && x+w<b_stride ? &s->
block[index-b_stride+w] : tl;
644 if(x<0 || x>=b_stride || y>=b_height)
660 pred_mv(s, &dmx, &dmy, b->
ref, left, top, tr);
672 const int block_w = plane_index ? block_size/2 : block_size;
673 const int obmc_stride= plane_index ? block_size : 2*block_size;
676 uint8_t *src= s-> input_picture.data[plane_index];
682 const int w= p->
width;
687 int sx= block_w*mb_x - block_w/2;
688 int sy= block_w*mb_y - block_w/2;
689 int x0=
FFMAX(0,-sx);
690 int y0=
FFMAX(0,-sy);
691 int x1=
FFMIN(block_w*2, w-sx);
692 int y1=
FFMIN(block_w*2, h-sy);
695 ff_snow_pred_block(s, cur, tmp, ref_stride, sx, sy, block_w*2, block_w*2, &s->
block[mb_x + mb_y*b_stride], plane_index, w, h);
697 for(y=y0; y<y1; y++){
698 const uint8_t *obmc1= obmc_edged[y];
699 const IDWTELEM *pred1 = pred + y*obmc_stride;
700 uint8_t *cur1 = cur + y*ref_stride;
701 uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
702 for(x=x0; x<x1; x++){
703 #if FRAC_BITS >= LOG2_OBMC_MAX
709 if(v&(~255)) v= ~(v>>31);
716 && (mb_x == 0 || mb_x == b_stride-1)
717 && (mb_y == 0 || mb_y == b_height-1)){
727 memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
738 distortion =
ff_w97_32_c(&s->
m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
740 distortion =
ff_w53_32_c(&s->
m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
744 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
745 distortion += s->
dsp.
me_cmp[0](&s->
m, src +
off, dst +
off, ref_stride, 16);
750 distortion = s->
dsp.
me_cmp[0](&s->
m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
759 rate +=
get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
761 if(mb_x == b_stride-2)
764 return distortion + rate*penalty_factor;
771 const int block_w = plane_index ? block_size/2 : block_size;
773 const int obmc_stride= plane_index ? block_size : 2*block_size;
776 uint8_t *src= s-> input_picture.data[plane_index];
781 const int w= p->
width;
788 int mb_x2= mb_x + (i%3) - 1;
789 int mb_y2= mb_y + (i/3) - 1;
790 int x= block_w*mb_x2 + block_w/2;
791 int y= block_w*mb_y2 + block_w/2;
794 x, y, block_w, block_w, w, h, 0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
797 for(y2= y; y2<0; y2++)
798 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
799 for(y2= h; y2<y+block_w; y2++)
800 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
802 for(y2= y; y2<y+block_w; y2++)
803 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
806 for(y2= y; y2<y+block_w; y2++)
807 memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
810 assert(block_w== 8 || block_w==16);
811 distortion += s->
dsp.
me_cmp[block_w==8](&s->
m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_w);
825 for(i=merged?4:0; i<9; i++){
826 static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
830 return distortion + rate*penalty_factor;
834 const int w= b->
width;
847 int l=0, lt=0,
t=0, rt=0;
851 t= src[x + (y-1)*stride];
853 lt= src[x - 1 + (y-1)*stride];
856 rt= src[x + 1 + (y-1)*stride];
869 if(px<b->parent->width && py<b->parent->height)
870 p= parent[px + py*2*
stride];
874 runs[run_index++]=
run;
882 max_index= run_index;
883 runs[run_index++]=
run;
885 run= runs[run_index++];
888 if(run_index <= max_index)
898 int l=0, lt=0,
t=0, rt=0;
902 t= src[x + (y-1)*stride];
904 lt= src[x - 1 + (y-1)*stride];
907 rt= src[x + 1 + (y-1)*stride];
920 if(px<b->parent->width && py<b->parent->height)
921 p= parent[px + py*2*
stride];
929 run= runs[run_index++];
931 if(run_index <= max_index)
941 int l2= 2*
FFABS(l) + (l<0);
967 assert(mb_x>=0 && mb_y>=0);
968 assert(mb_x<b_stride);
971 block->
color[0] = p[0];
972 block->
color[1] = p[1];
973 block->
color[2] = p[2];
1002 int p[2] = {p0, p1};
1003 return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
1016 backup[0] = block[0];
1017 backup[1] = block[1];
1018 backup[2] = block[b_stride];
1019 backup[3] = block[b_stride + 1];
1021 assert(mb_x>=0 && mb_y>=0);
1022 assert(mb_x<b_stride);
1023 assert(((mb_x|mb_y)&1) == 0);
1035 block[1]= block[b_stride]= block[b_stride+1]= *
block;
1044 block[0]= backup[0];
1045 block[1]= backup[1];
1046 block[b_stride]= backup[2];
1047 block[b_stride+1]= backup[3];
1053 int pass, mb_x, mb_y;
1056 const int b_stride= b_width;
1063 for(mb_y= 0; mb_y<s->
b_height; mb_y++)
1064 for(mb_x= 0; mb_x<s->
b_width; mb_x++)
1070 for(pass=0; pass<25; pass++){
1073 for(mb_y= 0; mb_y<b_height; mb_y++){
1074 for(mb_x= 0; mb_x<b_width; mb_x++){
1075 int dia_change, i, j, ref;
1076 int best_rd= INT_MAX, ref_rd;
1078 const int index= mb_x + mb_y * b_stride;
1087 BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->
block[index+b_stride+1] :
NULL;
1104 for (y = 0; y < b_w * 2; y++)
1107 for(y=0; y<b_w*2; y++)
1108 memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1109 if(mb_x==b_stride-1)
1110 for(y=0; y<b_w*2; y++)
1111 memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1113 for(x=0; x<b_w*2; x++)
1114 obmc_edged[0][x] += obmc_edged[b_w-1][x];
1115 for(y=1; y<b_w; y++)
1116 memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1118 if(mb_y==b_height-1){
1119 for(x=0; x<b_w*2; x++)
1120 obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
1121 for(y=b_w; y<b_w*2-1; y++)
1122 memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1127 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
1128 uint8_t *src= s-> input_picture.data[0];
1132 const int sx= block_w*mb_x - block_w/2;
1133 const int sy= block_w*mb_y - block_w/2;
1139 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1140 for(y=h; y<sy+block_w*2; y++)
1141 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1143 for(y=sy; y<sy+block_w*2; y++)
1144 memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
1146 if(sx+block_w*2 > w){
1147 for(y=sy; y<sy+block_w*2; y++)
1148 memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
1154 color[i]=
get_dc(s, mb_x, mb_y, i);
1159 check_block(s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);
1175 check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1181 check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1189 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx+4*(i-j), block->
my+(4*j), obmc_edged, &best_rd);
1190 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx-4*(i-j), block->
my-(4*j), obmc_edged, &best_rd);
1191 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx+4*(i-j), block->
my-(4*j), obmc_edged, &best_rd);
1192 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx-4*(i-j), block->
my+(4*j), obmc_edged, &best_rd);
1198 static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1201 dia_change |=
check_block_inter(s, mb_x, mb_y, block->
mx+square[i][0], block->
my+square[i][1], obmc_edged, &best_rd);
1205 mvr[0][0]= block->
mx;
1206 mvr[0][1]= block->
my;
1207 if(ref_rd > best_rd){
1214 check_block(s, mb_x, mb_y, color, 1, obmc_edged, &best_rd);
1236 for(mb_y= 0; mb_y<b_height; mb_y+=2){
1237 for(mb_x= 0; mb_x<b_width; mb_x+=2){
1239 int best_rd, init_rd;
1240 const int index= mb_x + mb_y * b_stride;
1245 b[2]= b[0]+b_stride;
1260 (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,
1261 (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);
1267 if(init_rd != best_rd)
1298 const int w= b->
width;
1302 int x,y, thres1, thres2;
1307 dst[x + y*stride]= src[x + y*stride];
1311 bias= bias ? 0 : (3*qmul)>>3;
1318 int i= src[x + y*
stride];
1320 if((
unsigned)(i+thres1) > thres2){
1338 int i= src[x + y*
stride];
1340 if((
unsigned)(i+thres1) > thres2){
1343 i= (i + bias) / qmul;
1348 i= (i + bias) / qmul;
1359 const int w= b->
width;
1370 int i= src[x + y*
stride];
1381 const int w= b->
width;
1385 for(y=h-1; y>=0; y--){
1386 for(x=w-1; x>=0; x--){
1391 if(y && x+1<w) src[i] -=
mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1392 else src[i] -= src[i - 1];
1394 if(y) src[i] -=
mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1395 else src[i] -= src[i - 1];
1398 if(y) src[i] -= src[i -
stride];
1405 const int w= b->
width;
1415 if(y && x+1<w) src[i] +=
mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1416 else src[i] += src[i - 1];
1418 if(y) src[i] +=
mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1419 else src[i] += src[i - 1];
1422 if(y) src[i] += src[i -
stride];
1429 int plane_index,
level, orientation;
1431 for(plane_index=0; plane_index<2; plane_index++){
1433 for(orientation=level ? 1:0; orientation<4; orientation++){
1434 if(orientation==2)
continue;
1445 memset(kstate,
MID_STATE,
sizeof(kstate));
1455 for(plane_index=0; plane_index<2; plane_index++){
1480 for(plane_index=0; plane_index<2; plane_index++){
1488 for(plane_index=0; plane_index<2; plane_index++){
1492 for(i= p->
htaps/2; i; i--)
1516 for(plane_index=0; plane_index<2; plane_index++){
1542 uint32_t coef_sum= 0;
1543 int level, orientation, delta_qlog;
1546 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1549 const int w= b->
width;
1551 const int stride= b->
stride;
1554 const int qdiv= (1<<16)/qmul;
1559 buf[x+y*stride]= b->
buf[x+y*stride];
1564 coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
1569 coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1570 assert(coef_sum < INT_MAX);
1585 s->
qlog+= delta_qlog;
1590 int width = p->
width;
1592 int level, orientation, x, y;
1595 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1604 for(x=0; x<
width; x++){
1610 b->
qlog= (int)(log(352256.0/sqrt(error)) / log(pow(2.0, 1.0/
QROOT))+0.5);
1616 const AVFrame *pict,
int *got_packet)
1623 int level, orientation, plane_index, i, y, ret;
1638 for(y=0; y<(height>>shift); y++)
1676 int block_width = (width +15)>>4;
1677 int block_height= (height+15)>>4;
1686 s->
m. new_picture.f.data[0] = s-> input_picture.data[0];
1687 s->
m. last_picture_ptr= &s->
m. last_picture;
1735 for(plane_index=0; plane_index<3; plane_index++){
1745 for(plane_index=0; plane_index<3; plane_index++){
1754 if(pict->
data[plane_index])
1795 if (delta_qlog <= INT_MIN)
1808 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1823 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1845 pict->
data[plane_index][y*pict->
linesize[plane_index] + x];
1856 if(pict->
data[plane_index])
1915 #define OFFSET(x) offsetof(SnowContext, x)
1916 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1918 {
"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 },
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
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
int ff_snow_frame_start(SnowContext *s)
int last_spatial_decomposition_count
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)
void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
uint64_t error[AV_NUM_DATA_POINTERS]
error
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
void ff_h263_encode_init(MpegEncContext *s)
AVFrame * coded_frame
the picture in the bitstream
uint8_t * current_mv_penalty
#define FF_MIN_BUFFER_SIZE
int ff_w53_32_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
static int pix_sum(uint8_t *pix, int line_size, int w)
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)
int ff_w97_32_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
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)
int scenechange_threshold
scene change detection threshold 0 is default, larger means fewer detected scene changes.
int qlog
log(qscale)/log[2^(1/6)]
int ff_rac_terminate(RangeCoder *c)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
enum OutputFormat out_format
output format
uint32_t * ref_scores[MAX_REF_FRAMES]
Motion estimation context.
int64_t pts
presentation timestamp in time_base units (time when frame should be shown to user) If AV_NOPTS_VALUE...
int misc_bits
cbp, mb_type
#define CODEC_FLAG_QSCALE
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
static int encode_subband_c0run(SnowContext *s, SubBand *b, IDWTELEM *src, IDWTELEM *parent, int stride, int orientation)
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)
char * stats_out
pass1 encoding statistics output buffer
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
static int init(AVCodecParserContext *s)
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
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
static int encode_subband(SnowContext *s, SubBand *b, IDWTELEM *src, IDWTELEM *parent, int stride, int orientation)
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. ...
const uint8_t *const ff_obmc_tab[4]
static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index)
void av_log(void *avcl, int level, const char *fmt,...)
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.
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, see ?_TYPE below.
int display_picture_number
picture number in display order
SubBand band[MAX_DECOMPOSITIONS][4]
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
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
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))
struct SnowContext SnowContext
#define FF_COMPLIANCE_EXPERIMENTAL
int penalty_factor
an estimate of the bits required to code a given mv value, e.g.
static const float pred[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
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
static void encode_header(SnowContext *s)
int spatial_decomposition_count
static av_const unsigned int ff_sqrt(unsigned int a)
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
int frame_bits
number of bits used for the previously encoded frame
static int get_penalty_factor(int lambda, int lambda2, int type)
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)
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]
Describe the class of an AVClass context structure.
static int get_block_bits(SnowContext *s, int x, int y, int w)
DSPContext dsp
pointers for accelerated dsp functions
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)
int ff_snow_common_init(AVCodecContext *avctx)
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)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int spatial_decomposition_type
void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h)
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)
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
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
int ff_rate_control_init(MpegEncContext *s)
void ff_spatial_dwt(DWTELEM *buffer, DWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
static void pred_mv(SnowContext *s, int *mx, int *my, int ref, const BlockNode *left, const BlockNode *top, const BlockNode *tr)
static av_cold int encode_init(AVCodecContext *avctx)
static const uint8_t color[]
static const AVOption options[]
uint32_t * map
map to avoid duplicate evaluations
IDWTELEM * spatial_idwt_buffer
uint8_t * bytestream_start
AVFrame input_picture
new_picture with the internal linesizes
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
int linesize
line size, in bytes, may be different from width
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 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]
static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
static int pix_norm1(uint8_t *pix, int line_size, int w)
int temporal_decomposition_count
int uvlinesize
line size, for chroma in bytes, may be different from width
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 ...
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
int last_spatial_decomposition_type
unsigned int lambda
lagrange multipler used in rate distortion
void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
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)
AVFrame last_picture[MAX_REF_FRAMES]