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