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