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