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 
39 {
40  SnowContext *s = avctx->priv_data;
41  int plane_index, ret;
42  int i;
43 
44 #if FF_API_PRIVATE_OPT
46  if (avctx->prediction_method)
47  s->pred = avctx->prediction_method;
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  }
76 
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  }
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 
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);
143 
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 
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;
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){
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);
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  }
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  }
1449  put_rac(&s->c, s->header_state, 1);
1451  encode_qlogs(s);
1452  }else
1453  put_rac(&s->c, s->header_state, 0);
1454  }
1455 
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);
1461 
1462 }
1463 
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 
1477  s->last_qlog = s->qlog;
1478  s->last_qbias = s->qbias;
1479  s->last_mv_scale = s->mv_scale;
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 
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;
1527  }else{
1528  s->m.current_picture.mc_mb_var_sum= coef_sum;
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 
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;
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 
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));
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){
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;
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
1630  av_frame_unref(avctx->coded_frame);
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
1640  if (ret < 0)
1641  return ret;
1642 #endif
1643 
1645  s->current_picture->linesize[0], w , h ,
1647  if (s->current_picture->data[2]) {
1654  }
1655  emms_c();
1656  }
1657 
1659 #if FF_API_CODED_FRAME
1661  ret = av_frame_ref(avctx->coded_frame, s->current_picture);
1663 #endif
1664  if (ret < 0)
1665  return ret;
1666 
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 
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;
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 
1719 
1720  while( !(width >>(s->chroma_h_shift + s->spatial_decomposition_count))
1721  || !(height>>(s->chroma_v_shift + 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 
1733 
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
1767 #endif
1768 
1769  if( plane_index==0
1770  && pic->pict_type == AV_PICTURE_TYPE_P
1771  && !(avctx->flags&AV_CODEC_FLAG_PASS2)
1773  ff_init_range_encoder(c, pkt->data, pkt->size);
1774  ff_build_rac_states(c, (1LL<<32)/20, 256-8);
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 
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 
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 
1875 
1876  ff_snow_release_buffer(avctx);
1877 
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;
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
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;
1900 #endif
1901 
1902  emms_c();
1903 
1905  s->encoding_error,
1906  (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
1908 
1909 #if FF_API_ERROR_FRAME
1911  memcpy(s->current_picture->error, s->encoding_error, sizeof(s->encoding_error));
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 
1924 {
1925  SnowContext *s = avctx->priv_data;
1926 
1927  ff_snow_common_end(s);
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 
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[]){
1979  },
1980  .priv_class = &snowenc_class,
1981  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1983 };
int last_block_max_depth
Definition: snow.h:168
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free.
Definition: motion_est.h:52
#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:48
static const AVClass snowenc_class
Definition: snowenc.c:1959
int version
Definition: snow.h:135
static av_cold int encode_end(AVCodecContext *avctx)
Definition: snowenc.c:1923
MpegEncContext m
Definition: snow.h:183
int frame_bits
bits used for the current frame
Definition: mpegvideo.h:338
int mv_scale
Definition: snow.h:160
#define NULL
Definition: coverity.c:32
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
Definition: mpegvideo.h:341
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
Definition: snow.h:455
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:653
av_cold void ff_rate_control_uninit(MpegEncContext *s)
Definition: ratecontrol.c:672
#define QSHIFT
Definition: snow.h:43
#define P_MEDIAN
Definition: snowenc.c:225
int picture_number
Definition: mpegvideo.h:127
#define P
#define P_TOPRIGHT
Definition: snowenc.c:224
AVCodecContext * avctx
Definition: snow.h:116
int block_max_depth
Definition: snow.h:167
int last_spatial_decomposition_count
Definition: snow.h:140
static int shift(int a, int b)
Definition: sonic.c:82
int chroma_v_shift
Definition: snow.h:153
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
int skip
set if ME is skipped for the current MB
Definition: motion_est.h:49
AVOption.
Definition: opt.h:248
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:796
int pass1_rc
Definition: snow.h:159
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:1709
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
RateControlEntry * entry
Definition: ratecontrol.h:65
int * run_buffer
Definition: snow.h:150
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
#define P_LEFT
Definition: snowenc.c:222
void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:761
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)
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int always_reset
Definition: snow.h:134
int no_bitstream
Definition: snow.h:177
uint8_t * current_mv_penalty
Definition: motion_est.h:94
#define BLOCK_INTRA
Intra block, inter otherwise.
Definition: snow.h:58
int(* sub_motion_search)(struct MpegEncContext *s, int *mx_ptr, int *my_ptr, int dmin, int src_index, int ref_index, int size, int h)
Definition: motion_est.h:95
Range coder.
uint8_t * bytestream_end
Definition: rangecoder.h:44
int size
Definition: packet.h:364
int mb_lmin
minimum MB Lagrange multiplier
Definition: avcodec.h:1073
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int av_log2(unsigned v)
Definition: intmath.c:26
int scenechange_threshold
Definition: snow.h:181
int sub_penalty_factor
Definition: motion_est.h:67
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
GLint GLenum type
Definition: opengl_enc.c:104
int max_ref_frames
Definition: snow.h:142
uint32_t * score_map
map to store the scores
Definition: motion_est.h:59
#define FF_CMP_W97
Definition: avcodec.h:943
mpegvideo header.
int8_t last_hcoeff[HTAPS_MAX/2]
Definition: snow.h:110
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
int scene_change_score
Definition: motion_est.h:87
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:513
ptrdiff_t stride
Definition: cfhd.h:112
static void update_last_header_values(SnowContext *s)
Definition: snowenc.c:1464
int keyframe
Definition: snow.h:133
uint8_t run
Definition: svq3.c:204
static AVPacket pkt
#define EDGE_TOP
static void error(const char *err)
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:133
#define FF_LAMBDA_SHIFT
Definition: avutil.h:225
QpelDSPContext qdsp
Definition: mpegvideo.h:235
AVCodec.
Definition: codec.h:190
uint8_t(* mv_penalty)[MAX_DMV *2+1]
bit amount needed to encode a MV
Definition: motion_est.h:93
int qscale
QP.
Definition: mpegvideo.h:204
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:96
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:462
short IDWTELEM
Definition: dirac_dwt.h:27
enum AVPictureType last_picture
Definition: movenc.c:68
HpelDSPContext hdsp
Definition: snow.h:119
#define FF_ME_ZERO
Definition: motion_est.h:40
AVCodec ff_snow_encoder
Definition: snowenc.c:1966
#define log2(x)
Definition: libm.h:404
MECmpContext mecc
Definition: snow.h:118
static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
Definition: snowenc.c:779
#define OFFSET(x)
Definition: snowenc.c:1935
int qlog
log(qscale)/log[2^(1/6)]
Definition: snow.h:88
Definition: snow.h:51
int width
Definition: cfhd.h:114
static int get_penalty_factor(int lambda, int lambda2, int type)
Definition: snowenc.c:197
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
uint8_t level
Definition: snow.h:61
attribute_deprecated int mv_bits
Definition: avcodec.h:1519
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
uint8_t ref
Reference frame index.
Definition: snow.h:54
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
#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:40
int mb_lmax
maximum MB Lagrange multiplier
Definition: avcodec.h:1080
int b_height
Definition: snow.h:166
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: snowenc.c:1567
ScratchpadContext sc
Definition: mpegvideo.h:202
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define ME_MAP_SIZE
Definition: motion_est.h:38
int16_t mx
Motion vector component X, see mv_scale.
Definition: snow.h:52
#define av_cold
Definition: attributes.h:88
#define FRAC_BITS
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:232
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
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
AVOptions.
enum OutputFormat out_format
output format
Definition: mpegvideo.h:104
uint32_t * ref_scores[MAX_REF_FRAMES]
Definition: snow.h:145
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)
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
const uint32_t ff_square_tab[512]
Definition: me_cmp.c:33
Motion estimation context.
Definition: motion_est.h:47
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
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:456
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:401
int misc_bits
cbp, mb_type
Definition: mpegvideo.h:352
int me_cmp
motion estimation comparison function
Definition: avcodec.h:912
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:180
#define ENCODER_EXTRA_BITS
Definition: snow.h:75
static void calculate_visual_weight(SnowContext *s, Plane *p)
Definition: snowenc.c:1541
#define height
int16_t my
Motion vector component Y, see mv_scale.
Definition: snow.h:53
uint8_t * data
Definition: packet.h:363
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
static const BlockNode null_block
Definition: snow.h:64
static void encode_blocks(SnowContext *s, int search)
Definition: snowenc.c:1225
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
ptrdiff_t size
Definition: opengl_enc.c:100
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:638
#define QEXPSHIFT
Definition: snow.h:507
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1545
#define FF_CMP_SSE
Definition: avcodec.h:932
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:222
attribute_deprecated uint64_t error[AV_NUM_DATA_POINTERS]
Definition: frame.h:443
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
Definition: snow.h:563
#define av_log(a,...)
#define ff_sqrt
Definition: mathops.h:206
Definition: cfhd.h:111
#define ROUNDED_DIV(a, b)
Definition: common.h:56
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
#define DWT_97
Definition: snow_dwt.h:68
BlockNode * block
Definition: snow.h:171
MpegvideoEncDSPContext mpvencdsp
Definition: snow.h:123
int last_diag_mc
Definition: snow.h:111
#define EDGE_WIDTH
Definition: mpegpicture.h:33
#define src
Definition: vp8dsp.c:254
#define MAX_DMV
Definition: motion_est.h:37
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]
Definition: snow.h:144
#define MB_SIZE
Definition: cinepakenc.c:54
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
Definition: avcodec.h:279
SubBand band[DWT_LEVELS_3D][4]
Definition: cfhd.h:132
int64_t total_bits
Definition: mpegvideo.h:337
unsigned me_cache_generation
Definition: snow.h:174
av_cold int ff_rate_control_init(MpegEncContext *s)
Definition: ratecontrol.c:472
int me_sub_cmp
subpixel motion estimation comparison function
Definition: avcodec.h:918
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
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
void ff_write_pass1_stats(MpegEncContext *s)
Definition: ratecontrol.c:38
int unrestricted_mv
mv can point outside of the coded picture
Definition: mpegvideo.h:223
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
int diag_mc
Definition: snow.h:106
const char * r
Definition: vf_curves.c:114
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
Definition: diracdec.c:1389
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
const uint8_t *const ff_obmc_tab[4]
Definition: snowdata.h:123
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index)
Definition: snowenc.c:513
const char * name
Name of the codec implementation.
Definition: codec.h:197
static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1354
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:401
static int square(int x)
Definition: roqvideoenc.c:113
int lambda
Definition: snow.h:157
int intra_penalty
Definition: snow.h:178
#define FFMAX(a, b)
Definition: common.h:94
uint8_t * emu_edge_buffer
Definition: snow.h:186
uint8_t * bytestream
Definition: rangecoder.h:43
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
uint8_t color[3]
Color for intra.
Definition: snow.h:55
#define pass
Definition: fft_template.c:619
int ref_frames
Definition: snow.h:143
int htaps
Definition: snow.h:104
int qlog
Definition: snow.h:155
int refs
number of reference frames
Definition: avcodec.h:1114
#define FF_CMP_BIT
Definition: avcodec.h:936
#define b
Definition: input.c:41
const int8_t ff_quant3bA[256]
Definition: snowdata.h:104
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
static struct @322 state
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:275
#define FFMIN(a, b)
Definition: common.h:96
int display_picture_number
picture number in display order
Definition: frame.h:426
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
#define width
#define ME_CACHE_SIZE
Definition: snow.h:172
#define LOSSLESS_QLOG
Definition: snow.h:45
int width
picture width / height.
Definition: avcodec.h:699
uint8_t w
Definition: llviddspenc.c:38
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:184
#define VE
Definition: snowenc.c:1936
uint8_t * scratchbuf
Definition: snow.h:185
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:312
static int encode_q_branch(SnowContext *s, int level, int x, int y)
Definition: snowenc.c:229
Plane plane[MAX_PLANES]
Definition: snow.h:170
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
Definition: ratecontrol.c:868
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
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:280
int b_width
Definition: snow.h:165
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:431
MotionEstContext me
Definition: mpegvideo.h:282
int last_mv_scale
Definition: snow.h:161
int chroma_h_shift
Definition: snow.h:152
#define FF_CMP_SAD
Definition: avcodec.h:931
int penalty_factor
an estimate of the bits required to code a given mv value, e.g.
Definition: motion_est.h:62
static const float pred[4]
Definition: siprdata.h:259
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
Definition: snow.h:270
attribute_deprecated int misc_bits
Definition: avcodec.h:1533
uint8_t block_state[128+32 *128]
Definition: snow.h:132
int qbias
Definition: snow.h:162
int coded_picture_number
picture number in bitstream order
Definition: frame.h:422
#define FF_ME_XONE
Definition: motion_est.h:42
#define FF_LAMBDA_SCALE
Definition: avutil.h:226
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
Definition: snow.c:69
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
Definition: mpegvideo.h:207
Libavcodec external API header.
static void encode_header(SnowContext *s)
Definition: snowenc.c:1391
attribute_deprecated int scenechange_threshold
Definition: avcodec.h:1040
#define FF_CMP_RD
Definition: avcodec.h:937
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:134
AVCodecContext * avctx
Definition: motion_est.h:48
#define LOG2_OBMC_MAX
Definition: snow.h:49
int spatial_decomposition_count
Definition: snow.h:139
int DWTELEM
Definition: dirac_dwt.h:26
attribute_deprecated int prediction_method
Definition: avcodec.h:885
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
Definition: me_cmp.c:474
#define abs(x)
Definition: cuda_runtime.h:35
main external API structure.
Definition: avcodec.h:526
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:105
#define QROOT
Definition: snow.h:44
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:327
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
#define FF_CMP_NSSE
Definition: avcodec.h:941
#define FF_ME_EPZS
Definition: motion_est.h:41
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:110
#define FF_CMP_SATD
Definition: avcodec.h:933
uint8_t * ibuf
Definition: diracdec.c:98
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:206
struct SubBand * parent
Definition: diracdec.c:99
#define FF_CMP_DCT
Definition: avcodec.h:934
static int get_rac_count(RangeCoder *c)
Definition: rangecoder.h:96
static void encode_q_branch2(SnowContext *s, int level, int x, int y)
Definition: snowenc.c:457
Replacements for frequently missing libm functions.
unsigned me_cache[ME_CACHE_SIZE]
Definition: snow.h:173
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
Describe the class of an AVClass context structure.
Definition: log.h:67
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:42
int64_t mc_mb_var_sum
motion compensated MB variance for current frame
Definition: mpegpicture.h:82
int index
Definition: gxfenc.c:89
struct AVFrame * f
Definition: mpegpicture.h:46
int nb_planes
Definition: snow.h:169
int pred
Definition: snow.h:192
static int get_block_bits(SnowContext *s, int x, int y, int w)
Definition: snowenc.c:571
void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
Definition: snow_dwt.c:731
#define mid_pred
Definition: mathops.h:97
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:135
#define FF_CMP_PSNR
Definition: avcodec.h:935
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
DWTELEM * temp_dwt_buffer
Definition: snow.h:147
#define FF_CMP_W53
Definition: avcodec.h:942
uint8_t header_state[32]
Definition: snow.h:131
int motion_est
Definition: snow.h:179
int f_code
forward MV resolution
Definition: mpegvideo.h:238
#define FF_CMP_DCT264
Definition: avcodec.h:945
int last_qlog
Definition: snow.h:156
uint64_t encoding_error[AV_NUM_DATA_POINTERS]
Definition: snow.h:190
attribute_deprecated int p_tex_bits
Definition: avcodec.h:1525
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
int spatial_scalability
Definition: snow.h:154
static int qscale2qlog(int qscale)
Definition: snowenc.c:1484
static int pix_sum(uint8_t *pix, int line_size, int w, int h)
Definition: snowenc.c:165
int ff_snow_common_init(AVCodecContext *avctx)
static void encode_qlogs(SnowContext *s)
Definition: snowenc.c:1378
int motion_est
ME algorithm.
Definition: mpegvideo.h:258
int iterative_dia_size
Definition: snow.h:180
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:566
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:592
me_cmp_func me_cmp[6]
Definition: me_cmp.h:72
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
Definition: frame.c:624
int ff_init_me(MpegEncContext *s)
Definition: motion_est.c:306
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
Definition: avcodec.h:287
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
int spatial_decomposition_type
Definition: snow.h:136
AVFrame * current_picture
Definition: snow.h:126
int memc_only
Definition: snow.h:176
uint8_t level
Definition: svq3.c:205
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
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:131
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
Definition: rangecoder.c:109
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:721
static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index)
Definition: snowenc.c:710
int
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
int mb_cmp
macroblock comparison function (not supported yet)
Definition: avcodec.h:924
MECmpContext mecc
Definition: mpegvideo.h:231
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
#define MID_STATE
Definition: snow.h:40
int temporal_decomposition_type
Definition: snow.h:138
#define QBIAS_SHIFT
Definition: snow.h:164
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:130
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
IDWTELEM * temp_idwt_buffer
Definition: snow.h:149
void ff_spatial_dwt(DWTELEM *buffer, DWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
Definition: snow_dwt.c:319
int last_pict_type
Definition: mpegvideo.h:214
#define LOG2_MB_SIZE
Definition: snow.h:73
#define put_rac(C, S, B)
DWTELEM * spatial_dwt_buffer
Definition: snow.h:146
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1776
static av_cold int encode_init(AVCodecContext *avctx)
Definition: snowenc.c:38
int lambda2
Definition: snow.h:158
me_cmp_func me_sub_cmp[6]
Definition: me_cmp.h:73
uint8_t state[7+512][32]
Definition: snow.h:96
static const AVOption options[]
Definition: snowenc.c:1937
uint32_t * map
map to avoid duplicate evaluations
Definition: motion_est.h:58
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:148
uint8_t * bytestream_start
Definition: rangecoder.h:42
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:300
void * priv_data
Definition: avcodec.h:553
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
static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride)
Definition: snowenc.c:1308
int dia_size
ME diamond size & shape.
Definition: avcodec.h:954
attribute_deprecated int frame_bits
Definition: avcodec.h:1537
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
#define FF_ME_ITER
Definition: snow.h:38
uint8_t * obmc_scratchpad
Definition: mpegpicture.h:38
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
int colorspace_type
Definition: snow.h:151
int last_htaps
Definition: snow.h:109
int64_t bit_rate
wanted bit rate
Definition: mpegvideo.h:103
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
int height
Definition: cfhd.h:116
#define DWT_53
Definition: snow_dwt.h:69
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
#define lrint
Definition: tablegen.h:53
int fast_mc
Definition: snow.h:107
#define EDGE_BOTTOM
int width
Definition: cfhd.h:120
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:691
RangeCoder c
Definition: snow.h:117
uint8_t ff_qexp[QROOT]
Definition: snowdata.h:128
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1217
DWTELEM * buf
Definition: snow.h:89
#define P_TOP
Definition: snowenc.c:223
#define av_freep(p)
#define MAX_REF_FRAMES
Definition: snow.h:47
#define av_always_inline
Definition: attributes.h:45
uint8_t * temp
Definition: motion_est.h:56
static uint32_t inverse(uint32_t v)
find multiplicative inverse modulo 2 ^ 32
Definition: asfcrypt.c:35
uint8_t type
Bitfield of BLOCK_*.
Definition: snow.h:56
#define stride
static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
Definition: snowenc.c:1489
AVFrame * last_picture[MAX_REF_FRAMES]
Definition: snow.h:127
int height
Definition: cfhd.h:121
int last_qbias
Definition: snow.h:163
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
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:216
AVFrame * input_picture
new_picture with the internal linesizes
Definition: snow.h:125
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 local context
static int pix_norm1(uint8_t *pix, int line_size, int w)
Definition: snowenc.c:181
int temporal_decomposition_count
Definition: snow.h:141
int64_t mb_var_sum
sum of MB variance for current frame
Definition: mpegpicture.h:81
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:340
static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1330
#define BLOCK_OPT
Block needs no checks in this round of iterative motion estiation.
Definition: snow.h:59
static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias)
Definition: snowenc.c:1247
static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
Definition: snowenc.c:899
int last_spatial_decomposition_type
Definition: snow.h:137
#define t2
Definition: regdef.h:30
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
unsigned int lambda
Lagrange multiplier used in rate distortion.
Definition: mpegvideo.h:206
Definition: cfhd.h:119
#define tb
Definition: regdef.h:68
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
HpelDSPContext hdsp
Definition: mpegvideo.h:229
static void iterative_me(SnowContext *s)
Definition: snowenc.c:998
QpelDSPContext qdsp
Definition: snow.h:120
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
static uint8_t tmp[11]
Definition: aes_ctr.c:26