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