FFmpeg
snowenc.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/intmath.h"
22 #include "libavutil/libm.h"
23 #include "libavutil/log.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/pixdesc.h"
26 #include "avcodec.h"
27 #include "codec_internal.h"
28 #include "encode.h"
29 #include "internal.h" //For AVCodecInternal.recon_frame
30 #include "me_cmp.h"
31 #include "packet_internal.h"
32 #include "snow_dwt.h"
33 #include "snow.h"
34 
35 #include "rangecoder.h"
36 #include "mathops.h"
37 
38 #include "mpegvideo.h"
39 #include "h263enc.h"
40 
41 static av_cold int encode_init(AVCodecContext *avctx)
42 {
43  SnowContext *s = avctx->priv_data;
44  int plane_index, ret;
45  int i;
46 
47  if(s->pred == DWT_97
48  && (avctx->flags & AV_CODEC_FLAG_QSCALE)
49  && avctx->global_quality == 0){
50  av_log(avctx, AV_LOG_ERROR, "The 9/7 wavelet is incompatible with lossless mode.\n");
51  return AVERROR(EINVAL);
52  }
53 
54  s->spatial_decomposition_type= s->pred; //FIXME add decorrelator type r transform_type
55 
56  s->mv_scale = (avctx->flags & AV_CODEC_FLAG_QPEL) ? 2 : 4;
57  s->block_max_depth= (avctx->flags & AV_CODEC_FLAG_4MV ) ? 1 : 0;
58 
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;
66  }
67 
68  if ((ret = ff_snow_common_init(avctx)) < 0) {
69  return ret;
70  }
71  ff_me_cmp_init(&s->mecc, avctx);
72  ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
73 
74  ff_snow_alloc_blocks(s);
75 
76  s->version=0;
77 
78  s->m.avctx = avctx;
79  s->m.bit_rate= avctx->bit_rate;
80  s->m.lmin = avctx->mb_lmin;
81  s->m.lmax = avctx->mb_lmax;
82  s->m.mb_num = (avctx->width * avctx->height + 255) / 256; // For ratecontrol
83 
84  s->m.me.temp =
85  s->m.me.scratchpad = av_calloc(avctx->width + 64, 2*16*2*sizeof(uint8_t));
86  s->m.sc.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));
87  s->m.me.map = av_mallocz(2 * ME_MAP_SIZE * sizeof(*s->m.me.map));
88  if (!s->m.me.scratchpad || !s->m.me.map || !s->m.sc.obmc_scratchpad)
89  return AVERROR(ENOMEM);
90  s->m.me.score_map = s->m.me.map + ME_MAP_SIZE;
91 
92  ff_h263_encode_init(&s->m); //mv_penalty
93 
94  s->max_ref_frames = av_clip(avctx->refs, 1, MAX_REF_FRAMES);
95 
96  if(avctx->flags&AV_CODEC_FLAG_PASS1){
97  if(!avctx->stats_out)
98  avctx->stats_out = av_mallocz(256);
99 
100  if (!avctx->stats_out)
101  return AVERROR(ENOMEM);
102  }
103  if((avctx->flags&AV_CODEC_FLAG_PASS2) || !(avctx->flags&AV_CODEC_FLAG_QSCALE)){
104  ret = ff_rate_control_init(&s->m);
105  if(ret < 0)
106  return ret;
107  }
108  s->pass1_rc= !(avctx->flags & (AV_CODEC_FLAG_QSCALE|AV_CODEC_FLAG_PASS2));
109 
110  switch(avctx->pix_fmt){
111  case AV_PIX_FMT_YUV444P:
112 // case AV_PIX_FMT_YUV422P:
113  case AV_PIX_FMT_YUV420P:
114 // case AV_PIX_FMT_YUV411P:
115  case AV_PIX_FMT_YUV410P:
116  s->nb_planes = 3;
117  s->colorspace_type= 0;
118  break;
119  case AV_PIX_FMT_GRAY8:
120  s->nb_planes = 1;
121  s->colorspace_type = 1;
122  break;
123 /* case AV_PIX_FMT_RGB32:
124  s->colorspace= 1;
125  break;*/
126  }
127 
128  ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift,
129  &s->chroma_v_shift);
130  if (ret)
131  return ret;
132 
133  ff_set_cmp(&s->mecc, s->mecc.me_cmp, s->avctx->me_cmp);
134  ff_set_cmp(&s->mecc, s->mecc.me_sub_cmp, s->avctx->me_sub_cmp);
135 
136  s->input_picture = av_frame_alloc();
137  if (!s->input_picture)
138  return AVERROR(ENOMEM);
139 
140  if ((ret = ff_snow_get_buffer(s, s->input_picture)) < 0)
141  return ret;
142 
143  if(s->motion_est == FF_ME_ITER){
144  int size= s->b_width * s->b_height << 2*s->block_max_depth;
145  for(i=0; i<s->max_ref_frames; i++){
146  s->ref_mvs[i] = av_calloc(size, sizeof(*s->ref_mvs[i]));
147  s->ref_scores[i] = av_calloc(size, sizeof(*s->ref_scores[i]));
148  if (!s->ref_mvs[i] || !s->ref_scores[i])
149  return AVERROR(ENOMEM);
150  }
151  }
152 
153  return 0;
154 }
155 
156 //near copy & paste from dsputil, FIXME
157 static int pix_sum(const uint8_t * pix, int line_size, int w, int h)
158 {
159  int s, i, j;
160 
161  s = 0;
162  for (i = 0; i < h; i++) {
163  for (j = 0; j < w; j++) {
164  s += pix[0];
165  pix ++;
166  }
167  pix += line_size - w;
168  }
169  return s;
170 }
171 
172 //near copy & paste from dsputil, FIXME
173 static int pix_norm1(const uint8_t * pix, int line_size, int w)
174 {
175  int s, i, j;
176  const uint32_t *sq = ff_square_tab + 256;
177 
178  s = 0;
179  for (i = 0; i < w; i++) {
180  for (j = 0; j < w; j ++) {
181  s += sq[pix[0]];
182  pix ++;
183  }
184  pix += line_size - w;
185  }
186  return s;
187 }
188 
189 static inline int get_penalty_factor(int lambda, int lambda2, int type){
190  switch(type&0xFF){
191  default:
192  case FF_CMP_SAD:
193  return lambda>>FF_LAMBDA_SHIFT;
194  case FF_CMP_DCT:
195  return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
196  case FF_CMP_W53:
197  return (4*lambda)>>(FF_LAMBDA_SHIFT);
198  case FF_CMP_W97:
199  return (2*lambda)>>(FF_LAMBDA_SHIFT);
200  case FF_CMP_SATD:
201  case FF_CMP_DCT264:
202  return (2*lambda)>>FF_LAMBDA_SHIFT;
203  case FF_CMP_RD:
204  case FF_CMP_PSNR:
205  case FF_CMP_SSE:
206  case FF_CMP_NSSE:
207  return lambda2>>FF_LAMBDA_SHIFT;
208  case FF_CMP_BIT:
209  return 1;
210  }
211 }
212 
213 //FIXME copy&paste
214 #define P_LEFT P[1]
215 #define P_TOP P[2]
216 #define P_TOPRIGHT P[3]
217 #define P_MEDIAN P[4]
218 #define P_MV1 P[9]
219 #define FLAG_QPEL 1 //must be 1
220 
221 static int encode_q_branch(SnowContext *s, int level, int x, int y){
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)];
226  RangeCoder pc, ic;
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;
234  const int block_w= 1<<(LOG2_MB_SIZE - level);
235  int trx= (x+1)<<rem_depth;
236  int try= (y+1)<<rem_depth;
237  const BlockNode *left = x ? &s->block[index-1] : &null_block;
238  const BlockNode *top = y ? &s->block[index-w] : &null_block;
239  const BlockNode *right = trx<w ? &s->block[index+1] : &null_block;
240  const BlockNode *bottom= try<h ? &s->block[index+w] : &null_block;
241  const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
242  const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
243  int pl = left->color[0];
244  int pcb= left->color[1];
245  int pcr= left->color[2];
246  int pmx, pmy;
247  int mx=0, my=0;
248  int l,cr,cb;
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)};
254  int P[10][2];
255  int16_t last_mv[3][2];
256  int qpel= !!(s->avctx->flags & AV_CODEC_FLAG_QPEL); //unused
257  const int shift= 1+qpel;
258  MotionEstContext *c= &s->m.me;
259  int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
260  int mx_context= av_log2(2*FFABS(left->mx - top->mx));
261  int my_context= av_log2(2*FFABS(left->my - top->my));
262  int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
263  int ref, best_ref, ref_score, ref_mx, ref_my;
264 
265  av_assert0(sizeof(s->block_state) >= 256);
266  if(s->keyframe){
267  set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
268  return 0;
269  }
270 
271 // clip predictors / edge ?
272 
273  P_LEFT[0]= left->mx;
274  P_LEFT[1]= left->my;
275  P_TOP [0]= top->mx;
276  P_TOP [1]= top->my;
277  P_TOPRIGHT[0]= tr->mx;
278  P_TOPRIGHT[1]= tr->my;
279 
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;
286 
287  s->m.mb_stride=2;
288  s->m.mb_x=
289  s->m.mb_y= 0;
290  c->skip= 0;
291 
292  av_assert1(c-> stride == stride);
293  av_assert1(c->uvstride == uvstride);
294 
295  c->penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
296  c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
297  c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);
298  c->current_mv_penalty= c->mv_penalty[s->m.f_code=1] + MAX_DMV;
299 
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;
304 
305  if(P_LEFT[0] > (c->xmax<<shift)) P_LEFT[0] = (c->xmax<<shift);
306  if(P_LEFT[1] > (c->ymax<<shift)) P_LEFT[1] = (c->ymax<<shift);
307  if(P_TOP[0] > (c->xmax<<shift)) P_TOP[0] = (c->xmax<<shift);
308  if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift);
309  if(P_TOPRIGHT[0] < (c->xmin * (1<<shift))) P_TOPRIGHT[0]= (c->xmin * (1<<shift));
310  if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); //due to pmx no clip
311  if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
312 
313  P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
314  P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
315 
316  if (!y) {
317  c->pred_x= P_LEFT[0];
318  c->pred_y= P_LEFT[1];
319  } else {
320  c->pred_x = P_MEDIAN[0];
321  c->pred_y = P_MEDIAN[1];
322  }
323 
324  score= INT_MAX;
325  best_ref= 0;
326  for(ref=0; ref<s->ref_frames; ref++){
327  init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0);
328 
329  ref_score= ff_epzs_motion_search(&s->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
330  (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
331 
332  av_assert2(ref_mx >= c->xmin);
333  av_assert2(ref_mx <= c->xmax);
334  av_assert2(ref_my >= c->ymin);
335  av_assert2(ref_my <= c->ymax);
336 
337  ref_score= c->sub_motion_search(&s->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
338  ref_score= ff_get_mb_score(&s->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
339  ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
340  if(s->ref_mvs[ref]){
341  s->ref_mvs[ref][index][0]= ref_mx;
342  s->ref_mvs[ref][index][1]= ref_my;
343  s->ref_scores[ref][index]= ref_score;
344  }
345  if(score > ref_score){
346  score= ref_score;
347  best_ref= ref;
348  mx= ref_mx;
349  my= ref_my;
350  }
351  }
352  //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
353 
354  // subpel search
355  base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
356  pc= s->c;
357  pc.bytestream_start=
358  pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo
359  memcpy(p_state, s->block_state, sizeof(s->block_state));
360 
361  if(level!=s->block_max_depth)
362  put_rac(&pc, &p_state[4 + s_context], 1);
363  put_rac(&pc, &p_state[1 + left->type + top->type], 0);
364  if(s->ref_frames > 1)
365  put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
366  pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
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;
370  score += (s->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;
371 
372  block_s= block_w*block_w;
373  sum = pix_sum(current_data[0], stride, 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;
376 
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;
381  // iscore += pix_norm1(&current_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*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;
384  // iscore += pix_norm1(&current_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
385  }else
386  cb = cr = 0;
387 
388  ic= s->c;
389  ic.bytestream_start=
390  ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo
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);
394  put_rac(&ic, &i_state[1 + left->type + top->type], 1);
395  put_symbol(&ic, &i_state[32], l-pl , 1);
396  if (s->nb_planes > 2) {
397  put_symbol(&ic, &i_state[64], cb-pcb, 1);
398  put_symbol(&ic, &i_state[96], cr-pcr, 1);
399  }
400  i_len= ic.bytestream - ic.bytestream_start;
401  iscore += (s->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;
402 
403  av_assert1(iscore < 255*255*256 + s->lambda2*10);
404  av_assert1(iscore >= 0);
405  av_assert1(l>=0 && l<=255);
406  av_assert1(pl>=0 && pl<=255);
407 
408  if(level==0){
409  int varc= iscore >> 8;
410  int vard= score >> 8;
411  if (vard <= 64 || vard < varc)
412  c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
413  else
414  c->scene_change_score+= s->m.qscale;
415  }
416 
417  if(level!=s->block_max_depth){
418  put_rac(&s->c, &s->block_state[4 + s_context], 0);
419  score2 = encode_q_branch(s, level+1, 2*x+0, 2*y+0);
420  score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+0);
421  score2+= encode_q_branch(s, level+1, 2*x+0, 2*y+1);
422  score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+1);
423  score2+= s->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead
424 
425  if(score2 < score && score2 < iscore)
426  return score2;
427  }
428 
429  if(iscore < score){
430  pred_mv(s, &pmx, &pmy, 0, left, top, tr);
431  memcpy(pbbak, i_buffer, i_len);
432  s->c= ic;
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));
437  return iscore;
438  }else{
439  memcpy(pbbak, p_buffer, p_len);
440  s->c= pc;
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));
445  return score;
446  }
447 }
448 
449 static void encode_q_branch2(SnowContext *s, int level, int x, int y){
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;
454  BlockNode *b= &s->block[index];
455  const BlockNode *left = x ? &s->block[index-1] : &null_block;
456  const BlockNode *top = y ? &s->block[index-w] : &null_block;
457  const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
458  const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
459  int pl = left->color[0];
460  int pcb= left->color[1];
461  int pcr= left->color[2];
462  int pmx, pmy;
463  int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
464  int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 16*!!b->ref;
465  int my_context= av_log2(2*FFABS(left->my - top->my)) + 16*!!b->ref;
466  int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
467 
468  if(s->keyframe){
469  set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
470  return;
471  }
472 
473  if(level!=s->block_max_depth){
474  if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){
475  put_rac(&s->c, &s->block_state[4 + s_context], 1);
476  }else{
477  put_rac(&s->c, &s->block_state[4 + s_context], 0);
478  encode_q_branch2(s, level+1, 2*x+0, 2*y+0);
479  encode_q_branch2(s, level+1, 2*x+1, 2*y+0);
480  encode_q_branch2(s, level+1, 2*x+0, 2*y+1);
481  encode_q_branch2(s, level+1, 2*x+1, 2*y+1);
482  return;
483  }
484  }
485  if(b->type & BLOCK_INTRA){
486  pred_mv(s, &pmx, &pmy, 0, left, top, tr);
487  put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);
488  put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);
489  if (s->nb_planes > 2) {
490  put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);
491  put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);
492  }
493  set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0, BLOCK_INTRA);
494  }else{
495  pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);
496  put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);
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);
502  }
503 }
504 
505 static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index){
506  int i, x2, y2;
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;
511  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
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; //FIXME change to unsigned
516  const int b_stride = s->b_width << s->block_max_depth;
517  const int w= p->width;
518  const int h= p->height;
519  int index= mb_x + mb_y*b_stride;
520  BlockNode *b= &s->block[index];
521  BlockNode backup= *b;
522  int ab=0;
523  int aa=0;
524 
525  av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc stuff above
526 
527  b->type|= BLOCK_INTRA;
528  b->color[plane_index]= 0;
529  memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));
530 
531  for(i=0; i<4; i++){
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;
536 
537  add_yblock(s, 0, NULL, dst + (i&1)*block_w + (i>>1)*obmc_stride*block_h, NULL, obmc,
538  x, y, block_w, block_h, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
539 
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];
544  int d;
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];
549  //FIXME precalculate this or simplify it somehow else
550 
551  d = -dst[index] + (1<<(FRAC_BITS-1));
552  dst[index] = d;
553  ab += (src[x2 + y2*ref_stride] - (d>>FRAC_BITS)) * obmc_v;
554  aa += obmc_v * obmc_v; //FIXME precalculate this
555  }
556  }
557  }
558  *b= backup;
559 
560  return av_clip_uint8( ROUNDED_DIV(ab<<LOG2_OBMC_MAX, aa) ); //FIXME we should not need clipping
561 }
562 
563 static inline int get_block_bits(SnowContext *s, int x, int y, int w){
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;
567  const BlockNode *b = &s->block[index];
568  const BlockNode *left = x ? &s->block[index-1] : &null_block;
569  const BlockNode *top = y ? &s->block[index-b_stride] : &null_block;
570  const BlockNode *tl = y && x ? &s->block[index-b_stride-1] : left;
571  const BlockNode *tr = y && x+w<b_stride ? &s->block[index-b_stride+w] : tl;
572  int dmx, dmy;
573 // int mx_context= av_log2(2*FFABS(left->mx - top->mx));
574 // int my_context= av_log2(2*FFABS(left->my - top->my));
575 
576  if(x<0 || x>=b_stride || y>=b_height)
577  return 0;
578 /*
579 1 0 0
580 01X 1-2 1
581 001XX 3-6 2-3
582 0001XXX 7-14 4-7
583 00001XXXX 15-30 8-15
584 */
585 //FIXME try accurate rate
586 //FIXME intra and inter predictors if surrounding blocks are not the same type
587  if(b->type & BLOCK_INTRA){
588  return 3+2*( av_log2(2*FFABS(left->color[0] - b->color[0]))
589  + av_log2(2*FFABS(left->color[1] - b->color[1]))
590  + av_log2(2*FFABS(left->color[2] - b->color[2])));
591  }else{
592  pred_mv(s, &dmx, &dmy, b->ref, left, top, tr);
593  dmx-= b->mx;
594  dmy-= b->my;
595  return 2*(1 + av_log2(2*FFABS(dmx)) //FIXME kill the 2* can be merged in lambda
596  + av_log2(2*FFABS(dmy))
597  + av_log2(2*b->ref));
598  }
599 }
600 
601 static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t (*obmc_edged)[MB_SIZE * 2]){
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];
610  IDWTELEM *pred= (IDWTELEM*)s->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4;
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;
615  const int w= p->width;
616  const int h= p->height;
617  int distortion;
618  int rate= 0;
619  const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
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);
626  int i,x,y;
627 
628  av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below chckinhg only block_w
629 
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);
631 
632  for(y=y0; y<y1; y++){
633  const uint8_t *obmc1= obmc_edged[y];
634  const IDWTELEM *pred1 = pred + y*obmc_stride;
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
639  int v = (cur1[x] * obmc1[x]) << (FRAC_BITS - LOG2_OBMC_MAX);
640 #else
641  int v = (cur1[x] * obmc1[x] + (1<<(LOG2_OBMC_MAX - FRAC_BITS-1))) >> (LOG2_OBMC_MAX - FRAC_BITS);
642 #endif
643  v = (v + pred1[x]) >> FRAC_BITS;
644  if(v&(~255)) v= ~(v>>31);
645  dst1[x] = v;
646  }
647  }
648 
649  /* copy the regions where obmc[] = (uint8_t)256 */
650  if(LOG2_OBMC_MAX == 8
651  && (mb_x == 0 || mb_x == b_stride-1)
652  && (mb_y == 0 || mb_y == b_height-1)){
653  if(mb_x == 0)
654  x1 = block_w;
655  else
656  x0 = block_w;
657  if(mb_y == 0)
658  y1 = block_h;
659  else
660  y0 = block_h;
661  for(y=y0; y<y1; y++)
662  memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
663  }
664 
665  if(block_w==16){
666  /* FIXME rearrange dsputil to fit 32x32 cmp functions */
667  /* FIXME check alignment of the cmp wavelet vs the encoding wavelet */
668  /* FIXME cmps overlap but do not cover the wavelet's whole support.
669  * So improving the score of one block is not strictly guaranteed
670  * to improve the score of the whole frame, thus iterative motion
671  * estimation does not always converge. */
672  if(s->avctx->me_cmp == FF_CMP_W97)
673  distortion = ff_w97_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
674  else if(s->avctx->me_cmp == FF_CMP_W53)
675  distortion = ff_w53_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
676  else{
677  distortion = 0;
678  for(i=0; i<4; i++){
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);
681  }
682  }
683  }else{
684  av_assert2(block_w==8);
685  distortion = s->mecc.me_cmp[0](&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
686  }
687 
688  if(plane_index==0){
689  for(i=0; i<4; i++){
690 /* ..RRr
691  * .RXx.
692  * rxx..
693  */
694  rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
695  }
696  if(mb_x == b_stride-2)
697  rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);
698  }
699  return distortion + rate*penalty_factor;
700 }
701 
702 static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){
703  int i, y2;
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;
708  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
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];
713  //FIXME zero_dst is const but add_yblock changes dst if add is 0 (this is never the case for dst=zero_dst
714  // const has only been removed from zero_dst to suppress a warning
715  static IDWTELEM zero_dst[4096]; //FIXME
716  const int b_stride = s->b_width << s->block_max_depth;
717  const int w= p->width;
718  const int h= p->height;
719  int distortion= 0;
720  int rate= 0;
721  const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
722 
723  av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below
724 
725  for(i=0; i<9; i++){
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;
730 
731  add_yblock(s, 0, NULL, zero_dst, dst, obmc,
732  x, y, block_w, block_h, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
733 
734  //FIXME find a cleaner/simpler way to skip the outside stuff
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);
739  if(x<0){
740  for(y2= y; y2<y+block_h; y2++)
741  memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
742  }
743  if(x+block_w > w){
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);
746  }
747 
748  av_assert1(block_w== 8 || block_w==16);
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);
750  }
751 
752  if(plane_index==0){
753  BlockNode *b= &s->block[mb_x+mb_y*b_stride];
754  int merged= same_block(b,b+1) && same_block(b,b+b_stride) && same_block(b,b+b_stride+1);
755 
756 /* ..RRRr
757  * .RXXx.
758  * .RXXx.
759  * rxxx.
760  */
761  if(merged)
762  rate = get_block_bits(s, mb_x, mb_y, 2);
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}};
765  rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);
766  }
767  }
768  return distortion + rate*penalty_factor;
769 }
770 
771 static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
772  const int w= b->width;
773  const int h= b->height;
774  int x, y;
775 
776  if(1){
777  int run=0;
778  int *runs = s->run_buffer;
779  int run_index=0;
780  int max_index;
781 
782  for(y=0; y<h; y++){
783  for(x=0; x<w; x++){
784  int v, p=0;
785  int /*ll=0, */l=0, lt=0, t=0, rt=0;
786  v= src[x + y*stride];
787 
788  if(y){
789  t= src[x + (y-1)*stride];
790  if(x){
791  lt= src[x - 1 + (y-1)*stride];
792  }
793  if(x + 1 < w){
794  rt= src[x + 1 + (y-1)*stride];
795  }
796  }
797  if(x){
798  l= src[x - 1 + y*stride];
799  /*if(x > 1){
800  if(orientation==1) ll= src[y + (x-2)*stride];
801  else ll= src[x - 2 + y*stride];
802  }*/
803  }
804  if(parent){
805  int px= x>>1;
806  int py= y>>1;
807  if(px<b->parent->width && py<b->parent->height)
808  p= parent[px + py*2*stride];
809  }
810  if(!(/*ll|*/l|lt|t|rt|p)){
811  if(v){
812  runs[run_index++]= run;
813  run=0;
814  }else{
815  run++;
816  }
817  }
818  }
819  }
820  max_index= run_index;
821  runs[run_index++]= run;
822  run_index=0;
823  run= runs[run_index++];
824 
825  put_symbol2(&s->c, b->state[30], max_index, 0);
826  if(run_index <= max_index)
827  put_symbol2(&s->c, b->state[1], run, 3);
828 
829  for(y=0; y<h; y++){
830  if(s->c.bytestream_end - s->c.bytestream < w*40){
831  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
832  return AVERROR(ENOMEM);
833  }
834  for(x=0; x<w; x++){
835  int v, p=0;
836  int /*ll=0, */l=0, lt=0, t=0, rt=0;
837  v= src[x + y*stride];
838 
839  if(y){
840  t= src[x + (y-1)*stride];
841  if(x){
842  lt= src[x - 1 + (y-1)*stride];
843  }
844  if(x + 1 < w){
845  rt= src[x + 1 + (y-1)*stride];
846  }
847  }
848  if(x){
849  l= src[x - 1 + y*stride];
850  /*if(x > 1){
851  if(orientation==1) ll= src[y + (x-2)*stride];
852  else ll= src[x - 2 + y*stride];
853  }*/
854  }
855  if(parent){
856  int px= x>>1;
857  int py= y>>1;
858  if(px<b->parent->width && py<b->parent->height)
859  p= parent[px + py*2*stride];
860  }
861  if(/*ll|*/l|lt|t|rt|p){
862  int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
863 
864  put_rac(&s->c, &b->state[0][context], !!v);
865  }else{
866  if(!run){
867  run= runs[run_index++];
868 
869  if(run_index <= max_index)
870  put_symbol2(&s->c, b->state[1], run, 3);
871  av_assert2(v);
872  }else{
873  run--;
874  av_assert2(!v);
875  }
876  }
877  if(v){
878  int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
879  int l2= 2*FFABS(l) + (l<0);
880  int t2= 2*FFABS(t) + (t<0);
881 
882  put_symbol2(&s->c, b->state[context + 2], FFABS(v)-1, context-4);
883  put_rac(&s->c, &b->state[0][16 + 1 + 3 + ff_quant3bA[l2&0xFF] + 3*ff_quant3bA[t2&0xFF]], v<0);
884  }
885  }
886  }
887  }
888  return 0;
889 }
890 
891 static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
892 // encode_subband_qtree(s, b, src, parent, stride, orientation);
893 // encode_subband_z0run(s, b, src, parent, stride, orientation);
894  return encode_subband_c0run(s, b, src, parent, stride, orientation);
895 // encode_subband_dzr(s, b, src, parent, stride, orientation);
896 }
897 
898 static av_always_inline int check_block_intra(SnowContext *s, int mb_x, int mb_y, int p[3],
899  uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd)
900 {
901  const int b_stride= s->b_width << s->block_max_depth;
902  BlockNode *block= &s->block[mb_x + mb_y * b_stride];
903  BlockNode backup= *block;
904  int rd;
905 
906  av_assert2(mb_x>=0 && mb_y>=0);
907  av_assert2(mb_x<b_stride);
908 
909  block->color[0] = p[0];
910  block->color[1] = p[1];
911  block->color[2] = p[2];
912  block->type |= BLOCK_INTRA;
913 
914  rd = get_block_rd(s, mb_x, mb_y, 0, obmc_edged) + s->intra_penalty;
915 
916 //FIXME chroma
917  if(rd < *best_rd){
918  *best_rd= rd;
919  return 1;
920  }else{
921  *block= backup;
922  return 0;
923  }
924 }
925 
926 /* special case for int[2] args we discard afterwards,
927  * fixes compilation problem with gcc 2.95 */
928 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){
929  const int b_stride = s->b_width << s->block_max_depth;
930  BlockNode *block = &s->block[mb_x + mb_y * b_stride];
931  BlockNode backup = *block;
932  unsigned value;
933  int rd, index;
934 
935  av_assert2(mb_x >= 0 && mb_y >= 0);
936  av_assert2(mb_x < b_stride);
937 
938  index = (p0 + 31 * p1) & (ME_CACHE_SIZE-1);
939  value = s->me_cache_generation + (p0 >> 10) + p1 * (1 << 6) + (block->ref << 12);
940  if (s->me_cache[index] == value)
941  return 0;
942  s->me_cache[index] = value;
943 
944  block->mx = p0;
945  block->my = p1;
946  block->type &= ~BLOCK_INTRA;
947 
948  rd = get_block_rd(s, mb_x, mb_y, 0, obmc_edged);
949 
950 //FIXME chroma
951  if (rd < *best_rd) {
952  *best_rd = rd;
953  return 1;
954  } else {
955  *block = backup;
956  return 0;
957  }
958 }
959 
960 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){
961  const int b_stride= s->b_width << s->block_max_depth;
962  BlockNode *block= &s->block[mb_x + mb_y * b_stride];
963  BlockNode backup[4];
964  unsigned value;
965  int rd, index;
966 
967  /* We don't initialize backup[] during variable declaration, because
968  * that fails to compile on MSVC: "cannot convert from 'BlockNode' to
969  * 'int16_t'". */
970  backup[0] = block[0];
971  backup[1] = block[1];
972  backup[2] = block[b_stride];
973  backup[3] = block[b_stride + 1];
974 
975  av_assert2(mb_x>=0 && mb_y>=0);
976  av_assert2(mb_x<b_stride);
977  av_assert2(((mb_x|mb_y)&1) == 0);
978 
979  index= (p0 + 31*p1) & (ME_CACHE_SIZE-1);
980  value= s->me_cache_generation + (p0>>10) + (p1<<6) + (block->ref<<12);
981  if(s->me_cache[index] == value)
982  return 0;
983  s->me_cache[index]= value;
984 
985  block->mx= p0;
986  block->my= p1;
987  block->ref= ref;
988  block->type &= ~BLOCK_INTRA;
989  block[1]= block[b_stride]= block[b_stride+1]= *block;
990 
991  rd= get_4block_rd(s, mb_x, mb_y, 0);
992 
993 //FIXME chroma
994  if(rd < *best_rd){
995  *best_rd= rd;
996  return 1;
997  }else{
998  block[0]= backup[0];
999  block[1]= backup[1];
1000  block[b_stride]= backup[2];
1001  block[b_stride+1]= backup[3];
1002  return 0;
1003  }
1004 }
1005 
1006 static void iterative_me(SnowContext *s){
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;
1011  int color[3];
1012 
1013  {
1014  RangeCoder r = s->c;
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++)
1019  encode_q_branch(s, 0, mb_x, mb_y);
1020  s->c = r;
1021  memcpy(s->block_state, state, sizeof(s->block_state));
1022  }
1023 
1024  for(pass=0; pass<25; pass++){
1025  int change= 0;
1026 
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;
1031  BlockNode backup, ref_b;
1032  const int index= mb_x + mb_y * b_stride;
1033  BlockNode *block= &s->block[index];
1034  BlockNode *tb = mb_y ? &s->block[index-b_stride ] : NULL;
1035  BlockNode *lb = mb_x ? &s->block[index -1] : NULL;
1036  BlockNode *rb = mb_x+1<b_width ? &s->block[index +1] : NULL;
1037  BlockNode *bb = mb_y+1<b_height ? &s->block[index+b_stride ] : NULL;
1038  BlockNode *tlb= mb_x && mb_y ? &s->block[index-b_stride-1] : NULL;
1039  BlockNode *trb= mb_x+1<b_width && mb_y ? &s->block[index-b_stride+1] : NULL;
1040  BlockNode *blb= mb_x && mb_y+1<b_height ? &s->block[index+b_stride-1] : NULL;
1041  BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->block[index+b_stride+1] : NULL;
1042  const int b_w= (MB_SIZE >> s->block_max_depth);
1043  uint8_t obmc_edged[MB_SIZE * 2][MB_SIZE * 2];
1044 
1045  if(pass && (block->type & BLOCK_OPT))
1046  continue;
1047  block->type |= BLOCK_OPT;
1048 
1049  backup= *block;
1050 
1051  if(!s->me_cache_generation)
1052  memset(s->me_cache, 0, sizeof(s->me_cache));
1053  s->me_cache_generation += 1<<22;
1054 
1055  //FIXME precalculate
1056  {
1057  int x, y;
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);
1060  if(mb_x==0)
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);
1066  if(mb_y==0){
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);
1071  }
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);
1077  }
1078  }
1079 
1080  //skip stuff outside the picture
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;
1091  int y;
1092 
1093  for(y=sy; y<0; y++)
1094  memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1095  for(y=h; y<sy+block_h*2; y++)
1096  memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1097  if(sx<0){
1098  for(y=sy; y<sy+block_h*2; y++)
1099  memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
1100  }
1101  if(sx+block_w*2 > w){
1102  for(y=sy; y<sy+block_h*2; y++)
1103  memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
1104  }
1105  }
1106 
1107  // intra(black) = neighbors' contribution to the current block
1108  for(i=0; i < s->nb_planes; i++)
1109  color[i]= get_dc(s, mb_x, mb_y, i);
1110 
1111  // get previous score (cannot be cached due to OBMC)
1112  if(pass > 0 && (block->type&BLOCK_INTRA)){
1113  int color0[3]= {block->color[0], block->color[1], block->color[2]};
1114  check_block_intra(s, mb_x, mb_y, color0, obmc_edged, &best_rd);
1115  }else
1116  check_block_inter(s, mb_x, mb_y, block->mx, block->my, obmc_edged, &best_rd);
1117 
1118  ref_b= *block;
1119  ref_rd= best_rd;
1120  for(ref=0; ref < s->ref_frames; ref++){
1121  int16_t (*mvr)[2]= &s->ref_mvs[ref][index];
1122  if(s->ref_scores[ref][index] > s->ref_scores[ref_b.ref][index]*3/2) //FIXME tune threshold
1123  continue;
1124  block->ref= ref;
1125  best_rd= INT_MAX;
1126 
1127  check_block_inter(s, mb_x, mb_y, mvr[0][0], mvr[0][1], obmc_edged, &best_rd);
1128  check_block_inter(s, mb_x, mb_y, 0, 0, obmc_edged, &best_rd);
1129  if(tb)
1130  check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1131  if(lb)
1132  check_block_inter(s, mb_x, mb_y, mvr[-1][0], mvr[-1][1], obmc_edged, &best_rd);
1133  if(rb)
1134  check_block_inter(s, mb_x, mb_y, mvr[1][0], mvr[1][1], obmc_edged, &best_rd);
1135  if(bb)
1136  check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1137 
1138  /* fullpel ME */
1139  //FIXME avoid subpel interpolation / round to nearest integer
1140  do{
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);
1144  dia_change=0;
1145  for(i=0; i < dia_size; i++){
1146  for(j=0; j<i; j++){
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);
1151  }
1152  }
1153  }while(dia_change);
1154  /* subpel ME */
1155  do{
1156  static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1157  dia_change=0;
1158  for(i=0; i<8; i++)
1159  dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+square[i][0], block->my+square[i][1], obmc_edged, &best_rd);
1160  }while(dia_change);
1161  //FIXME or try the standard 2 pass qpel or similar
1162 
1163  mvr[0][0]= block->mx;
1164  mvr[0][1]= block->my;
1165  if(ref_rd > best_rd){
1166  ref_rd= best_rd;
1167  ref_b= *block;
1168  }
1169  }
1170  best_rd= ref_rd;
1171  *block= ref_b;
1172  check_block_intra(s, mb_x, mb_y, color, obmc_edged, &best_rd);
1173  //FIXME RD style color selection
1174  if(!same_block(block, &backup)){
1175  if(tb ) tb ->type &= ~BLOCK_OPT;
1176  if(lb ) lb ->type &= ~BLOCK_OPT;
1177  if(rb ) rb ->type &= ~BLOCK_OPT;
1178  if(bb ) bb ->type &= ~BLOCK_OPT;
1179  if(tlb) tlb->type &= ~BLOCK_OPT;
1180  if(trb) trb->type &= ~BLOCK_OPT;
1181  if(blb) blb->type &= ~BLOCK_OPT;
1182  if(brb) brb->type &= ~BLOCK_OPT;
1183  change ++;
1184  }
1185  }
1186  }
1187  av_log(s->avctx, AV_LOG_DEBUG, "pass:%d changed:%d\n", pass, change);
1188  if(!change)
1189  break;
1190  }
1191 
1192  if(s->block_max_depth == 1){
1193  int change= 0;
1194  for(mb_y= 0; mb_y<b_height; mb_y+=2){
1195  for(mb_x= 0; mb_x<b_width; mb_x+=2){
1196  int i;
1197  int best_rd, init_rd;
1198  const int index= mb_x + mb_y * b_stride;
1199  BlockNode *b[4];
1200 
1201  b[0]= &s->block[index];
1202  b[1]= b[0]+1;
1203  b[2]= b[0]+b_stride;
1204  b[3]= b[2]+1;
1205  if(same_block(b[0], b[1]) &&
1206  same_block(b[0], b[2]) &&
1207  same_block(b[0], b[3]))
1208  continue;
1209 
1210  if(!s->me_cache_generation)
1211  memset(s->me_cache, 0, sizeof(s->me_cache));
1212  s->me_cache_generation += 1<<22;
1213 
1214  init_rd= best_rd= get_4block_rd(s, mb_x, mb_y, 0);
1215 
1216  //FIXME more multiref search?
1217  check_4block_inter(s, mb_x, mb_y,
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);
1220 
1221  for(i=0; i<4; i++)
1222  if(!(b[i]->type&BLOCK_INTRA))
1223  check_4block_inter(s, mb_x, mb_y, b[i]->mx, b[i]->my, b[i]->ref, &best_rd);
1224 
1225  if(init_rd != best_rd)
1226  change++;
1227  }
1228  }
1229  av_log(s->avctx, AV_LOG_ERROR, "pass:4mv changed:%d\n", change*4);
1230  }
1231 }
1232 
1233 static void encode_blocks(SnowContext *s, int search){
1234  int x, y;
1235  int w= s->b_width;
1236  int h= s->b_height;
1237 
1238  if(s->motion_est == FF_ME_ITER && !s->keyframe && search)
1239  iterative_me(s);
1240 
1241  for(y=0; y<h; y++){
1242  if(s->c.bytestream_end - s->c.bytestream < w*MB_SIZE*MB_SIZE*3){ //FIXME nicer limit
1243  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1244  return;
1245  }
1246  for(x=0; x<w; x++){
1247  if(s->motion_est == FF_ME_ITER || !search)
1248  encode_q_branch2(s, 0, x, y);
1249  else
1250  encode_q_branch (s, 0, x, y);
1251  }
1252  }
1253 }
1254 
1255 static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias){
1256  const int w= b->width;
1257  const int h= b->height;
1258  const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1259  const int qmul= ff_qexp[qlog&(QROOT-1)]<<((qlog>>QSHIFT) + ENCODER_EXTRA_BITS);
1260  int x,y, thres1, thres2;
1261 
1262  if(s->qlog == LOSSLESS_QLOG){
1263  for(y=0; y<h; y++)
1264  for(x=0; x<w; x++)
1265  dst[x + y*stride]= src[x + y*stride];
1266  return;
1267  }
1268 
1269  bias= bias ? 0 : (3*qmul)>>3;
1270  thres1= ((qmul - bias)>>QEXPSHIFT) - 1;
1271  thres2= 2*thres1;
1272 
1273  if(!bias){
1274  for(y=0; y<h; y++){
1275  for(x=0; x<w; x++){
1276  int i= src[x + y*stride];
1277 
1278  if((unsigned)(i+thres1) > thres2){
1279  if(i>=0){
1280  i<<= QEXPSHIFT;
1281  i/= qmul; //FIXME optimize
1282  dst[x + y*stride]= i;
1283  }else{
1284  i= -i;
1285  i<<= QEXPSHIFT;
1286  i/= qmul; //FIXME optimize
1287  dst[x + y*stride]= -i;
1288  }
1289  }else
1290  dst[x + y*stride]= 0;
1291  }
1292  }
1293  }else{
1294  for(y=0; y<h; y++){
1295  for(x=0; x<w; x++){
1296  int i= src[x + y*stride];
1297 
1298  if((unsigned)(i+thres1) > thres2){
1299  if(i>=0){
1300  i<<= QEXPSHIFT;
1301  i= (i + bias) / qmul; //FIXME optimize
1302  dst[x + y*stride]= i;
1303  }else{
1304  i= -i;
1305  i<<= QEXPSHIFT;
1306  i= (i + bias) / qmul; //FIXME optimize
1307  dst[x + y*stride]= -i;
1308  }
1309  }else
1310  dst[x + y*stride]= 0;
1311  }
1312  }
1313  }
1314 }
1315 
1316 static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride){
1317  const int w= b->width;
1318  const int h= b->height;
1319  const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1320  const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1321  const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
1322  int x,y;
1323 
1324  if(s->qlog == LOSSLESS_QLOG) return;
1325 
1326  for(y=0; y<h; y++){
1327  for(x=0; x<w; x++){
1328  int i= src[x + y*stride];
1329  if(i<0){
1330  src[x + y*stride]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
1331  }else if(i>0){
1332  src[x + y*stride]= (( i*qmul + qadd)>>(QEXPSHIFT));
1333  }
1334  }
1335  }
1336 }
1337 
1338 static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
1339  const int w= b->width;
1340  const int h= b->height;
1341  int x,y;
1342 
1343  for(y=h-1; y>=0; y--){
1344  for(x=w-1; x>=0; x--){
1345  int i= x + y*stride;
1346 
1347  if(x){
1348  if(use_median){
1349  if(y && x+1<w) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1350  else src[i] -= src[i - 1];
1351  }else{
1352  if(y) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1353  else src[i] -= src[i - 1];
1354  }
1355  }else{
1356  if(y) src[i] -= src[i - stride];
1357  }
1358  }
1359  }
1360 }
1361 
1362 static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
1363  const int w= b->width;
1364  const int h= b->height;
1365  int x,y;
1366 
1367  for(y=0; y<h; y++){
1368  for(x=0; x<w; x++){
1369  int i= x + y*stride;
1370 
1371  if(x){
1372  if(use_median){
1373  if(y && x+1<w) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1374  else src[i] += src[i - 1];
1375  }else{
1376  if(y) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1377  else src[i] += src[i - 1];
1378  }
1379  }else{
1380  if(y) src[i] += src[i - stride];
1381  }
1382  }
1383  }
1384 }
1385 
1386 static void encode_qlogs(SnowContext *s){
1387  int plane_index, level, orientation;
1388 
1389  for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){
1390  for(level=0; level<s->spatial_decomposition_count; level++){
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);
1394  }
1395  }
1396  }
1397 }
1398 
1399 static void encode_header(SnowContext *s){
1400  int plane_index, i;
1401  uint8_t kstate[32];
1402 
1403  memset(kstate, MID_STATE, sizeof(kstate));
1404 
1405  put_rac(&s->c, kstate, s->keyframe);
1406  if(s->keyframe || s->always_reset){
1407  ff_snow_reset_contexts(s);
1408  s->last_spatial_decomposition_type=
1409  s->last_qlog=
1410  s->last_qbias=
1411  s->last_mv_scale=
1412  s->last_block_max_depth= 0;
1413  for(plane_index=0; plane_index<2; plane_index++){
1414  Plane *p= &s->plane[plane_index];
1415  p->last_htaps=0;
1416  p->last_diag_mc=0;
1417  memset(p->last_hcoeff, 0, sizeof(p->last_hcoeff));
1418  }
1419  }
1420  if(s->keyframe){
1421  put_symbol(&s->c, s->header_state, s->version, 0);
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);
1426  put_symbol(&s->c, s->header_state, s->colorspace_type, 0);
1427  if (s->nb_planes > 2) {
1428  put_symbol(&s->c, s->header_state, s->chroma_h_shift, 0);
1429  put_symbol(&s->c, s->header_state, s->chroma_v_shift, 0);
1430  }
1431  put_rac(&s->c, s->header_state, s->spatial_scalability);
1432 // put_rac(&s->c, s->header_state, s->rate_scalability);
1433  put_symbol(&s->c, s->header_state, s->max_ref_frames-1, 0);
1434 
1435  encode_qlogs(s);
1436  }
1437 
1438  if(!s->keyframe){
1439  int update_mc=0;
1440  for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){
1441  Plane *p= &s->plane[plane_index];
1442  update_mc |= p->last_htaps != p->htaps;
1443  update_mc |= p->last_diag_mc != p->diag_mc;
1444  update_mc |= !!memcmp(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
1445  }
1446  put_rac(&s->c, s->header_state, update_mc);
1447  if(update_mc){
1448  for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){
1449  Plane *p= &s->plane[plane_index];
1450  put_rac(&s->c, s->header_state, p->diag_mc);
1451  put_symbol(&s->c, s->header_state, p->htaps/2-1, 0);
1452  for(i= p->htaps/2; i; i--)
1453  put_symbol(&s->c, s->header_state, FFABS(p->hcoeff[i]), 0);
1454  }
1455  }
1456  if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
1457  put_rac(&s->c, s->header_state, 1);
1458  put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
1459  encode_qlogs(s);
1460  }else
1461  put_rac(&s->c, s->header_state, 0);
1462  }
1463 
1464  put_symbol(&s->c, s->header_state, s->spatial_decomposition_type - s->last_spatial_decomposition_type, 1);
1465  put_symbol(&s->c, s->header_state, s->qlog - s->last_qlog , 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);
1469 
1470 }
1471 
1472 static void update_last_header_values(SnowContext *s){
1473  int plane_index;
1474 
1475  if(!s->keyframe){
1476  for(plane_index=0; plane_index<2; plane_index++){
1477  Plane *p= &s->plane[plane_index];
1478  p->last_diag_mc= p->diag_mc;
1479  p->last_htaps = p->htaps;
1480  memcpy(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
1481  }
1482  }
1483 
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;
1490 }
1491 
1492 static int qscale2qlog(int qscale){
1493  return lrint(QROOT*log2(qscale / (float)FF_QP2LAMBDA))
1494  + 61*QROOT/8; ///< 64 > 60
1495 }
1496 
1497 static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
1498 {
1499  /* Estimate the frame's complexity as a sum of weighted dwt coefficients.
1500  * FIXME we know exact mv bits at this point,
1501  * but ratecontrol isn't set up to include them. */
1502  uint32_t coef_sum= 0;
1503  int level, orientation, delta_qlog;
1504 
1505  for(level=0; level<s->spatial_decomposition_count; level++){
1506  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1507  SubBand *b= &s->plane[0].band[level][orientation];
1508  IDWTELEM *buf= b->ibuf;
1509  const int w= b->width;
1510  const int h= b->height;
1511  const int stride= b->stride;
1512  const int qlog= av_clip(2*QROOT + b->qlog, 0, QROOT*16);
1513  const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1514  const int qdiv= (1<<16)/qmul;
1515  int x, y;
1516  //FIXME this is ugly
1517  for(y=0; y<h; y++)
1518  for(x=0; x<w; x++)
1519  buf[x+y*stride]= b->buf[x+y*stride];
1520  if(orientation==0)
1521  decorrelate(s, b, buf, stride, 1, 0);
1522  for(y=0; y<h; y++)
1523  for(x=0; x<w; x++)
1524  coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
1525  }
1526  }
1527 
1528  /* ugly, ratecontrol just takes a sqrt again */
1529  av_assert0(coef_sum < INT_MAX);
1530  coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1531 
1532  if(pict->pict_type == AV_PICTURE_TYPE_I){
1533  s->m.mb_var_sum = coef_sum;
1534  s->m.mc_mb_var_sum = 0;
1535  }else{
1536  s->m.mc_mb_var_sum = coef_sum;
1537  s->m.mb_var_sum = 0;
1538  }
1539 
1540  pict->quality= ff_rate_estimate_qscale(&s->m, 1);
1541  if (pict->quality < 0)
1542  return INT_MIN;
1543  s->lambda= pict->quality * 3/2;
1544  delta_qlog= qscale2qlog(pict->quality) - s->qlog;
1545  s->qlog+= delta_qlog;
1546  return delta_qlog;
1547 }
1548 
1549 static void calculate_visual_weight(SnowContext *s, Plane *p){
1550  int width = p->width;
1551  int height= p->height;
1552  int level, orientation, x, y;
1553 
1554  for(level=0; level<s->spatial_decomposition_count; level++){
1555  int64_t error=0;
1556  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1557  SubBand *b= &p->band[level][orientation];
1558  IDWTELEM *ibuf= b->ibuf;
1559 
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;
1562  ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, width, height, width, s->spatial_decomposition_type, s->spatial_decomposition_count);
1563  for(y=0; y<height; y++){
1564  for(x=0; x<width; x++){
1565  int64_t d= s->spatial_idwt_buffer[x + y*width]*16;
1566  error += d*d;
1567  }
1568  }
1569  if (orientation == 2)
1570  error /= 2;
1571  b->qlog= (int)(QROOT * log2(352256.0/sqrt(error)) + 0.5);
1572  if (orientation != 1)
1573  error = 0;
1574  }
1575  p->band[level][1].qlog = p->band[level][2].qlog;
1576  }
1577 }
1578 
1579 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1580  const AVFrame *pict, int *got_packet)
1581 {
1582  SnowContext *s = avctx->priv_data;
1583  RangeCoder * const c= &s->c;
1584  AVCodecInternal *avci = avctx->internal;
1585  AVFrame *pic;
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)];
1591 
1592  if ((ret = ff_alloc_packet(avctx, pkt, s->b_width*s->b_height*MB_SIZE*MB_SIZE*3 + AV_INPUT_BUFFER_MIN_SIZE)) < 0)
1593  return ret;
1594 
1595  ff_init_range_encoder(c, pkt->data, pkt->size);
1596  ff_build_rac_states(c, (1LL<<32)/20, 256-8);
1597 
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;
1601  for(y=0; y<AV_CEIL_RSHIFT(height, vshift); y++)
1602  memcpy(&s->input_picture->data[i][y * s->input_picture->linesize[i]],
1603  &pict->data[i][y * pict->linesize[i]],
1604  AV_CEIL_RSHIFT(width, hshift));
1605  s->mpvencdsp.draw_edges(s->input_picture->data[i], s->input_picture->linesize[i],
1606  AV_CEIL_RSHIFT(width, hshift), AV_CEIL_RSHIFT(height, vshift),
1607  EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1608  EDGE_TOP | EDGE_BOTTOM);
1609 
1610  }
1611  emms_c();
1612  pic = s->input_picture;
1613  pic->pict_type = pict->pict_type;
1614  pic->quality = pict->quality;
1615 
1616  s->m.picture_number= avctx->frame_num;
1617  if(avctx->flags&AV_CODEC_FLAG_PASS2){
1618  s->m.pict_type = pic->pict_type = s->m.rc_context.entry[avctx->frame_num].new_pict_type;
1619  s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I;
1620  if(!(avctx->flags&AV_CODEC_FLAG_QSCALE)) {
1621  pic->quality = ff_rate_estimate_qscale(&s->m, 0);
1622  if (pic->quality < 0)
1623  return -1;
1624  }
1625  }else{
1626  s->keyframe= avctx->gop_size==0 || avctx->frame_num % avctx->gop_size == 0;
1627  s->m.pict_type = pic->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1628  }
1629 
1630  if(s->pass1_rc && avctx->frame_num == 0)
1631  pic->quality = 2*FF_QP2LAMBDA;
1632  if (pic->quality) {
1633  s->qlog = qscale2qlog(pic->quality);
1634  s->lambda = pic->quality * 3/2;
1635  }
1636  if (s->qlog < 0 || (!pic->quality && (avctx->flags & AV_CODEC_FLAG_QSCALE))) {
1637  s->qlog= LOSSLESS_QLOG;
1638  s->lambda = 0;
1639  }//else keep previous frame's qlog until after motion estimation
1640 
1641  if (s->current_picture->data[0]) {
1642  int w = s->avctx->width;
1643  int h = s->avctx->height;
1644 
1645  s->mpvencdsp.draw_edges(s->current_picture->data[0],
1646  s->current_picture->linesize[0], w , h ,
1647  EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
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,
1651  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
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,
1654  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
1655  }
1656  emms_c();
1657  }
1658 
1659  ff_snow_frame_start(s);
1660 
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;
1664  if(pic->pict_type == AV_PICTURE_TYPE_P){
1665  int block_width = (width +15)>>4;
1666  int block_height= (height+15)>>4;
1667  int stride= s->current_picture->linesize[0];
1668 
1669  av_assert0(s->current_picture->data[0]);
1670  av_assert0(s->last_picture[0]->data[0]);
1671 
1672  s->m.avctx= s->avctx;
1673  s->m. last_picture.f = s->last_picture[0];
1674  s->m. new_picture = s->input_picture;
1675  s->m. last_picture_ptr= &s->m. last_picture;
1676  s->m.linesize = stride;
1677  s->m.uvlinesize= s->current_picture->linesize[1];
1678  s->m.width = width;
1679  s->m.height= height;
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;
1684  s->m.f_code=1;
1685  s->m.pict_type = pic->pict_type;
1686  s->m.motion_est= s->motion_est;
1687  s->m.me.scene_change_score=0;
1688  s->m.me.dia_size = avctx->dia_size;
1689  s->m.quarter_sample= (s->avctx->flags & AV_CODEC_FLAG_QPEL)!=0;
1690  s->m.out_format= FMT_H263;
1691  s->m.unrestricted_mv= 1;
1692 
1693  s->m.lambda = s->lambda;
1694  s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
1695  s->lambda2= s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
1696 
1697  s->m.mecc= s->mecc; //move
1698  s->m.qdsp= s->qdsp; //move
1699  s->m.hdsp = s->hdsp;
1700  ff_init_me(&s->m);
1701  s->hdsp = s->m.hdsp;
1702  s->mecc= s->m.mecc;
1703  }
1704 
1705  if(s->pass1_rc){
1706  memcpy(rc_header_bak, s->header_state, sizeof(s->header_state));
1707  memcpy(rc_block_bak, s->block_state, sizeof(s->block_state));
1708  }
1709 
1710 redo_frame:
1711 
1712  s->spatial_decomposition_count= 5;
1713 
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--;
1717 
1718  if (s->spatial_decomposition_count <= 0) {
1719  av_log(avctx, AV_LOG_ERROR, "Resolution too low\n");
1720  return AVERROR(EINVAL);
1721  }
1722 
1723  s->m.pict_type = pic->pict_type;
1724  s->qbias = pic->pict_type == AV_PICTURE_TYPE_P ? 2 : 0;
1725 
1726  ff_snow_common_init_after_header(avctx);
1727 
1728  if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
1729  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1730  calculate_visual_weight(s, &s->plane[plane_index]);
1731  }
1732  }
1733 
1734  encode_header(s);
1735  s->m.misc_bits = 8*(s->c.bytestream - s->c.bytestream_start);
1736  encode_blocks(s, 1);
1737  s->m.mv_bits = 8*(s->c.bytestream - s->c.bytestream_start) - s->m.misc_bits;
1738 
1739  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1740  Plane *p= &s->plane[plane_index];
1741  int w= p->width;
1742  int h= p->height;
1743  int x, y;
1744 // int bits= put_bits_count(&s->c.pb);
1745 
1746  if (!s->memc_only) {
1747  //FIXME optimize
1748  if(pict->data[plane_index]) //FIXME gray hack
1749  for(y=0; y<h; y++){
1750  for(x=0; x<w; x++){
1751  s->spatial_idwt_buffer[y*w + x]= pict->data[plane_index][y*pict->linesize[plane_index] + x]<<FRAC_BITS;
1752  }
1753  }
1754  predict_plane(s, s->spatial_idwt_buffer, plane_index, 0);
1755 
1756  if( plane_index==0
1757  && pic->pict_type == AV_PICTURE_TYPE_P
1758  && !(avctx->flags&AV_CODEC_FLAG_PASS2)
1759  && s->m.me.scene_change_score > s->scenechange_threshold){
1760  ff_init_range_encoder(c, pkt->data, pkt->size);
1761  ff_build_rac_states(c, (1LL<<32)/20, 256-8);
1762  pic->pict_type= AV_PICTURE_TYPE_I;
1763  s->keyframe=1;
1764  s->current_picture->key_frame=1;
1765  goto redo_frame;
1766  }
1767 
1768  if(s->qlog == LOSSLESS_QLOG){
1769  for(y=0; y<h; y++){
1770  for(x=0; x<w; x++){
1771  s->spatial_dwt_buffer[y*w + x]= (s->spatial_idwt_buffer[y*w + x] + (1<<(FRAC_BITS-1))-1)>>FRAC_BITS;
1772  }
1773  }
1774  }else{
1775  for(y=0; y<h; y++){
1776  for(x=0; x<w; x++){
1777  s->spatial_dwt_buffer[y*w + x]= s->spatial_idwt_buffer[y*w + x] * (1 << ENCODER_EXTRA_BITS);
1778  }
1779  }
1780  }
1781 
1782  ff_spatial_dwt(s->spatial_dwt_buffer, s->temp_dwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);
1783 
1784  if(s->pass1_rc && plane_index==0){
1785  int delta_qlog = ratecontrol_1pass(s, pic);
1786  if (delta_qlog <= INT_MIN)
1787  return -1;
1788  if(delta_qlog){
1789  //reordering qlog in the bitstream would eliminate this reset
1790  ff_init_range_encoder(c, pkt->data, pkt->size);
1791  memcpy(s->header_state, rc_header_bak, sizeof(s->header_state));
1792  memcpy(s->block_state, rc_block_bak, sizeof(s->block_state));
1793  encode_header(s);
1794  encode_blocks(s, 0);
1795  }
1796  }
1797 
1798  for(level=0; level<s->spatial_decomposition_count; level++){
1799  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1800  SubBand *b= &p->band[level][orientation];
1801 
1802  quantize(s, b, b->ibuf, b->buf, b->stride, s->qbias);
1803  if(orientation==0)
1804  decorrelate(s, b, b->ibuf, b->stride, pic->pict_type == AV_PICTURE_TYPE_P, 0);
1805  if (!s->no_bitstream)
1806  encode_subband(s, b, b->ibuf, b->parent ? b->parent->ibuf : NULL, b->stride, orientation);
1807  av_assert0(b->parent==NULL || b->parent->stride == b->stride*2);
1808  if(orientation==0)
1809  correlate(s, b, b->ibuf, b->stride, 1, 0);
1810  }
1811  }
1812 
1813  for(level=0; level<s->spatial_decomposition_count; level++){
1814  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1815  SubBand *b= &p->band[level][orientation];
1816 
1817  dequantize(s, b, b->ibuf, b->stride);
1818  }
1819  }
1820 
1821  ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);
1822  if(s->qlog == LOSSLESS_QLOG){
1823  for(y=0; y<h; y++){
1824  for(x=0; x<w; x++){
1825  s->spatial_idwt_buffer[y*w + x] *= 1 << FRAC_BITS;
1826  }
1827  }
1828  }
1829  predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
1830  }else{
1831  //ME/MC only
1832  if(pic->pict_type == AV_PICTURE_TYPE_I){
1833  for(y=0; y<h; y++){
1834  for(x=0; x<w; x++){
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];
1837  }
1838  }
1839  }else{
1840  memset(s->spatial_idwt_buffer, 0, sizeof(IDWTELEM)*w*h);
1841  predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
1842  }
1843  }
1844  if(s->avctx->flags&AV_CODEC_FLAG_PSNR){
1845  int64_t error= 0;
1846 
1847  if(pict->data[plane_index]) //FIXME gray hack
1848  for(y=0; y<h; y++){
1849  for(x=0; x<w; x++){
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];
1851  error += d*d;
1852  }
1853  }
1854  s->avctx->error[plane_index] += error;
1855  s->encoding_error[plane_index] = error;
1856  }
1857 
1858  }
1859  emms_c();
1860 
1861  update_last_header_values(s);
1862 
1863  ff_snow_release_buffer(avctx);
1864 
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);
1873  if(s->pass1_rc)
1874  if (ff_rate_estimate_qscale(&s->m, 0) < 0)
1875  return -1;
1876  if(avctx->flags&AV_CODEC_FLAG_PASS1)
1877  ff_write_pass1_stats(&s->m);
1878  s->m.last_pict_type = s->m.pict_type;
1879 
1880  emms_c();
1881 
1882  ff_side_data_set_encoder_stats(pkt, s->current_picture->quality,
1883  s->encoding_error,
1884  (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? SNOW_MAX_PLANES : 0,
1885  s->current_picture->pict_type);
1886  if (s->avctx->flags & AV_CODEC_FLAG_RECON_FRAME) {
1887  av_frame_unref(avci->recon_frame);
1888  av_frame_ref(avci->recon_frame, s->current_picture);
1889  }
1890 
1891  pkt->size = ff_rac_terminate(c, 0);
1892  if (s->current_picture->key_frame)
1893  pkt->flags |= AV_PKT_FLAG_KEY;
1894  *got_packet = 1;
1895 
1896  return 0;
1897 }
1898 
1899 static av_cold int encode_end(AVCodecContext *avctx)
1900 {
1901  SnowContext *s = avctx->priv_data;
1902 
1903  ff_snow_common_end(s);
1904  ff_rate_control_uninit(&s->m);
1905  av_frame_free(&s->input_picture);
1906  av_freep(&avctx->stats_out);
1907 
1908  return 0;
1909 }
1910 
1911 #define OFFSET(x) offsetof(SnowContext, x)
1912 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1913 static const AVOption options[] = {
1914  {"motion_est", "motion estimation algorithm", OFFSET(motion_est), AV_OPT_TYPE_INT, {.i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_ITER, VE, "motion_est" },
1915  { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, VE, "motion_est" },
1916  { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, VE, "motion_est" },
1917  { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, VE, "motion_est" },
1918  { "iter", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ITER }, 0, 0, VE, "motion_est" },
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 },
1924  { "pred", "Spatial decomposition type", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, DWT_97, DWT_53, VE, "pred" },
1925  { "dwt97", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
1926  { "dwt53", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
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.",
1931  OFFSET(m.rc_eq), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
1932  { NULL },
1933 };
1934 
1935 static const AVClass snowenc_class = {
1936  .class_name = "snow encoder",
1937  .item_name = av_default_item_name,
1938  .option = options,
1939  .version = LIBAVUTIL_VERSION_INT,
1940 };
1941 
1942 const FFCodec ff_snow_encoder = {
1943  .p.name = "snow",
1944  CODEC_LONG_NAME("Snow"),
1945  .p.type = AVMEDIA_TYPE_VIDEO,
1946  .p.id = AV_CODEC_ID_SNOW,
1947  .p.capabilities = AV_CODEC_CAP_DR1 |
1948  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE |
1949  AV_CODEC_CAP_ENCODER_RECON_FRAME,
1950  .priv_data_size = sizeof(SnowContext),
1951  .init = encode_init,
1952  FF_CODEC_ENCODE_CB(encode_frame),
1953  .close = encode_end,
1954  .p.pix_fmts = (const enum AVPixelFormat[]){
1955  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV444P,
1956  AV_PIX_FMT_GRAY8,
1957  AV_PIX_FMT_NONE
1958  },
1959  .p.priv_class = &snowenc_class,
1960  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1961 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
encode_subband
static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
Definition: snowenc.c:891
decorrelate
static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1338
set_blocks
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)
Definition: snow.h:464
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
Plane::last_diag_mc
int last_diag_mc
Definition: snow.h:113
P_LEFT
#define P_LEFT
Definition: snowenc.c:214
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:95
iterative_me
static void iterative_me(SnowContext *s)
Definition: snowenc.c:1006
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
QEXPSHIFT
#define QEXPSHIFT
Definition: snow.h:509
FF_LAMBDA_SCALE
#define FF_LAMBDA_SCALE
Definition: avutil.h:226
r
const char * r
Definition: vf_curves.c:126
AVERROR
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
opt.h
libm.h
MID_STATE
#define MID_STATE
Definition: snow.h:42
color
Definition: vf_paletteuse.c:509
EDGE_BOTTOM
#define EDGE_BOTTOM
Definition: mpegvideoencdsp.h:30
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:239
FF_ME_EPZS
#define FF_ME_EPZS
Definition: motion_est.h:41
inverse
inverse
Definition: af_crystalizer.c:122
encode_end
static av_cold int encode_end(AVCodecContext *avctx)
Definition: snowenc.c:1899
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:602
LOG2_MB_SIZE
#define LOG2_MB_SIZE
Definition: snow.h:75
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:216
MotionEstContext
Motion estimation context.
Definition: motion_est.h:47
AV_CODEC_CAP_ENCODER_RECON_FRAME
#define AV_CODEC_CAP_ENCODER_RECON_FRAME
The encoder is able to output reconstructed frame data, i.e.
Definition: codec.h:171
QBIAS_SHIFT
#define QBIAS_SHIFT
Definition: snow.h:165
h263enc.h
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:101
DWT_97
#define DWT_97
Definition: snow_dwt.h:68
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:437
MAX_DMV
#define MAX_DMV
Definition: motion_est.h:37
update_last_header_values
static void update_last_header_values(SnowContext *s)
Definition: snowenc.c:1472
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVOption
AVOption.
Definition: opt.h:251
last_picture
enum AVPictureType last_picture
Definition: movenc.c:69
encode.h
b
#define b
Definition: input.c:41
DWT_53
#define DWT_53
Definition: snow_dwt.h:69
get_penalty_factor
static int get_penalty_factor(int lambda, int lambda2, int type)
Definition: snowenc.c:189
encode_subband_c0run
static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
Definition: snowenc.c:771
rangecoder.h
FFCodec
Definition: codec_internal.h:127
mpegvideo.h
ff_rate_control_init
av_cold int ff_rate_control_init(MpegEncContext *s)
Definition: ratecontrol.c:471
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:314
FF_LAMBDA_SHIFT
#define FF_LAMBDA_SHIFT
Definition: avutil.h:225
SnowContext
Definition: snow.h:116
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: snowenc.c:1579
QSHIFT
#define QSHIFT
Definition: snow.h:45
MAX_REF_FRAMES
#define MAX_REF_FRAMES
Definition: snow.h:49
AV_CODEC_FLAG_4MV
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
Definition: avcodec.h:220
ff_set_cmp
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
Definition: me_cmp.c:476
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:232
ff_snow_common_end
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:625
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
ff_spatial_dwt
void ff_spatial_dwt(DWTELEM *buffer, DWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
Definition: snow_dwt.c:319
Plane::diag_mc
int diag_mc
Definition: snow.h:108
BlockNode::type
uint8_t type
Bitfield of BLOCK_*.
Definition: snow.h:58
ff_mpegvideoencdsp_init
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
Definition: mpegvideoencdsp.c:232
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
ff_spatial_idwt
void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
Definition: snow_dwt.c:731
ff_init_range_encoder
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:42
LOG2_OBMC_MAX
#define LOG2_OBMC_MAX
Definition: snow.h:51
BlockNode
Definition: snow.h:53
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:987
ff_me_cmp_init
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:1003
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:515
av_pix_fmt_get_chroma_sub_sample
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.
Definition: pixdesc.c:2916
OFFSET
#define OFFSET(x)
Definition: snowenc.c:1911
ff_snow_pred_block
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)
Definition: snow.c:316
type
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 type
Definition: writing_filters.txt:86
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:315
FF_CMP_SSE
#define FF_CMP_SSE
Definition: avcodec.h:835
ff_sqrt
#define ff_sqrt
Definition: mathops.h:218
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:89
ff_rate_estimate_qscale
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
Definition: ratecontrol.c:866
ff_snow_common_init_after_header
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:507
lrint
#define lrint
Definition: tablegen.h:53
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
FF_CMP_BIT
#define FF_CMP_BIT
Definition: avcodec.h:839
ff_snow_get_buffer
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
Definition: snow.c:64
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:256
check_block_intra
static av_always_inline int check_block_intra(SnowContext *s, int mb_x, int mb_y, int p[3], uint8_t(*obmc_edged)[MB_SIZE *2], int *best_rd)
Definition: snowenc.c:898
encode_blocks
static void encode_blocks(SnowContext *s, int search)
Definition: snowenc.c:1233
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:501
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
BLOCK_OPT
#define BLOCK_OPT
Block needs no checks in this round of iterative motion estiation.
Definition: snow.h:61
LOSSLESS_QLOG
#define LOSSLESS_QLOG
Definition: snow.h:47
calculate_visual_weight
static void calculate_visual_weight(SnowContext *s, Plane *p)
Definition: snowenc.c:1549
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:156
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
add_yblock
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)
Definition: snow.h:282
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:191
pix_norm1
static int pix_norm1(const uint8_t *pix, int line_size, int w)
Definition: snowenc.c:173
ff_snow_common_init
av_cold int ff_snow_common_init(AVCodecContext *avctx)
Definition: snow.c:426
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
pass
#define pass
Definition: fft_template.c:608
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
context
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 context
Definition: writing_filters.txt:91
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
ff_write_pass1_stats
void ff_write_pass1_stats(MpegEncContext *s)
Definition: ratecontrol.c:37
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
check_block_inter
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)
Definition: snowenc.c:928
NULL
#define NULL
Definition: coverity.c:32
ff_epzs_motion_search
int ff_epzs_motion_search(struct MpegEncContext *s, int *mx_ptr, int *my_ptr, int P[10][2], int src_index, int ref_index, const int16_t(*last_mv)[2], int ref_mv_scale, int size, int h)
Definition: motion_est_template.c:977
run
uint8_t run
Definition: svq3.c:203
bias
static int bias(int x, int c)
Definition: vqcdec.c:113
EDGE_WIDTH
#define EDGE_WIDTH
Definition: mpegpicture.h:34
snow.h
init_ref
static void init_ref(MotionEstContext *c, uint8_t *const src[3], uint8_t *const ref[3], uint8_t *const ref2[3], int x, int y, int ref_index)
Definition: motion_est.c:82
BlockNode::my
int16_t my
Motion vector component Y, see mv_scale.
Definition: snow.h:55
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:470
VE
#define VE
Definition: snowenc.c:1912
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:485
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
Definition: rangecoder.c:109
ROUNDED_DIV
#define ROUNDED_DIV(a, b)
Definition: common.h:48
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
ff_snow_release_buffer
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:583
FF_ME_ITER
#define FF_ME_ITER
Definition: snow.h:40
mathops.h
get_dc
static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index)
Definition: snowenc.c:505
abs
#define abs(x)
Definition: cuda_runtime.h:35
correlate
static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1362
ff_w53_32_c
int ff_w53_32_c(struct MpegEncContext *v, const uint8_t *pix1, const uint8_t *pix2, ptrdiff_t line_size, int h)
Definition: snow_dwt.c:832
QROOT
#define QROOT
Definition: snow.h:46
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
ME_MAP_SIZE
#define ME_MAP_SIZE
Definition: motion_est.h:38
FF_ME_XONE
#define FF_ME_XONE
Definition: motion_est.h:42
index
int index
Definition: gxfenc.c:89
c
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
Definition: undefined.txt:32
MB_SIZE
#define MB_SIZE
Definition: cinepakenc.c:55
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1309
AV_CODEC_FLAG_QPEL
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
Definition: avcodec.h:228
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:427
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
SNOW_MAX_PLANES
#define SNOW_MAX_PLANES
Definition: snow.h:38
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:629
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:350
encode_header
static void encode_header(SnowContext *s)
Definition: snowenc.c:1399
codec_internal.h
FF_CMP_PSNR
#define FF_CMP_PSNR
Definition: avcodec.h:838
Plane::height
int height
Definition: cfhd.h:119
P
#define P
shift
static int shift(int a, int b)
Definition: bonk.c:257
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:470
FF_CMP_W53
#define FF_CMP_W53
Definition: avcodec.h:845
Plane::last_hcoeff
int8_t last_hcoeff[HTAPS_MAX/2]
Definition: snow.h:112
size
int size
Definition: twinvq_data.h:10344
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
pix_sum
static int pix_sum(const uint8_t *pix, int line_size, int w, int h)
Definition: snowenc.c:157
encode_q_branch
static int encode_q_branch(SnowContext *s, int level, int x, int y)
Definition: snowenc.c:221
ff_snow_encoder
const FFCodec ff_snow_encoder
Definition: snowenc.c:1942
SubBand
Definition: cfhd.h:108
FF_CMP_SATD
#define FF_CMP_SATD
Definition: avcodec.h:836
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:302
height
#define height
Plane::htaps
int htaps
Definition: snow.h:106
Plane::last_htaps
int last_htaps
Definition: snow.h:111
Plane::width
int width
Definition: cfhd.h:118
snow_dwt.h
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
AVCodecInternal
Definition: internal.h:52
FF_CMP_SAD
#define FF_CMP_SAD
Definition: avcodec.h:834
encode_q_branch2
static void encode_q_branch2(SnowContext *s, int level, int x, int y)
Definition: snowenc.c:449
ff_get_mb_score
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)
Definition: motion_est_template.c:192
ff_quant3bA
const int8_t ff_quant3bA[256]
Definition: snowdata.h:104
Plane::hcoeff
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:107
DWTELEM
int DWTELEM
Definition: dirac_dwt.h:26
ff_obmc_tab
const uint8_t *const ff_obmc_tab[4]
Definition: snowdata.h:123
state
static struct @346 state
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
FMT_H263
@ FMT_H263
Definition: mpegutils.h:119
ENCODER_EXTRA_BITS
#define ENCODER_EXTRA_BITS
Definition: snow.h:77
AV_CODEC_FLAG_RECON_FRAME
#define AV_CODEC_FLAG_RECON_FRAME
Request the encoder to output reconstructed frames, i.e. frames that would be produced by decoding th...
Definition: avcodec.h:252
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
pred_mv
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
Definition: diracdec.c:1391
FF_CMP_RD
#define FF_CMP_RD
Definition: avcodec.h:840
get_block_bits
static int get_block_bits(SnowContext *s, int x, int y, int w)
Definition: snowenc.c:563
ff_square_tab
const uint32_t ff_square_tab[512]
Definition: me_cmp.c:35
BLOCK_INTRA
#define BLOCK_INTRA
Intra block, inter otherwise.
Definition: snow.h:60
get_block_rd
static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t(*obmc_edged)[MB_SIZE *2])
Definition: snowenc.c:601
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
qscale2qlog
static int qscale2qlog(int qscale)
Definition: snowenc.c:1492
av_always_inline
#define av_always_inline
Definition: attributes.h:49
value
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 value
Definition: writing_filters.txt:86
AVCodecContext::dia_size
int dia_size
ME diamond size & shape.
Definition: avcodec.h:857
ff_h263_encode_init
void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:816
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FF_CMP_NSSE
#define FF_CMP_NSSE
Definition: avcodec.h:844
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:484
AVCodecContext::mb_lmin
int mb_lmin
minimum MB Lagrange multiplier
Definition: avcodec.h:960
tb
#define tb
Definition: regdef.h:68
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
ff_qexp
const uint8_t ff_qexp[QROOT]
Definition: snowdata.h:128
predict_plane
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
Definition: snow.h:457
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:191
ff_snow_frame_start
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:592
put_symbol2
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
Definition: snow.h:565
ff_init_me
int ff_init_me(MpegEncContext *s)
Definition: motion_est.c:308
AVCodecContext::height
int height
Definition: avcodec.h:607
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:644
ff_rate_control_uninit
av_cold void ff_rate_control_uninit(MpegEncContext *s)
Definition: ratecontrol.c:671
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
log2
#define log2(x)
Definition: libm.h:404
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2086
mid_pred
#define mid_pred
Definition: mathops.h:98
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
search
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)
Definition: vf_find_rect.c:146
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: snowenc.c:41
options
static const AVOption options[]
Definition: snowenc.c:1913
AVCodecInternal::recon_frame
AVFrame * recon_frame
When the AV_CODEC_FLAG_RECON_FRAME flag is used.
Definition: internal.h:121
square
static int square(int x)
Definition: roqvideoenc.c:195
left
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
Definition: snow.txt:386
put_rac
#define put_rac(C, S, B)
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:94
me_cmp.h
SubBand::qlog
int qlog
log(qscale)/log[2^(1/6)]
Definition: snow.h:90
encode_qlogs
static void encode_qlogs(SnowContext *s)
Definition: snowenc.c:1386
AVCodecContext
main external API structure.
Definition: avcodec.h:435
AV_CODEC_ID_SNOW
@ AV_CODEC_ID_SNOW
Definition: codec_id.h:266
EDGE_TOP
#define EDGE_TOP
Definition: mpegvideoencdsp.h:29
t2
#define t2
Definition: regdef.h:30
ME_CACHE_SIZE
#define ME_CACHE_SIZE
Definition: snow.h:173
FRAC_BITS
#define FRAC_BITS
Definition: g729postfilter.c:36
check_4block_inter
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)
Definition: snowenc.c:960
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
get_4block_rd
static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index)
Definition: snowenc.c:702
FF_CMP_DCT
#define FF_CMP_DCT
Definition: avcodec.h:837
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
get_rac_count
static int get_rac_count(RangeCoder *c)
Definition: rangecoder.h:87
AVCodecContext::mb_lmax
int mb_lmax
maximum MB Lagrange multiplier
Definition: avcodec.h:967
Plane
Definition: cfhd.h:117
av_clip_uint8
#define av_clip_uint8
Definition: common.h:101
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
BlockNode::level
uint8_t level
Definition: snow.h:63
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
same_block
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
Definition: snow.h:272
packet_internal.h
Plane::band
SubBand band[DWT_LEVELS_3D][4]
Definition: cfhd.h:130
BlockNode::mx
int16_t mx
Motion vector component X, see mv_scale.
Definition: snow.h:54
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:462
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:240
FF_CMP_DCT264
#define FF_CMP_DCT264
Definition: avcodec.h:848
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
quantize
static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias)
Definition: snowenc.c:1255
dequantize
static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride)
Definition: snowenc.c:1316
ff_w97_32_c
int ff_w97_32_c(struct MpegEncContext *v, const uint8_t *pix1, const uint8_t *pix2, ptrdiff_t line_size, int h)
Definition: snow_dwt.c:837
ratecontrol_1pass
static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
Definition: snowenc.c:1497
d
d
Definition: ffmpeg_filter.c:156
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:607
null_block
static const BlockNode null_block
Definition: snow.h:66
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:375
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
IDWTELEM
short IDWTELEM
Definition: dirac_dwt.h:27
h
h
Definition: vp9dsp_template.c:2038
RangeCoder
Definition: mss3.c:62
snowenc_class
static const AVClass snowenc_class
Definition: snowenc.c:1935
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
int
int
Definition: ffmpeg_filter.c:156
P_TOP
#define P_TOP
Definition: snowenc.c:215
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:108
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:35
BlockNode::ref
uint8_t ref
Reference frame index.
Definition: snow.h:56
P_TOPRIGHT
#define P_TOPRIGHT
Definition: snowenc.c:216
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:298
P_MEDIAN
#define P_MEDIAN
Definition: snowenc.c:217
FF_ME_ZERO
#define FF_ME_ZERO
Definition: motion_est.h:40
FF_CMP_W97
#define FF_CMP_W97
Definition: avcodec.h:846
intmath.h
Generated on Fri Mar 31 2023 19:21:41 for FFmpeg by   doxygen 1.8.17