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