54 s->spatial_decomposition_type=
s->pred;
59 for(plane_index=0; plane_index<3; plane_index++){
60 s->plane[plane_index].diag_mc= 1;
61 s->plane[plane_index].htaps= 6;
62 s->plane[plane_index].hcoeff[0]= 40;
63 s->plane[plane_index].hcoeff[1]= -10;
64 s->plane[plane_index].hcoeff[2]= 2;
65 s->plane[plane_index].fast_mc= 1;
82 s->m.mb_num = (avctx->
width * avctx->
height + 255) / 256;
85 s->m.me.scratchpad =
av_calloc(avctx->
width + 64, 2*16*2*
sizeof(uint8_t));
88 if (!
s->m.me.scratchpad || !
s->m.me.map || !
s->m.sc.obmc_scratchpad)
117 s->colorspace_type= 0;
121 s->colorspace_type = 1;
134 ff_set_cmp(&
s->mecc,
s->mecc.me_sub_cmp,
s->avctx->me_sub_cmp);
137 if (!
s->input_picture)
144 int size=
s->b_width *
s->b_height << 2*
s->block_max_depth;
145 for(
i=0;
i<
s->max_ref_frames;
i++){
148 if (!
s->ref_mvs[
i] || !
s->ref_scores[
i])
157 static int pix_sum(
const uint8_t * pix,
int line_size,
int w,
int h)
162 for (
i = 0;
i <
h;
i++) {
163 for (j = 0; j <
w; j++) {
167 pix += line_size -
w;
173 static int pix_norm1(
const uint8_t * pix,
int line_size,
int w)
179 for (
i = 0;
i <
w;
i++) {
180 for (j = 0; j <
w; j ++) {
184 pix += line_size -
w;
216 #define P_TOPRIGHT P[3]
217 #define P_MEDIAN P[4]
219 #define FLAG_QPEL 1 //must be 1
222 uint8_t p_buffer[1024];
223 uint8_t i_buffer[1024];
224 uint8_t p_state[
sizeof(
s->block_state)];
225 uint8_t i_state[
sizeof(
s->block_state)];
227 uint8_t *pbbak=
s->c.bytestream;
228 uint8_t *pbbak_start=
s->c.bytestream_start;
229 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
230 const int w=
s->b_width <<
s->block_max_depth;
231 const int h=
s->b_height <<
s->block_max_depth;
232 const int rem_depth=
s->block_max_depth -
level;
233 const int index= (x + y*
w) << rem_depth;
235 int trx= (x+1)<<rem_depth;
236 int try= (y+1)<<rem_depth;
243 int pl =
left->color[0];
244 int pcb=
left->color[1];
245 int pcr=
left->color[2];
249 const int stride=
s->current_picture->linesize[0];
250 const int uvstride=
s->current_picture->linesize[1];
251 const uint8_t *
const current_data[3] = {
s->input_picture->data[0] + (x + y*
stride)*block_w,
252 s->input_picture->data[1] + ((x*block_w)>>
s->chroma_h_shift) + ((y*uvstride*block_w)>>
s->chroma_v_shift),
253 s->input_picture->data[2] + ((x*block_w)>>
s->chroma_h_shift) + ((y*uvstride*block_w)>>
s->chroma_v_shift)};
255 int16_t last_mv[3][2];
257 const int shift= 1+qpel;
263 int ref, best_ref, ref_score, ref_mx, ref_my;
267 set_blocks(
s,
level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
280 last_mv[0][0]=
s->block[
index].mx;
281 last_mv[0][1]=
s->block[
index].my;
282 last_mv[1][0]= right->
mx;
283 last_mv[1][1]= right->
my;
284 last_mv[2][0]= bottom->
mx;
285 last_mv[2][1]= bottom->
my;
298 c->current_mv_penalty=
c->mv_penalty[
s->m.f_code=1] +
MAX_DMV;
300 c->xmin = - x*block_w - 16+3;
301 c->ymin = - y*block_w - 16+3;
302 c->xmax = - (x+1)*block_w + (
w<<(
LOG2_MB_SIZE -
s->block_max_depth)) + 16-3;
303 c->ymax = - (y+1)*block_w + (
h<<(
LOG2_MB_SIZE -
s->block_max_depth)) + 16-3;
327 init_ref(
c, current_data,
s->last_picture[
ref]->data,
NULL, block_w*x, block_w*y, 0);
337 ref_score=
c->sub_motion_search(&
s->m, &ref_mx, &ref_my, ref_score, 0, 0,
level-
LOG2_MB_SIZE+4, block_w);
345 if(score > ref_score){
355 base_bits=
get_rac_count(&
s->c) - 8*(
s->c.bytestream -
s->c.bytestream_start);
358 pc.bytestream= p_buffer;
359 memcpy(p_state,
s->block_state,
sizeof(
s->block_state));
361 if(
level!=
s->block_max_depth)
362 put_rac(&pc, &p_state[4 + s_context], 1);
364 if(
s->ref_frames > 1)
365 put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
367 put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
368 put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
369 p_len= pc.bytestream - pc.bytestream_start;
372 block_s= block_w*block_w;
374 l= (sum + block_s/2)/block_s;
375 iscore =
pix_norm1(current_data[0],
stride, block_w) - 2*l*sum + l*l*block_s;
377 if (
s->nb_planes > 2) {
378 block_s= block_w*block_w>>(
s->chroma_h_shift +
s->chroma_v_shift);
379 sum =
pix_sum(current_data[1], uvstride, block_w>>
s->chroma_h_shift, block_w>>
s->chroma_v_shift);
380 cb= (sum + block_s/2)/block_s;
382 sum =
pix_sum(current_data[2], uvstride, block_w>>
s->chroma_h_shift, block_w>>
s->chroma_v_shift);
383 cr= (sum + block_s/2)/block_s;
390 ic.bytestream= i_buffer;
391 memcpy(i_state,
s->block_state,
sizeof(
s->block_state));
392 if(
level!=
s->block_max_depth)
393 put_rac(&ic, &i_state[4 + s_context], 1);
396 if (
s->nb_planes > 2) {
400 i_len= ic.bytestream - ic.bytestream_start;
403 av_assert1(iscore < 255*255*256 + s->lambda2*10);
409 int varc= iscore >> 8;
410 int vard= score >> 8;
411 if (vard <= 64 || vard < varc)
414 c->scene_change_score+=
s->m.qscale;
417 if(
level!=
s->block_max_depth){
418 put_rac(&
s->c, &
s->block_state[4 + s_context], 0);
425 if(score2 < score && score2 < iscore)
431 memcpy(pbbak, i_buffer, i_len);
433 s->c.bytestream_start= pbbak_start;
434 s->c.bytestream= pbbak + i_len;
435 set_blocks(
s,
level, x, y, l,
cb,
cr, pmx, pmy, 0,
BLOCK_INTRA);
436 memcpy(
s->block_state, i_state,
sizeof(
s->block_state));
439 memcpy(pbbak, p_buffer, p_len);
441 s->c.bytestream_start= pbbak_start;
442 s->c.bytestream= pbbak + p_len;
443 set_blocks(
s,
level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
444 memcpy(
s->block_state, p_state,
sizeof(
s->block_state));
450 const int w=
s->b_width <<
s->block_max_depth;
451 const int rem_depth=
s->block_max_depth -
level;
452 const int index= (x + y*
w) << rem_depth;
453 int trx= (x+1)<<rem_depth;
459 int pl =
left->color[0];
460 int pcb=
left->color[1];
461 int pcr=
left->color[2];
469 set_blocks(
s,
level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
473 if(
level!=
s->block_max_depth){
475 put_rac(&
s->c, &
s->block_state[4 + s_context], 1);
477 put_rac(&
s->c, &
s->block_state[4 + s_context], 0);
489 if (
s->nb_planes > 2) {
493 set_blocks(
s,
level, x, y,
b->color[0],
b->color[1],
b->color[2], pmx, pmy, 0,
BLOCK_INTRA);
497 if(
s->ref_frames > 1)
498 put_symbol(&
s->c, &
s->block_state[128 + 1024 + 32*ref_context],
b->ref, 0);
499 put_symbol(&
s->c, &
s->block_state[128 + 32*mx_context],
b->mx - pmx, 1);
500 put_symbol(&
s->c, &
s->block_state[128 + 32*my_context],
b->my - pmy, 1);
501 set_blocks(
s,
level, x, y, pl, pcb, pcr,
b->mx,
b->my,
b->ref, 0);
507 Plane *p= &
s->plane[plane_index];
508 const int block_size =
MB_SIZE >>
s->block_max_depth;
509 const int block_w = plane_index ? block_size>>
s->chroma_h_shift : block_size;
510 const int block_h = plane_index ? block_size>>
s->chroma_v_shift : block_size;
512 const int obmc_stride= plane_index ? (2*block_size)>>
s->chroma_h_shift : 2*block_size;
513 const int ref_stride=
s->current_picture->linesize[plane_index];
514 const uint8_t *
src =
s->input_picture->data[plane_index];
515 IDWTELEM *dst= (
IDWTELEM*)
s->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4;
516 const int b_stride =
s->b_width <<
s->block_max_depth;
519 int index= mb_x + mb_y*b_stride;
528 b->color[plane_index]= 0;
529 memset(dst, 0, obmc_stride*obmc_stride*
sizeof(
IDWTELEM));
532 int mb_x2= mb_x + (
i &1) - 1;
533 int mb_y2= mb_y + (
i>>1) - 1;
534 int x= block_w*mb_x2 + block_w/2;
535 int y= block_h*mb_y2 + block_h/2;
538 x, y, block_w, block_h,
w,
h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
540 for(y2=
FFMAX(y, 0); y2<
FFMIN(
h, y+block_h); y2++){
541 for(x2=
FFMAX(x, 0); x2<
FFMIN(
w, x+block_w); x2++){
542 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;
543 int obmc_v= obmc[
index];
545 if(y<0) obmc_v += obmc[
index + block_h*obmc_stride];
546 if(x<0) obmc_v += obmc[
index + block_w];
547 if(y+block_h>
h) obmc_v += obmc[
index - block_h*obmc_stride];
548 if(x+block_w>
w) obmc_v += obmc[
index - block_w];
554 aa += obmc_v * obmc_v;
564 const int b_stride =
s->b_width <<
s->block_max_depth;
565 const int b_height =
s->b_height<<
s->block_max_depth;
566 int index= x + y*b_stride;
576 if(x<0 || x>=b_stride || y>=b_height)
602 Plane *p= &
s->plane[plane_index];
603 const int block_size =
MB_SIZE >>
s->block_max_depth;
604 const int block_w = plane_index ? block_size>>
s->chroma_h_shift : block_size;
605 const int block_h = plane_index ? block_size>>
s->chroma_v_shift : block_size;
606 const int obmc_stride= plane_index ? (2*block_size)>>
s->chroma_h_shift : 2*block_size;
607 const int ref_stride=
s->current_picture->linesize[plane_index];
608 uint8_t *dst=
s->current_picture->data[plane_index];
609 const uint8_t *
src =
s->input_picture->data[plane_index];
611 uint8_t *cur =
s->scratchbuf;
612 uint8_t *
tmp =
s->emu_edge_buffer;
613 const int b_stride =
s->b_width <<
s->block_max_depth;
614 const int b_height =
s->b_height<<
s->block_max_depth;
620 int sx= block_w*mb_x - block_w/2;
621 int sy= block_h*mb_y - block_h/2;
622 int x0=
FFMAX(0,-sx);
623 int y0=
FFMAX(0,-sy);
624 int x1=
FFMIN(block_w*2,
w-sx);
625 int y1=
FFMIN(block_h*2,
h-sy);
630 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);
632 for(y=y0; y<y1; y++){
633 const uint8_t *obmc1= obmc_edged[y];
635 uint8_t *cur1 = cur + y*ref_stride;
636 uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
637 for(x=x0; x<x1; x++){
638 #if FRAC_BITS >= LOG2_OBMC_MAX
644 if(v&(~255)) v= ~(v>>31);
651 && (mb_x == 0 || mb_x == b_stride-1)
652 && (mb_y == 0 || mb_y == b_height-1)){
662 memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
673 distortion =
ff_w97_32_c(&
s->m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
675 distortion =
ff_w53_32_c(&
s->m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
679 int off = sx+16*(
i&1) + (sy+16*(
i>>1))*ref_stride;
680 distortion +=
s->mecc.me_cmp[0](&
s->m,
src + off, dst + off, ref_stride, 16);
685 distortion =
s->mecc.me_cmp[0](&
s->m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
696 if(mb_x == b_stride-2)
699 return distortion + rate*penalty_factor;
704 Plane *p= &
s->plane[plane_index];
705 const int block_size =
MB_SIZE >>
s->block_max_depth;
706 const int block_w = plane_index ? block_size>>
s->chroma_h_shift : block_size;
707 const int block_h = plane_index ? block_size>>
s->chroma_v_shift : block_size;
709 const int obmc_stride= plane_index ? (2*block_size)>>
s->chroma_h_shift : 2*block_size;
710 const int ref_stride=
s->current_picture->linesize[plane_index];
711 uint8_t *dst=
s->current_picture->data[plane_index];
712 const uint8_t *
src =
s->input_picture->data[plane_index];
716 const int b_stride =
s->b_width <<
s->block_max_depth;
726 int mb_x2= mb_x + (
i%3) - 1;
727 int mb_y2= mb_y + (
i/3) - 1;
728 int x= block_w*mb_x2 + block_w/2;
729 int y= block_h*mb_y2 + block_h/2;
732 x, y, block_w, block_h,
w,
h, 0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
735 for(y2= y; y2<0; y2++)
736 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, block_w);
737 for(y2=
h; y2<y+block_h; y2++)
738 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, block_w);
740 for(y2= y; y2<y+block_h; y2++)
741 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, -x);
744 for(y2= y; y2<y+block_h; y2++)
745 memcpy(dst +
w + y2*ref_stride,
src +
w + y2*ref_stride, x+block_w -
w);
749 distortion +=
s->mecc.me_cmp[block_w==8](&
s->m,
src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
763 for(
i=merged?4:0;
i<9;
i++){
764 static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
768 return distortion + rate*penalty_factor;
772 const int w=
b->width;
773 const int h=
b->height;
778 int *runs =
s->run_buffer;
785 int l=0, lt=0, t=0, rt=0;
807 if(px<b->parent->width && py<b->parent->height)
808 p= parent[px + py*2*
stride];
812 runs[run_index++]=
run;
820 max_index= run_index;
821 runs[run_index++]=
run;
823 run= runs[run_index++];
826 if(run_index <= max_index)
830 if(
s->c.bytestream_end -
s->c.bytestream <
w*40){
836 int l=0, lt=0, t=0, rt=0;
858 if(px<b->parent->width && py<b->parent->height)
859 p= parent[px + py*2*
stride];
867 run= runs[run_index++];
869 if(run_index <= max_index)
879 int l2= 2*
FFABS(l) + (l<0);
899 uint8_t (*obmc_edged)[
MB_SIZE * 2],
int *best_rd)
901 const int b_stride=
s->b_width <<
s->block_max_depth;
909 block->color[0] = p[0];
910 block->color[1] = p[1];
911 block->color[2] = p[2];
914 rd =
get_block_rd(
s, mb_x, mb_y, 0, obmc_edged) +
s->intra_penalty;
929 const int b_stride =
s->b_width <<
s->block_max_depth;
939 value =
s->me_cache_generation + (p0 >> 10) + p1 * (1 << 6) + (
block->ref << 12);
961 const int b_stride=
s->b_width <<
s->block_max_depth;
970 backup[0] =
block[0];
971 backup[1] =
block[1];
972 backup[2] =
block[b_stride];
973 backup[3] =
block[b_stride + 1];
980 value=
s->me_cache_generation + (p0>>10) + (p1<<6) + (
block->ref<<12);
1000 block[b_stride]= backup[2];
1001 block[b_stride+1]= backup[3];
1007 int pass, mb_x, mb_y;
1008 const int b_width =
s->b_width <<
s->block_max_depth;
1009 const int b_height=
s->b_height <<
s->block_max_depth;
1010 const int b_stride= b_width;
1015 uint8_t
state[
sizeof(
s->block_state)];
1016 memcpy(
state,
s->block_state,
sizeof(
s->block_state));
1017 for(mb_y= 0; mb_y<
s->b_height; mb_y++)
1018 for(mb_x= 0; mb_x<
s->b_width; mb_x++)
1021 memcpy(
s->block_state,
state,
sizeof(
s->block_state));
1027 for(mb_y= 0; mb_y<b_height; mb_y++){
1028 for(mb_x= 0; mb_x<b_width; mb_x++){
1029 int dia_change,
i, j,
ref;
1030 int best_rd= INT_MAX, ref_rd;
1032 const int index= mb_x + mb_y * b_stride;
1042 const int b_w= (
MB_SIZE >>
s->block_max_depth);
1051 if(!
s->me_cache_generation)
1052 memset(
s->me_cache, 0,
sizeof(
s->me_cache));
1053 s->me_cache_generation += 1<<22;
1058 for (y = 0; y < b_w * 2; y++)
1059 memcpy(obmc_edged[y],
ff_obmc_tab[
s->block_max_depth] + y * b_w * 2, b_w * 2);
1061 for(y=0; y<b_w*2; y++)
1062 memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1063 if(mb_x==b_stride-1)
1064 for(y=0; y<b_w*2; y++)
1065 memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1067 for(x=0; x<b_w*2; x++)
1068 obmc_edged[0][x] += obmc_edged[b_w-1][x];
1069 for(y=1; y<b_w; y++)
1070 memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1072 if(mb_y==b_height-1){
1073 for(x=0; x<b_w*2; x++)
1074 obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
1075 for(y=b_w; y<b_w*2-1; y++)
1076 memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1081 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
1082 const uint8_t *
src =
s->input_picture->data[0];
1083 uint8_t *dst=
s->current_picture->data[0];
1084 const int stride=
s->current_picture->linesize[0];
1085 const int block_w=
MB_SIZE >>
s->block_max_depth;
1086 const int block_h=
MB_SIZE >>
s->block_max_depth;
1087 const int sx= block_w*mb_x - block_w/2;
1088 const int sy= block_h*mb_y - block_h/2;
1089 const int w=
s->plane[0].width;
1090 const int h=
s->plane[0].height;
1095 for(y=
h; y<sy+block_h*2; y++)
1098 for(y=sy; y<sy+block_h*2; y++)
1101 if(sx+block_w*2 >
w){
1102 for(y=sy; y<sy+block_h*2; y++)
1108 for(
i=0;
i <
s->nb_planes;
i++)
1121 int16_t (*mvr)[2]= &
s->ref_mvs[
ref][
index];
1130 check_block_inter(
s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1136 check_block_inter(
s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1141 int newx =
block->mx;
1142 int newy =
block->my;
1143 int dia_size =
s->iterative_dia_size ?
s->iterative_dia_size :
FFMAX(
s->avctx->dia_size, 1);
1145 for(
i=0;
i < dia_size;
i++){
1147 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx+4*(
i-j), newy+(4*j), obmc_edged, &best_rd);
1148 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx-4*(
i-j), newy-(4*j), obmc_edged, &best_rd);
1149 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx-(4*j), newy+4*(
i-j), obmc_edged, &best_rd);
1150 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx+(4*j), newy-4*(
i-j), obmc_edged, &best_rd);
1156 static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1163 mvr[0][0]=
block->mx;
1164 mvr[0][1]=
block->my;
1165 if(ref_rd > best_rd){
1192 if(
s->block_max_depth == 1){
1194 for(mb_y= 0; mb_y<b_height; mb_y+=2){
1195 for(mb_x= 0; mb_x<b_width; mb_x+=2){
1197 int best_rd, init_rd;
1198 const int index= mb_x + mb_y * b_stride;
1203 b[2]=
b[0]+b_stride;
1210 if(!
s->me_cache_generation)
1211 memset(
s->me_cache, 0,
sizeof(
s->me_cache));
1212 s->me_cache_generation += 1<<22;
1218 (
b[0]->mx +
b[1]->mx +
b[2]->mx +
b[3]->mx + 2) >> 2,
1219 (
b[0]->my +
b[1]->my +
b[2]->my +
b[3]->my + 2) >> 2, 0, &best_rd);
1225 if(init_rd != best_rd)
1256 const int w=
b->width;
1257 const int h=
b->height;
1260 int x,y, thres1, thres2;
1278 if((
unsigned)(
i+thres1) > thres2){
1298 if((
unsigned)(
i+thres1) > thres2){
1317 const int w=
b->width;
1318 const int h=
b->height;
1339 const int w=
b->width;
1340 const int h=
b->height;
1343 for(y=
h-1; y>=0; y--){
1344 for(x=
w-1; x>=0; x--){
1363 const int w=
b->width;
1364 const int h=
b->height;
1387 int plane_index,
level, orientation;
1389 for(plane_index=0; plane_index<
FFMIN(
s->nb_planes, 2); plane_index++){
1391 for(orientation=
level ? 1:0; orientation<4; orientation++){
1392 if(orientation==2)
continue;
1393 put_symbol(&
s->c,
s->header_state,
s->plane[plane_index].band[
level][orientation].qlog, 1);
1403 memset(kstate,
MID_STATE,
sizeof(kstate));
1406 if(
s->keyframe ||
s->always_reset){
1408 s->last_spatial_decomposition_type=
1412 s->last_block_max_depth= 0;
1413 for(plane_index=0; plane_index<2; plane_index++){
1414 Plane *p= &
s->plane[plane_index];
1422 put_rac(&
s->c,
s->header_state,
s->always_reset);
1423 put_symbol(&
s->c,
s->header_state,
s->temporal_decomposition_type, 0);
1424 put_symbol(&
s->c,
s->header_state,
s->temporal_decomposition_count, 0);
1425 put_symbol(&
s->c,
s->header_state,
s->spatial_decomposition_count, 0);
1427 if (
s->nb_planes > 2) {
1431 put_rac(&
s->c,
s->header_state,
s->spatial_scalability);
1440 for(plane_index=0; plane_index<
FFMIN(
s->nb_planes, 2); plane_index++){
1441 Plane *p= &
s->plane[plane_index];
1446 put_rac(&
s->c,
s->header_state, update_mc);
1448 for(plane_index=0; plane_index<
FFMIN(
s->nb_planes, 2); plane_index++){
1449 Plane *p= &
s->plane[plane_index];
1456 if(
s->last_spatial_decomposition_count !=
s->spatial_decomposition_count){
1458 put_symbol(&
s->c,
s->header_state,
s->spatial_decomposition_count, 0);
1464 put_symbol(&
s->c,
s->header_state,
s->spatial_decomposition_type -
s->last_spatial_decomposition_type, 1);
1466 put_symbol(&
s->c,
s->header_state,
s->mv_scale -
s->last_mv_scale, 1);
1467 put_symbol(&
s->c,
s->header_state,
s->qbias -
s->last_qbias , 1);
1468 put_symbol(&
s->c,
s->header_state,
s->block_max_depth -
s->last_block_max_depth, 1);
1476 for(plane_index=0; plane_index<2; plane_index++){
1477 Plane *p= &
s->plane[plane_index];
1484 s->last_spatial_decomposition_type =
s->spatial_decomposition_type;
1485 s->last_qlog =
s->qlog;
1486 s->last_qbias =
s->qbias;
1487 s->last_mv_scale =
s->mv_scale;
1488 s->last_block_max_depth =
s->block_max_depth;
1489 s->last_spatial_decomposition_count =
s->spatial_decomposition_count;
1502 uint32_t coef_sum= 0;
1503 int level, orientation, delta_qlog;
1506 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1509 const int w=
b->width;
1510 const int h=
b->height;
1514 const int qdiv= (1<<16)/qmul;
1524 coef_sum+=
abs(buf[x+y*
stride]) * qdiv >> 16;
1530 coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1533 s->m.mb_var_sum = coef_sum;
1534 s->m.mc_mb_var_sum = 0;
1536 s->m.mc_mb_var_sum = coef_sum;
1537 s->m.mb_var_sum = 0;
1545 s->qlog+= delta_qlog;
1552 int level, orientation, x, y;
1556 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1560 memset(
s->spatial_idwt_buffer, 0,
sizeof(*
s->spatial_idwt_buffer)*
width*
height);
1561 ibuf[
b->width/2 +
b->height/2*
b->stride]= 256*16;
1564 for(x=0; x<
width; x++){
1565 int64_t
d=
s->spatial_idwt_buffer[x + y*
width]*16;
1569 if (orientation == 2)
1572 if (orientation != 1)
1580 const AVFrame *pict,
int *got_packet)
1586 const int width=
s->avctx->width;
1587 const int height=
s->avctx->height;
1588 int level, orientation, plane_index,
i, y,
ret;
1589 uint8_t rc_header_bak[
sizeof(
s->header_state)];
1590 uint8_t rc_block_bak[
sizeof(
s->block_state)];
1598 for(
i=0;
i <
s->nb_planes;
i++){
1599 int hshift=
i ?
s->chroma_h_shift : 0;
1600 int vshift=
i ?
s->chroma_v_shift : 0;
1602 memcpy(&
s->input_picture->data[
i][y *
s->input_picture->linesize[
i]],
1605 s->mpvencdsp.draw_edges(
s->input_picture->data[
i],
s->input_picture->linesize[
i],
1612 pic =
s->input_picture;
1641 if (
s->current_picture->data[0]) {
1642 int w =
s->avctx->width;
1643 int h =
s->avctx->height;
1645 s->mpvencdsp.draw_edges(
s->current_picture->data[0],
1646 s->current_picture->linesize[0],
w ,
h ,
1648 if (
s->current_picture->data[2]) {
1649 s->mpvencdsp.draw_edges(
s->current_picture->data[1],
1650 s->current_picture->linesize[1],
w>>
s->chroma_h_shift,
h>>
s->chroma_v_shift,
1652 s->mpvencdsp.draw_edges(
s->current_picture->data[2],
1653 s->current_picture->linesize[2],
w>>
s->chroma_h_shift,
h>>
s->chroma_v_shift,
1661 s->m.current_picture_ptr= &
s->m.current_picture;
1662 s->m.current_picture.f =
s->current_picture;
1663 s->m.current_picture.f->pts = pict->
pts;
1665 int block_width = (
width +15)>>4;
1666 int block_height= (
height+15)>>4;
1667 int stride=
s->current_picture->linesize[0];
1672 s->m.avctx=
s->avctx;
1674 s->m. new_picture =
s->input_picture;
1677 s->m.uvlinesize=
s->current_picture->linesize[1];
1680 s->m.mb_width = block_width;
1681 s->m.mb_height= block_height;
1682 s->m.mb_stride=
s->m.mb_width+1;
1683 s->m.b8_stride= 2*
s->m.mb_width+1;
1686 s->m.motion_est=
s->motion_est;
1687 s->m.me.scene_change_score=0;
1691 s->m.unrestricted_mv= 1;
1693 s->m.lambda =
s->lambda;
1699 s->m.hdsp =
s->hdsp;
1701 s->hdsp =
s->m.hdsp;
1706 memcpy(rc_header_bak,
s->header_state,
sizeof(
s->header_state));
1707 memcpy(rc_block_bak,
s->block_state,
sizeof(
s->block_state));
1712 s->spatial_decomposition_count= 5;
1714 while( !(
width >>(
s->chroma_h_shift +
s->spatial_decomposition_count))
1715 || !(
height>>(
s->chroma_v_shift +
s->spatial_decomposition_count)))
1716 s->spatial_decomposition_count--;
1718 if (
s->spatial_decomposition_count <= 0) {
1728 if(
s->last_spatial_decomposition_count !=
s->spatial_decomposition_count){
1729 for(plane_index=0; plane_index <
s->nb_planes; plane_index++){
1735 s->m.misc_bits = 8*(
s->c.bytestream -
s->c.bytestream_start);
1737 s->m.mv_bits = 8*(
s->c.bytestream -
s->c.bytestream_start) -
s->m.misc_bits;
1739 for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1740 Plane *p= &
s->plane[plane_index];
1746 if (!
s->memc_only) {
1748 if(pict->
data[plane_index])
1759 &&
s->m.me.scene_change_score >
s->scenechange_threshold){
1764 s->current_picture->key_frame=1;
1782 ff_spatial_dwt(
s->spatial_dwt_buffer,
s->temp_dwt_buffer,
w,
h,
w,
s->spatial_decomposition_type,
s->spatial_decomposition_count);
1784 if(
s->pass1_rc && plane_index==0){
1786 if (delta_qlog <= INT_MIN)
1791 memcpy(
s->header_state, rc_header_bak,
sizeof(
s->header_state));
1792 memcpy(
s->block_state, rc_block_bak,
sizeof(
s->block_state));
1799 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1805 if (!
s->no_bitstream)
1814 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1821 ff_spatial_idwt(
s->spatial_idwt_buffer,
s->temp_idwt_buffer,
w,
h,
w,
s->spatial_decomposition_type,
s->spatial_decomposition_count);
1825 s->spatial_idwt_buffer[y*
w + x] *= 1 <<
FRAC_BITS;
1835 s->current_picture->data[plane_index][y*
s->current_picture->linesize[plane_index] + x]=
1836 pict->
data[plane_index][y*pict->
linesize[plane_index] + x];
1840 memset(
s->spatial_idwt_buffer, 0,
sizeof(
IDWTELEM)*
w*
h);
1847 if(pict->
data[plane_index])
1850 int d=
s->current_picture->data[plane_index][y*
s->current_picture->linesize[plane_index] + x] - pict->
data[plane_index][y*pict->
linesize[plane_index] + x];
1854 s->avctx->error[plane_index] +=
error;
1855 s->encoding_error[plane_index] =
error;
1865 s->current_picture->pict_type = pic->
pict_type;
1866 s->current_picture->quality = pic->
quality;
1867 s->m.frame_bits = 8*(
s->c.bytestream -
s->c.bytestream_start);
1868 s->m.p_tex_bits =
s->m.frame_bits -
s->m.misc_bits -
s->m.mv_bits;
1869 s->m.current_picture.display_picture_number =
1870 s->m.current_picture.coded_picture_number = avctx->
frame_num;
1871 s->m.current_picture.f->quality = pic->
quality;
1872 s->m.total_bits += 8*(
s->c.bytestream -
s->c.bytestream_start);
1878 s->m.last_pict_type =
s->m.pict_type;
1885 s->current_picture->pict_type);
1892 if (
s->current_picture->key_frame)
1911 #define OFFSET(x) offsetof(SnowContext, x)
1912 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1919 {
"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 },
1920 {
"no_bitstream",
"Skip final bitstream writeout.",
OFFSET(no_bitstream),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VE },
1921 {
"intra_penalty",
"Penalty for intra blocks in block decission",
OFFSET(intra_penalty),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
VE },
1922 {
"iterative_dia_size",
"Dia size for the iterative ME",
OFFSET(iterative_dia_size),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
VE },
1923 {
"sc_threshold",
"Scene change threshold",
OFFSET(scenechange_threshold),
AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX,
VE },
1927 {
"rc_eq",
"Set rate control equation. When computing the expression, besides the standard functions "
1928 "defined in the section 'Expression Evaluation', the following functions are available: "
1929 "bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv "
1930 "fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.",