57 memset(score, 0,
sizeof(*score)*score_stride*((p->
height + Q2_STEP-1)/Q2_STEP));
58 for(y=0; y<p->
height; y++){
59 for(x=0; x<p->
width; x++){
60 int sx= (x-xo + step/2) / step / Q2_STEP;
61 int sy= (y-yo + step/2) / step / Q2_STEP;
63 assert(sx>=0 && sy>=0 && sx < score_stride);
65 score[sx + sy*score_stride] += v*
v;
66 assert(score[sx + sy*score_stride] >= 0);
72 int level, orientation;
75 for(orientation=level ? 1 : 0; orientation<4; orientation++){
79 dequantize(s, b, dst, b->
stride);
85 int level, orientation, ys, xs, x, y,
pass;
88 const int score_stride= (width + 10)/Q2_STEP;
89 int best_score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP];
90 int score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP];
99 for(orientation=level ? 1 : 0; orientation<4; orientation++){
103 assert(src == b->
buf);
108 for(pass=0; pass<1; pass++){
112 for(orientation=level ? 1 : 0; orientation<4; orientation++){
117 for(ys= 0; ys<Q2_STEP; ys++){
118 for(xs= 0; xs<Q2_STEP; xs++){
119 memcpy(idwt2_buffer, best_dequant, height * stride *
sizeof(
IDWTELEM));
120 dequantize_all(s, p, idwt2_buffer, width, height);
122 find_sse(s, p, best_score, score_stride, idwt2_buffer, s->
spatial_idwt_buffer, level, orientation);
123 memcpy(idwt2_buffer, best_dequant, height * stride *
sizeof(
IDWTELEM));
124 for(y=ys; y<b->
height; y+= Q2_STEP){
125 for(x=xs; x<b->
width; x+= Q2_STEP){
131 dequantize_all(s, p, idwt2_buffer, width, height);
133 find_sse(s, p, score, score_stride, idwt2_buffer, s->
spatial_idwt_buffer, level, orientation);
134 for(y=ys; y<b->
height; y+= Q2_STEP){
135 for(x=xs; x<b->
width; x+= Q2_STEP){
136 int score_idx= x/Q2_STEP + (y/Q2_STEP)*score_stride;
137 if(score[score_idx] <= best_score[score_idx] + threshold){
138 best_score[score_idx]= score[score_idx];
139 if(best_dst[x + y*b->
stride]<0) best_dst[x + y*b->
stride]++;
140 if(best_dst[x + y*b->
stride]>0) best_dst[x + y*b->
stride]--;
155 #if CONFIG_SNOW_ENCODER
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++){
255 static int pix_sum(uint8_t * pix,
int line_size,
int w)
260 for (i = 0; i < w; i++) {
261 for (j = 0; j < w; j++) {
265 pix += line_size - w;
271 static int pix_norm1(uint8_t * pix,
int line_size,
int w)
277 for (i = 0; i < w; i++) {
278 for (j = 0; j < w; j ++) {
282 pix += line_size - w;
290 #define P_TOPRIGHT P[3]
291 #define P_MEDIAN P[4]
293 #define FLAG_QPEL 1 //must be 1
295 static int encode_q_branch(
SnowContext *s,
int level,
int x,
int y){
296 uint8_t p_buffer[1024];
297 uint8_t i_buffer[1024];
303 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
307 const int index= (x + y*w) << rem_depth;
309 int trx= (x+1)<<rem_depth;
310 int try= (y+1)<<rem_depth;
316 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[
index-w+(1<<rem_depth)] : tl;
317 int pl = left->
color[0];
318 int pcb= left->color[1];
319 int pcr= left->color[2];
323 const int stride= s->current_picture.linesize[0];
324 const int uvstride= s->current_picture.linesize[1];
325 uint8_t *current_data[3]= { s->input_picture.data[0] + (x + y*
stride)*block_w,
326 s->input_picture.data[1] + (x + y*uvstride)*block_w/2,
327 s->input_picture.data[2] + (x + y*uvstride)*block_w/2};
329 int16_t last_mv[3][2];
331 const int shift= 1+qpel;
333 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
334 int mx_context= av_log2(2*
FFABS(left->mx - top->mx));
335 int my_context= av_log2(2*
FFABS(left->my - top->my));
336 int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
337 int ref, best_ref, ref_score, ref_mx, ref_my;
339 assert(
sizeof(s->block_state) >= 256);
341 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
354 last_mv[0][0]= s->block[
index].mx;
355 last_mv[0][1]= s->block[
index].my;
356 last_mv[1][0]= right->mx;
357 last_mv[1][1]= right->my;
358 last_mv[2][0]= bottom->mx;
359 last_mv[2][1]= bottom->my;
366 assert(c-> stride == stride);
374 c->
xmin = - x*block_w - 16+3;
375 c->
ymin = - y*block_w - 16+3;
376 c->
xmax = - (x+1)*block_w + (w<<(
LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
377 c->
ymax = - (y+1)*block_w + (h<<(
LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
400 for(ref=0; ref<s->ref_frames; ref++){
401 init_ref(c, current_data, s->last_picture[ref].data,
NULL, block_w*x, block_w*y, 0);
406 assert(ref_mx >= c->
xmin);
407 assert(ref_mx <= c->xmax);
408 assert(ref_my >= c->
ymin);
409 assert(ref_my <= c->ymax);
415 s->ref_mvs[ref][
index][0]= ref_mx;
416 s->ref_mvs[ref][
index][1]= ref_my;
417 s->ref_scores[ref][
index]= ref_score;
419 if(score > ref_score){
429 base_bits=
get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
432 pc.bytestream= p_buffer;
433 memcpy(p_state, s->block_state,
sizeof(s->block_state));
435 if(level!=s->block_max_depth)
436 put_rac(&pc, &p_state[4 + s_context], 1);
437 put_rac(&pc, &p_state[1 + left->type + top->type], 0);
438 if(s->ref_frames > 1)
439 put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
440 pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
441 put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
442 put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
443 p_len= pc.bytestream - pc.bytestream_start;
446 block_s= block_w*block_w;
447 sum = pix_sum(current_data[0], stride, block_w);
448 l= (sum + block_s/2)/block_s;
449 iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
451 block_s= block_w*block_w>>2;
452 sum = pix_sum(current_data[1], uvstride, block_w>>1);
453 cb= (sum + block_s/2)/block_s;
455 sum = pix_sum(current_data[2], uvstride, block_w>>1);
456 cr= (sum + block_s/2)/block_s;
461 ic.bytestream= i_buffer;
462 memcpy(i_state, s->block_state,
sizeof(s->block_state));
463 if(level!=s->block_max_depth)
464 put_rac(&ic, &i_state[4 + s_context], 1);
465 put_rac(&ic, &i_state[1 + left->type + top->type], 1);
469 i_len= ic.bytestream - ic.bytestream_start;
473 assert(iscore < 255*255*256 + s->lambda2*10);
475 assert(l>=0 && l<=255);
476 assert(pl>=0 && pl<=255);
479 int varc= iscore >> 8;
480 int vard= score >> 8;
481 if (vard <= 64 || vard < varc)
487 if(level!=s->block_max_depth){
488 put_rac(&s->c, &s->block_state[4 + s_context], 0);
489 score2 = encode_q_branch(s, level+1, 2*x+0, 2*y+0);
490 score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+0);
491 score2+= encode_q_branch(s, level+1, 2*x+0, 2*y+1);
492 score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+1);
495 if(score2 < score && score2 < iscore)
500 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
501 memcpy(pbbak, i_buffer, i_len);
503 s->c.bytestream_start= pbbak_start;
504 s->c.bytestream= pbbak + i_len;
505 set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0,
BLOCK_INTRA);
506 memcpy(s->block_state, i_state,
sizeof(s->block_state));
509 memcpy(pbbak, p_buffer, p_len);
511 s->c.bytestream_start= pbbak_start;
512 s->c.bytestream= pbbak + p_len;
513 set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
514 memcpy(s->block_state, p_state,
sizeof(s->block_state));
519 static void encode_q_branch2(
SnowContext *s,
int level,
int x,
int y){
522 const int index= (x + y*w) << rem_depth;
523 int trx= (x+1)<<rem_depth;
528 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[
index-w+(1<<rem_depth)] : tl;
529 int pl = left->
color[0];
530 int pcb= left->color[1];
531 int pcr= left->color[2];
533 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
534 int mx_context= av_log2(2*
FFABS(left->mx - top->mx)) + 16*!!b->ref;
535 int my_context= av_log2(2*
FFABS(left->my - top->my)) + 16*!!b->ref;
536 int s_context= 2*left->
level + 2*top->level + tl->level + tr->level;
539 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
543 if(level!=s->block_max_depth){
545 put_rac(&s->c, &s->block_state[4 + s_context], 1);
547 put_rac(&s->c, &s->block_state[4 + s_context], 0);
548 encode_q_branch2(s, level+1, 2*x+0, 2*y+0);
549 encode_q_branch2(s, level+1, 2*x+1, 2*y+0);
550 encode_q_branch2(s, level+1, 2*x+0, 2*y+1);
551 encode_q_branch2(s, level+1, 2*x+1, 2*y+1);
556 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
557 put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);
558 put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);
559 put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);
560 put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);
561 set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0,
BLOCK_INTRA);
563 pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);
564 put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);
565 if(s->ref_frames > 1)
566 put_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], b->ref, 0);
567 put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);
568 put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);
569 set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, b->ref, 0);
577 const int block_w = plane_index ? block_size/2 : block_size;
579 const int obmc_stride= plane_index ? block_size : 2*block_size;
581 uint8_t *src= s-> input_picture.data[plane_index];
584 const int w= p->
width;
586 int index= mb_x + mb_y*b_stride;
593 b->color[plane_index]= 0;
594 memset(dst, 0, obmc_stride*obmc_stride*
sizeof(
IDWTELEM));
597 int mb_x2= mb_x + (i &1) - 1;
598 int mb_y2= mb_y + (i>>1) - 1;
599 int x= block_w*mb_x2 + block_w/2;
600 int y= block_w*mb_y2 + block_w/2;
603 x, y, block_w, block_w, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
605 for(y2=
FFMAX(y, 0); y2<
FFMIN(h, y+block_w); y2++){
606 for(x2=
FFMAX(x, 0); x2<
FFMIN(w, x+block_w); x2++){
607 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_w*mb_y - block_w/2))*obmc_stride;
608 int obmc_v= obmc[
index];
610 if(y<0) obmc_v += obmc[index + block_w*obmc_stride];
611 if(x<0) obmc_v += obmc[index + block_w];
612 if(y+block_w>h) obmc_v += obmc[index - block_w*obmc_stride];
613 if(x+block_w>w) obmc_v += obmc[index - block_w];
618 ab += (src[x2 + y2*ref_stride] - (d>>
FRAC_BITS)) * obmc_v;
619 aa += obmc_v * obmc_v;
628 static inline int get_block_bits(
SnowContext *s,
int x,
int y,
int w){
631 int index= x + y*b_stride;
635 const BlockNode *tl = y && x ? &s->
block[index-b_stride-1] : left;
636 const BlockNode *tr = y && x+w<b_stride ? &s->
block[index-b_stride+w] : tl;
641 if(x<0 || x>=b_stride || y>=b_height)
657 pred_mv(s, &dmx, &dmy, b->
ref, left, top, tr);
660 return 2*(1 + av_log2(2*
FFABS(dmx))
661 + av_log2(2*
FFABS(dmy))
662 + av_log2(2*b->
ref));
666 static int get_block_rd(
SnowContext *s,
int mb_x,
int mb_y,
int plane_index,
const uint8_t *obmc_edged){
669 const int block_w = plane_index ? block_size/2 : block_size;
670 const int obmc_stride= plane_index ? block_size : 2*block_size;
673 uint8_t *src= s-> input_picture.data[plane_index];
679 const int w= p->
width;
684 int sx= block_w*mb_x - block_w/2;
685 int sy= block_w*mb_y - block_w/2;
686 int x0=
FFMAX(0,-sx);
687 int y0=
FFMAX(0,-sy);
688 int x1=
FFMIN(block_w*2, w-sx);
689 int y1=
FFMIN(block_w*2, h-sy);
692 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);
694 for(y=y0; y<y1; y++){
695 const uint8_t *obmc1= obmc_edged + y*obmc_stride;
696 const IDWTELEM *pred1 = pred + y*obmc_stride;
697 uint8_t *cur1 = cur + y*ref_stride;
698 uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
699 for(x=x0; x<x1; x++){
700 #if FRAC_BITS >= LOG2_OBMC_MAX
706 if(v&(~255)) v= ~(v>>31);
713 && (mb_x == 0 || mb_x == b_stride-1)
714 && (mb_y == 0 || mb_y == b_height-1)){
724 memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
735 distortion =
ff_w97_32_c(&s->
m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
737 distortion =
ff_w53_32_c(&s->
m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
741 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
742 distortion += s->
dsp.
me_cmp[0](&s->
m, src +
off, dst +
off, ref_stride, 16);
747 distortion = s->
dsp.
me_cmp[0](&s->
m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
756 rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
758 if(mb_x == b_stride-2)
759 rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);
761 return distortion + rate*penalty_factor;
764 static int get_4block_rd(
SnowContext *s,
int mb_x,
int mb_y,
int plane_index){
768 const int block_w = plane_index ? block_size/2 : block_size;
770 const int obmc_stride= plane_index ? block_size : 2*block_size;
773 uint8_t *src= s-> input_picture.data[plane_index];
778 const int w= p->
width;
785 int mb_x2= mb_x + (i%3) - 1;
786 int mb_y2= mb_y + (i/3) - 1;
787 int x= block_w*mb_x2 + block_w/2;
788 int y= block_w*mb_y2 + block_w/2;
791 x, y, block_w, block_w, w, h, 0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
794 for(y2= y; y2<0; y2++)
795 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
796 for(y2= h; y2<y+block_w; y2++)
797 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
799 for(y2= y; y2<y+block_w; y2++)
800 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
803 for(y2= y; y2<y+block_w; y2++)
804 memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
807 assert(block_w== 8 || block_w==16);
808 distortion += s->
dsp.
me_cmp[block_w==8](&s->
m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_w);
821 rate = get_block_bits(s, mb_x, mb_y, 2);
822 for(i=merged?4:0; i<9; i++){
823 static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
824 rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);
827 return distortion + rate*penalty_factor;
831 const int w= b->
width;
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];
871 runs[run_index++]=
run;
879 max_index= run_index;
880 runs[run_index++]=
run;
882 run= runs[run_index++];
885 if(run_index <= max_index)
895 int l=0, lt=0,
t=0, rt=0;
899 t= src[x + (y-1)*stride];
901 lt= src[x - 1 + (y-1)*stride];
904 rt= src[x + 1 + (y-1)*stride];
917 if(px<b->parent->width && py<b->parent->height)
918 p= parent[px + py*2*
stride];
926 run= runs[run_index++];
928 if(run_index <= max_index)
938 int l2= 2*
FFABS(l) + (l<0);
953 return encode_subband_c0run(s, b, src, parent, stride, orientation);
957 static av_always_inline int check_block(
SnowContext *s,
int mb_x,
int mb_y,
int p[3],
int intra,
const uint8_t *obmc_edged,
int *best_rd){
964 assert(mb_x>=0 && mb_y>=0);
965 assert(mb_x<b_stride);
968 block->
color[0] = p[0];
969 block->
color[1] = p[1];
970 block->
color[2] = p[2];
984 rd= get_block_rd(s, mb_x, mb_y, 0, obmc_edged);
998 static av_always_inline int check_block_inter(
SnowContext *s,
int mb_x,
int mb_y,
int p0,
int p1,
const uint8_t *obmc_edged,
int *best_rd){
1000 return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
1006 BlockNode backup[4]= {block[0], block[1], block[b_stride], block[b_stride+1]};
1010 assert(mb_x>=0 && mb_y>=0);
1011 assert(mb_x<b_stride);
1012 assert(((mb_x|mb_y)&1) == 0);
1024 block[1]= block[b_stride]= block[b_stride+1]= *
block;
1026 rd= get_4block_rd(s, mb_x, mb_y, 0);
1033 block[0]= backup[0];
1034 block[1]= backup[1];
1035 block[b_stride]= backup[2];
1036 block[b_stride+1]= backup[3];
1042 int pass, mb_x, mb_y;
1045 const int b_stride= b_width;
1052 for(mb_y= 0; mb_y<s->
b_height; mb_y++)
1053 for(mb_x= 0; mb_x<s->
b_width; mb_x++)
1054 encode_q_branch(s, 0, mb_x, mb_y);
1059 for(pass=0; pass<25; pass++){
1062 for(mb_y= 0; mb_y<b_height; mb_y++){
1063 for(mb_x= 0; mb_x<b_width; mb_x++){
1064 int dia_change, i, j, ref;
1065 int best_rd= INT_MAX, ref_rd;
1067 const int index= mb_x + mb_y * b_stride;
1076 BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->
block[index+b_stride+1] :
NULL;
1078 uint8_t obmc_edged[b_w*2][b_w*2];
1095 for(y=0; y<b_w*2; y++)
1096 memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1097 if(mb_x==b_stride-1)
1098 for(y=0; y<b_w*2; y++)
1099 memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1101 for(x=0; x<b_w*2; x++)
1102 obmc_edged[0][x] += obmc_edged[b_w-1][x];
1103 for(y=1; y<b_w; y++)
1104 memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1106 if(mb_y==b_height-1){
1107 for(x=0; x<b_w*2; x++)
1108 obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
1109 for(y=b_w; y<b_w*2-1; y++)
1110 memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1115 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
1116 uint8_t *src= s-> input_picture.data[0];
1120 const int sx= block_w*mb_x - block_w/2;
1121 const int sy= block_w*mb_y - block_w/2;
1127 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1128 for(y=h; y<sy+block_w*2; y++)
1129 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1131 for(y=sy; y<sy+block_w*2; y++)
1132 memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
1134 if(sx+block_w*2 > w){
1135 for(y=sy; y<sy+block_w*2; y++)
1136 memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
1142 color[i]=
get_dc(s, mb_x, mb_y, i);
1147 check_block(s, mb_x, mb_y, color0, 1, *obmc_edged, &best_rd);
1149 check_block_inter(s, mb_x, mb_y, block->
mx, block->
my, *obmc_edged, &best_rd);
1160 check_block_inter(s, mb_x, mb_y, mvr[0][0], mvr[0][1], *obmc_edged, &best_rd);
1161 check_block_inter(s, mb_x, mb_y, 0, 0, *obmc_edged, &best_rd);
1163 check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], *obmc_edged, &best_rd);
1165 check_block_inter(s, mb_x, mb_y, mvr[-1][0], mvr[-1][1], *obmc_edged, &best_rd);
1167 check_block_inter(s, mb_x, mb_y, mvr[1][0], mvr[1][1], *obmc_edged, &best_rd);
1169 check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], *obmc_edged, &best_rd);
1177 dia_change |= check_block_inter(s, mb_x, mb_y, block->
mx+4*(i-j), block->
my+(4*j), *obmc_edged, &best_rd);
1178 dia_change |= check_block_inter(s, mb_x, mb_y, block->
mx-4*(i-j), block->
my-(4*j), *obmc_edged, &best_rd);
1179 dia_change |= check_block_inter(s, mb_x, mb_y, block->
mx+4*(i-j), block->
my-(4*j), *obmc_edged, &best_rd);
1180 dia_change |= check_block_inter(s, mb_x, mb_y, block->
mx-4*(i-j), block->
my+(4*j), *obmc_edged, &best_rd);
1186 static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1189 dia_change |= check_block_inter(s, mb_x, mb_y, block->
mx+square[i][0], block->
my+square[i][1], *obmc_edged, &best_rd);
1193 mvr[0][0]= block->
mx;
1194 mvr[0][1]= block->
my;
1195 if(ref_rd > best_rd){
1202 check_block(s, mb_x, mb_y, color, 1, *obmc_edged, &best_rd);
1224 for(mb_y= 0; mb_y<b_height; mb_y+=2){
1225 for(mb_x= 0; mb_x<b_width; mb_x+=2){
1227 int best_rd, init_rd;
1228 const int index= mb_x + mb_y * b_stride;
1233 b[2]= b[0]+b_stride;
1244 init_rd= best_rd= get_4block_rd(s, mb_x, mb_y, 0);
1247 check_4block_inter(s, mb_x, mb_y,
1248 (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,
1249 (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);
1253 check_4block_inter(s, mb_x, mb_y, b[i]->mx, b[i]->my, b[i]->ref, &best_rd);
1255 if(init_rd != best_rd)
1263 static void encode_blocks(
SnowContext *s,
int search){
1278 encode_q_branch2(s, 0, x, y);
1280 encode_q_branch (s, 0, x, y);
1286 const int w= b->
width;
1290 int x,y, thres1, thres2;
1295 dst[x + y*stride]= src[x + y*stride];
1299 bias= bias ? 0 : (3*qmul)>>3;
1306 int i= src[x + y*
stride];
1308 if((
unsigned)(i+thres1) > thres2){
1326 int i= src[x + y*
stride];
1328 if((
unsigned)(i+thres1) > thres2){
1331 i= (i + bias) / qmul;
1336 i= (i + bias) / qmul;
1347 const int w= b->
width;
1358 int i= src[x + y*
stride];
1369 const int w= b->
width;
1373 for(y=h-1; y>=0; y--){
1374 for(x=w-1; x>=0; x--){
1379 if(y && x+1<w) src[i] -=
mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1380 else src[i] -= src[i - 1];
1382 if(y) src[i] -=
mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1383 else src[i] -= src[i - 1];
1386 if(y) src[i] -= src[i -
stride];
1393 const int w= b->
width;
1403 if(y && x+1<w) src[i] +=
mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1404 else src[i] += src[i - 1];
1406 if(y) src[i] +=
mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1407 else src[i] += src[i - 1];
1410 if(y) src[i] += src[i -
stride];
1417 int plane_index,
level, orientation;
1419 for(plane_index=0; plane_index<2; plane_index++){
1421 for(orientation=level ? 1:0; orientation<4; orientation++){
1422 if(orientation==2)
continue;
1433 memset(kstate,
MID_STATE,
sizeof(kstate));
1443 for(plane_index=0; plane_index<2; plane_index++){
1468 for(plane_index=0; plane_index<2; plane_index++){
1476 for(plane_index=0; plane_index<2; plane_index++){
1480 for(i= p->
htaps/2; i; i--)
1500 static void update_last_header_values(
SnowContext *s){
1504 for(plane_index=0; plane_index<2; plane_index++){
1520 static int qscale2qlog(
int qscale){
1530 uint32_t coef_sum= 0;
1531 int level, orientation, delta_qlog;
1534 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1537 const int w= b->
width;
1539 const int stride= b->
stride;
1542 const int qdiv= (1<<16)/qmul;
1547 buf[x+y*stride]= b->
buf[x+y*stride];
1549 decorrelate(s, b, buf, stride, 1, 0);
1552 coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
1557 coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1558 assert(coef_sum < INT_MAX);
1573 s->
qlog+= delta_qlog;
1578 int width = p->
width;
1580 int level, orientation, x, y;
1583 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1592 for(x=0; x<
width; x++){
1598 b->
qlog= (int)(log(352256.0/sqrt(error)) / log(pow(2.0, 1.0/
QROOT))+0.5);
1609 int level, orientation, plane_index, i, y;
1618 for(y=0; y<(height>>shift); y++)
1658 int block_width = (width +15)>>4;
1659 int block_height= (height+15)>>4;
1668 s->
m. new_picture.f.data[0] = s-> input_picture.data[0];
1669 s->
m. last_picture_ptr= &s->
m. last_picture;
1717 for(plane_index=0; plane_index<3; plane_index++){
1718 calculate_visual_weight(s, &s->
plane[plane_index]);
1724 encode_blocks(s, 1);
1727 for(plane_index=0; plane_index<3; plane_index++){
1736 if(pict->
data[plane_index])
1776 int delta_qlog = ratecontrol_1pass(s, pict);
1777 if (delta_qlog <= INT_MIN)
1785 encode_blocks(s, 0);
1790 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1805 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1827 pict->
data[plane_index][y*pict->
linesize[plane_index] + x];
1838 if(pict->
data[plane_index])
1851 update_last_header_values(s);
1892 #define OFFSET(x) offsetof(SnowContext, x)
1893 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1895 {
"memc_only",
"Only do ME/MC (I frames -> ref, P frame -> ME+MC).",
OFFSET(memc_only),
AV_OPT_TYPE_INT, { 0 }, 0, 1,
VE },
1899 static const AVClass snowenc_class = {
1915 .priv_class = &snowenc_class,