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