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