FFmpeg
snow.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
3  * Copyright (C) 2006 Robert Edele <yartrebo@earthlink.net>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #ifndef AVCODEC_SNOW_H
23 #define AVCODEC_SNOW_H
24 
26 
27 #include "hpeldsp.h"
28 #include "me_cmp.h"
29 #include "qpeldsp.h"
30 #include "snow_dwt.h"
31 
32 #include "rangecoder.h"
33 #include "mathops.h"
34 
35 #include "mpegvideo.h"
36 #include "h264qpel.h"
37 
38 #define FF_ME_ITER 3
39 
40 #define MID_STATE 128
41 
42 #define MAX_PLANES 4
43 #define QSHIFT 5
44 #define QROOT (1<<QSHIFT)
45 #define LOSSLESS_QLOG -128
46 #define FRAC_BITS 4
47 #define MAX_REF_FRAMES 8
48 
49 #define LOG2_OBMC_MAX 8
50 #define OBMC_MAX (1<<(LOG2_OBMC_MAX))
51 typedef struct BlockNode{
52  int16_t mx; ///< Motion vector component X, see mv_scale
53  int16_t my; ///< Motion vector component Y, see mv_scale
54  uint8_t ref; ///< Reference frame index
55  uint8_t color[3]; ///< Color for intra
56  uint8_t type; ///< Bitfield of BLOCK_*
57 //#define TYPE_SPLIT 1
58 #define BLOCK_INTRA 1 ///< Intra block, inter otherwise
59 #define BLOCK_OPT 2 ///< Block needs no checks in this round of iterative motion estiation
60 //#define TYPE_NOCOLOR 4
61  uint8_t level; //FIXME merge into type?
62 }BlockNode;
63 
64 static const BlockNode null_block= { //FIXME add border maybe
65  .color= {128,128,128},
66  .mx= 0,
67  .my= 0,
68  .ref= 0,
69  .type= 0,
70  .level= 0,
71 };
72 
73 #define LOG2_MB_SIZE 4
74 #define MB_SIZE (1<<LOG2_MB_SIZE)
75 #define ENCODER_EXTRA_BITS 4
76 #define HTAPS_MAX 8
77 
78 typedef struct x_and_coeff{
79  int16_t x;
80  uint16_t coeff;
81 } x_and_coeff;
82 
83 typedef struct SubBand{
84  int level;
85  int stride;
86  int width;
87  int height;
88  int qlog; ///< log(qscale)/log[2^(1/6)]
93  int stride_line; ///< Stride measured in lines, not pixels.
95  struct SubBand *parent;
96  uint8_t state[/*7*2*/ 7 + 512][32];
97 }SubBand;
98 
99 typedef struct Plane{
100  int width;
101  int height;
103 
104  int htaps;
105  int8_t hcoeff[HTAPS_MAX/2];
106  int diag_mc;
107  int fast_mc;
108 
112 }Plane;
113 
114 typedef struct SnowContext{
115  AVClass *class;
125  AVFrame *input_picture; ///< new_picture with the internal linesizes
128  uint8_t *halfpel_plane[MAX_REF_FRAMES][4][4];
130 // uint8_t q_context[16];
131  uint8_t header_state[32];
132  uint8_t block_state[128 + 32*128];
133  int keyframe;
135  int version;
144  int16_t (*ref_mvs[MAX_REF_FRAMES])[2];
155  int qlog;
157  int lambda;
158  int lambda2;
159  int pass1_rc;
160  int mv_scale;
162  int qbias;
164 #define QBIAS_SHIFT 3
165  int b_width;
166  int b_height;
172 #define ME_CACHE_SIZE 1024
175  slice_buffer sb;
182 
183  MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
184 
185  uint8_t *scratchbuf;
186  uint8_t *emu_edge_buffer;
187 
189  unsigned avmv_size;
192 
193  int pred;
194 }SnowContext;
195 
196 /* Tables */
197 extern const uint8_t * const ff_obmc_tab[4];
198 extern const uint8_t ff_qexp[QROOT];
200 
201 /* C bits used by mmx/sse2/altivec */
202 
203 static av_always_inline void snow_interleave_line_header(int * i, int width, IDWTELEM * low, IDWTELEM * high){
204  (*i) = (width) - 2;
205 
206  if (width & 1){
207  low[(*i)+1] = low[((*i)+1)>>1];
208  (*i)--;
209  }
210 }
211 
213  for (; (*i)>=0; (*i)-=2){
214  low[(*i)+1] = high[(*i)>>1];
215  low[*i] = low[(*i)>>1];
216  }
217 }
218 
219 static av_always_inline void snow_horizontal_compose_lift_lead_out(int i, IDWTELEM * dst, IDWTELEM * src, IDWTELEM * ref, int width, int w, int lift_high, int mul, int add, int shift){
220  for(; i<w; i++){
221  dst[i] = src[i] - ((mul * (ref[i] + ref[i + 1]) + add) >> shift);
222  }
223 
224  if((width^lift_high)&1){
225  dst[w] = src[w] - ((mul * 2 * ref[w] + add) >> shift);
226  }
227 }
228 
230  for(; i<w; i++){
231  dst[i] = src[i] + ((ref[i] + ref[(i+1)]+W_BO + 4 * src[i]) >> W_BS);
232  }
233 
234  if(width&1){
235  dst[w] = src[w] + ((2 * ref[w] + W_BO + 4 * src[w]) >> W_BS);
236  }
237 }
238 
239 /* common code */
240 
248 void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride,
249  int sx, int sy, int b_w, int b_h, const BlockNode *block,
250  int plane_index, int w, int h);
252 /* common inline functions */
253 //XXX doublecheck all of them should stay inlined
254 
255 static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
256  const BlockNode *left, const BlockNode *top, const BlockNode *tr){
257  if(s->ref_frames == 1){
258  *mx = mid_pred(left->mx, top->mx, tr->mx);
259  *my = mid_pred(left->my, top->my, tr->my);
260  }else{
261  const int *scale = ff_scale_mv_ref[ref];
262  *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
263  (top ->mx * scale[top ->ref] + 128) >>8,
264  (tr ->mx * scale[tr ->ref] + 128) >>8);
265  *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
266  (top ->my * scale[top ->ref] + 128) >>8,
267  (tr ->my * scale[tr ->ref] + 128) >>8);
268  }
269 }
270 
272  if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
273  return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
274  }else{
275  return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
276  }
277 }
278 
279 //FIXME name cleanup (b_w, block_w, b_width stuff)
280 //XXX should we really inline it?
281 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){
282  const int b_width = s->b_width << s->block_max_depth;
283  const int b_height= s->b_height << s->block_max_depth;
284  const int b_stride= b_width;
285  BlockNode *lt= &s->block[b_x + b_y*b_stride];
286  BlockNode *rt= lt+1;
287  BlockNode *lb= lt+b_stride;
288  BlockNode *rb= lb+1;
289  uint8_t *block[4];
290  // When src_stride is large enough, it is possible to interleave the blocks.
291  // Otherwise the blocks are written sequentially in the tmp buffer.
292  int tmp_step= src_stride >= 7*MB_SIZE ? MB_SIZE : MB_SIZE*src_stride;
293  uint8_t *tmp = s->scratchbuf;
294  uint8_t *ptmp;
295  int x,y;
296 
297  if(b_x<0){
298  lt= rt;
299  lb= rb;
300  }else if(b_x + 1 >= b_width){
301  rt= lt;
302  rb= lb;
303  }
304  if(b_y<0){
305  lt= lb;
306  rt= rb;
307  }else if(b_y + 1 >= b_height){
308  lb= lt;
309  rb= rt;
310  }
311 
312  if(src_x<0){ //FIXME merge with prev & always round internal width up to *16
313  obmc -= src_x;
314  b_w += src_x;
315  if(!sliced && !offset_dst)
316  dst -= src_x;
317  src_x=0;
318  }
319  if(src_x + b_w > w){
320  b_w = w - src_x;
321  }
322  if(src_y<0){
323  obmc -= src_y*obmc_stride;
324  b_h += src_y;
325  if(!sliced && !offset_dst)
326  dst -= src_y*dst_stride;
327  src_y=0;
328  }
329  if(src_y + b_h> h){
330  b_h = h - src_y;
331  }
332 
333  if(b_w<=0 || b_h<=0) return;
334 
335  if(!sliced && offset_dst)
336  dst += src_x + src_y*dst_stride;
337  dst8+= src_x + src_y*src_stride;
338 // src += src_x + src_y*src_stride;
339 
340  ptmp= tmp + 3*tmp_step;
341  block[0]= ptmp;
342  ptmp+=tmp_step;
343  ff_snow_pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
344 
345  if(same_block(lt, rt)){
346  block[1]= block[0];
347  }else{
348  block[1]= ptmp;
349  ptmp+=tmp_step;
350  ff_snow_pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
351  }
352 
353  if(same_block(lt, lb)){
354  block[2]= block[0];
355  }else if(same_block(rt, lb)){
356  block[2]= block[1];
357  }else{
358  block[2]= ptmp;
359  ptmp+=tmp_step;
360  ff_snow_pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
361  }
362 
363  if(same_block(lt, rb) ){
364  block[3]= block[0];
365  }else if(same_block(rt, rb)){
366  block[3]= block[1];
367  }else if(same_block(lb, rb)){
368  block[3]= block[2];
369  }else{
370  block[3]= ptmp;
371  ff_snow_pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
372  }
373  if(sliced){
374  s->dwt.inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
375  }else{
376  for(y=0; y<b_h; y++){
377  //FIXME ugly misuse of obmc_stride
378  const uint8_t *obmc1= obmc + y*obmc_stride;
379  const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
380  const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
381  const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
382  for(x=0; x<b_w; x++){
383  int v= obmc1[x] * block[3][x + y*src_stride]
384  +obmc2[x] * block[2][x + y*src_stride]
385  +obmc3[x] * block[1][x + y*src_stride]
386  +obmc4[x] * block[0][x + y*src_stride];
387 
388  v <<= 8 - LOG2_OBMC_MAX;
389  if(FRAC_BITS != 8){
390  v >>= 8 - FRAC_BITS;
391  }
392  if(add){
393  v += dst[x + y*dst_stride];
394  v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
395  if(v&(~255)) v= ~(v>>31);
396  dst8[x + y*src_stride] = v;
397  }else{
398  dst[x + y*dst_stride] -= v;
399  }
400  }
401  }
402  }
403 }
404 
405 static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y){
406  Plane *p= &s->plane[plane_index];
407  const int mb_w= s->b_width << s->block_max_depth;
408  const int mb_h= s->b_height << s->block_max_depth;
409  int x, y, mb_x;
410  int block_size = MB_SIZE >> s->block_max_depth;
411  int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
412  int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
413  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
414  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
415  int ref_stride= s->current_picture->linesize[plane_index];
416  uint8_t *dst8= s->current_picture->data[plane_index];
417  int w= p->width;
418  int h= p->height;
419  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // obmc params assume squares
420  if(s->keyframe || (s->avctx->debug&512)){
421  if(mb_y==mb_h)
422  return;
423 
424  if(add){
425  for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
426  for(x=0; x<w; x++){
427  int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
428  v >>= FRAC_BITS;
429  if(v&(~255)) v= ~(v>>31);
430  dst8[x + y*ref_stride]= v;
431  }
432  }
433  }else{
434  for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
435  for(x=0; x<w; x++){
436  buf[x + y*w]-= 128<<FRAC_BITS;
437  }
438  }
439  }
440 
441  return;
442  }
443 
444  for(mb_x=0; mb_x<=mb_w; mb_x++){
445  add_yblock(s, 0, NULL, buf, dst8, obmc,
446  block_w*mb_x - block_w/2,
447  block_h*mb_y - block_h/2,
448  block_w, block_h,
449  w, h,
450  w, ref_stride, obmc_stride,
451  mb_x - 1, mb_y - 1,
452  add, 1, plane_index);
453  }
454 }
455 
456 static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add){
457  const int mb_h= s->b_height << s->block_max_depth;
458  int mb_y;
459  for(mb_y=0; mb_y<=mb_h; mb_y++)
460  predict_slice(s, buf, plane_index, add, mb_y);
461 }
462 
463 static inline 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){
464  const int w= s->b_width << s->block_max_depth;
465  const int rem_depth= s->block_max_depth - level;
466  const int index= (x + y*w) << rem_depth;
467  const int block_w= 1<<rem_depth;
468  const int block_h= 1<<rem_depth; //FIXME "w!=h"
470  int i,j;
471 
472  block.color[0]= l;
473  block.color[1]= cb;
474  block.color[2]= cr;
475  block.mx= mx;
476  block.my= my;
477  block.ref= ref;
478  block.type= type;
479  block.level= level;
480 
481  for(j=0; j<block_h; j++){
482  for(i=0; i<block_w; i++){
483  s->block[index + i + j*w]= block;
484  }
485  }
486 }
487 
488 static inline void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index){
489  SnowContext *s = c->avctx->priv_data;
490  const int offset[3]= {
491  y*c-> stride + x,
492  ((y*c->uvstride + x)>>s->chroma_h_shift),
493  ((y*c->uvstride + x)>>s->chroma_h_shift),
494  };
495  int i;
496  for(i=0; i<3; i++){
497  c->src[0][i]= src [i];
498  c->ref[0][i]= ref [i] + offset[i];
499  }
500  av_assert2(!ref_index);
501 }
502 
503 
504 /* bitstream functions */
505 
506 extern const int8_t ff_quant3bA[256];
507 
508 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
509 
510 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
511  int i;
512 
513  if(v){
514  const int a= FFABS(v);
515  const int e= av_log2(a);
516  const int el= FFMIN(e, 10);
517  put_rac(c, state+0, 0);
518 
519  for(i=0; i<el; i++){
520  put_rac(c, state+1+i, 1); //1..10
521  }
522  for(; i<e; i++){
523  put_rac(c, state+1+9, 1); //1..10
524  }
525  put_rac(c, state+1+FFMIN(i,9), 0);
526 
527  for(i=e-1; i>=el; i--){
528  put_rac(c, state+22+9, (a>>i)&1); //22..31
529  }
530  for(; i>=0; i--){
531  put_rac(c, state+22+i, (a>>i)&1); //22..31
532  }
533 
534  if(is_signed)
535  put_rac(c, state+11 + el, v < 0); //11..21
536  }else{
537  put_rac(c, state+0, 1);
538  }
539 }
540 
541 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
542  if(get_rac(c, state+0))
543  return 0;
544  else{
545  int i, e;
546  unsigned a;
547  e= 0;
548  while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
549  e++;
550  if (e > 31)
551  return AVERROR_INVALIDDATA;
552  }
553 
554  a= 1;
555  for(i=e-1; i>=0; i--){
556  a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
557  }
558 
559  e= -(is_signed && get_rac(c, state+11 + FFMIN(e,10))); //11..21
560  return (a^e)-e;
561  }
562 }
563 
564 static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2){
565  int i;
566  int r= log2>=0 ? 1<<log2 : 1;
567 
568  av_assert2(v>=0);
569  av_assert2(log2>=-4);
570 
571  while(v >= r){
572  put_rac(c, state+4+log2, 1);
573  v -= r;
574  log2++;
575  if(log2>0) r+=r;
576  }
577  put_rac(c, state+4+log2, 0);
578 
579  for(i=log2-1; i>=0; i--){
580  put_rac(c, state+31-i, (v>>i)&1);
581  }
582 }
583 
584 static inline int get_symbol2(RangeCoder *c, uint8_t *state, int log2){
585  int i;
586  int r= log2>=0 ? 1<<log2 : 1;
587  int v=0;
588 
589  av_assert2(log2>=-4);
590 
591  while(log2<28 && get_rac(c, state+4+log2)){
592  v+= r;
593  log2++;
594  if(log2>0) r+=r;
595  }
596 
597  for(i=log2-1; i>=0; i--){
598  v+= get_rac(c, state+31-i)<<i;
599  }
600 
601  return v;
602 }
603 
604 static inline void unpack_coeffs(SnowContext *s, SubBand *b, SubBand * parent, int orientation){
605  const int w= b->width;
606  const int h= b->height;
607  int x,y;
608 
609  int run, runs;
610  x_and_coeff *xc= b->x_coeff;
611  x_and_coeff *prev_xc= NULL;
612  x_and_coeff *prev2_xc= xc;
613  x_and_coeff *parent_xc= parent ? parent->x_coeff : NULL;
614  x_and_coeff *prev_parent_xc= parent_xc;
615 
616  runs= get_symbol2(&s->c, b->state[30], 0);
617  if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
618  else run= INT_MAX;
619 
620  for(y=0; y<h; y++){
621  int v=0;
622  int lt=0, t=0, rt=0;
623 
624  if(y && prev_xc->x == 0){
625  rt= prev_xc->coeff;
626  }
627  for(x=0; x<w; x++){
628  int p=0;
629  const int l= v;
630 
631  lt= t; t= rt;
632 
633  if(y){
634  if(prev_xc->x <= x)
635  prev_xc++;
636  if(prev_xc->x == x + 1)
637  rt= prev_xc->coeff;
638  else
639  rt=0;
640  }
641  if(parent_xc){
642  if(x>>1 > parent_xc->x){
643  parent_xc++;
644  }
645  if(x>>1 == parent_xc->x){
646  p= parent_xc->coeff;
647  }
648  }
649  if(/*ll|*/l|lt|t|rt|p){
650  int context= av_log2(/*FFABS(ll) + */3*(l>>1) + (lt>>1) + (t&~1) + (rt>>1) + (p>>1));
651 
652  v=get_rac(&s->c, &b->state[0][context]);
653  if(v){
654  v= 2*(get_symbol2(&s->c, b->state[context + 2], context-4) + 1);
655  v+=get_rac(&s->c, &b->state[0][16 + 1 + 3 + ff_quant3bA[l&0xFF] + 3*ff_quant3bA[t&0xFF]]);
656  if ((uint16_t)v != v) {
657  av_log(s->avctx, AV_LOG_ERROR, "Coefficient damaged\n");
658  v = 1;
659  }
660  xc->x=x;
661  (xc++)->coeff= v;
662  }
663  }else{
664  if(!run){
665  if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
666  else run= INT_MAX;
667  v= 2*(get_symbol2(&s->c, b->state[0 + 2], 0-4) + 1);
668  v+=get_rac(&s->c, &b->state[0][16 + 1 + 3]);
669  if ((uint16_t)v != v) {
670  av_log(s->avctx, AV_LOG_ERROR, "Coefficient damaged\n");
671  v = 1;
672  }
673 
674  xc->x=x;
675  (xc++)->coeff= v;
676  }else{
677  int max_run;
678  run--;
679  v=0;
680  av_assert2(run >= 0);
681  if(y) max_run= FFMIN(run, prev_xc->x - x - 2);
682  else max_run= FFMIN(run, w-x-1);
683  if(parent_xc)
684  max_run= FFMIN(max_run, 2*parent_xc->x - x - 1);
685  av_assert2(max_run >= 0 && max_run <= run);
686 
687  x+= max_run;
688  run-= max_run;
689  }
690  }
691  }
692  (xc++)->x= w+1; //end marker
693  prev_xc= prev2_xc;
694  prev2_xc= xc;
695 
696  if(parent_xc){
697  if(y&1){
698  while(parent_xc->x != parent->width+1)
699  parent_xc++;
700  parent_xc++;
701  prev_parent_xc= parent_xc;
702  }else{
703  parent_xc= prev_parent_xc;
704  }
705  }
706  }
707 
708  (xc++)->x= w+1; //end marker
709 }
710 
711 #endif /* AVCODEC_SNOW_H */
BlockNode::color
uint8_t color[3]
Color for intra.
Definition: snow.h:55
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:111
SnowContext::avmv_size
unsigned avmv_size
Definition: snow.h:189
SnowContext::me_cache
unsigned me_cache[ME_CACHE_SIZE]
Definition: snow.h:173
stride
int stride
Definition: mace.c:144
ff_snow_get_buffer
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
Definition: snow.c:70
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:463
Plane::last_diag_mc
int last_diag_mc
Definition: snow.h:111
level
uint8_t level
Definition: svq3.c:204
MAX_DECOMPOSITIONS
#define MAX_DECOMPOSITIONS
Definition: dirac_dwt.h:30
r
const char * r
Definition: vf_curves.c:116
Plane::fast_mc
int fast_mc
Definition: snow.h:107
color
Definition: vf_paletteuse.c:599
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
AVMotionVector
Definition: motion_vector.h:24
SnowContext::pred
int pred
Definition: snow.h:193
W_BO
#define W_BO
Definition: snow_dwt.h:78
SnowContext::pass1_rc
int pass1_rc
Definition: snow.h:159
SnowContext::hdsp
HpelDSPContext hdsp
Definition: snow.h:119
SnowContext::memc_only
int memc_only
Definition: snow.h:176
put_symbol
static void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: snow.h:510
MotionEstContext
Motion estimation context.
Definition: motion_est.h:47
SnowContext::current_picture
AVFrame * current_picture
Definition: snow.h:126
init_ref
static void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index)
Definition: snow.h:488
MB_SIZE
#define MB_SIZE
Definition: snow.h:74
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
index
fg index
Definition: ffmpeg_filter.c:168
w
uint8_t w
Definition: llviddspenc.c:38
SubBand::width
int width
Definition: cfhd.h:112
SubBand::level
int level
Definition: diracdec.c:92
b
#define b
Definition: input.c:40
rangecoder.h
FRAC_BITS
#define FRAC_BITS
Definition: snow.h:46
x_and_coeff::x
int16_t x
Definition: snow.h:79
SnowContext::scratchbuf
uint8_t * scratchbuf
Definition: snow.h:185
mpegvideo.h
SnowDWTContext
Definition: snow_dwt.h:56
SnowContext::block_state
uint8_t block_state[128+32 *128]
Definition: snow.h:132
SnowContext
Definition: snow.h:114
SubBand::state
uint8_t state[7+512][32]
Definition: snow.h:96
MAX_REF_FRAMES
#define MAX_REF_FRAMES
Definition: snow.h:47
SnowContext::run_buffer
int * run_buffer
Definition: snow.h:150
SubBand::buf
DWTELEM * buf
Definition: snow.h:89
SnowContext::chroma_h_shift
int chroma_h_shift
Definition: snow.h:152
SnowContext::h264qpel
H264QpelContext h264qpel
Definition: snow.h:122
SnowContext::keyframe
int keyframe
Definition: snow.h:133
SubBand::ibuf
IDWTELEM * ibuf
Definition: snow.h:90
Plane::diag_mc
int diag_mc
Definition: snow.h:106
BlockNode::type
uint8_t type
Bitfield of BLOCK_*.
Definition: snow.h:56
state
static struct @319 state
SnowContext::ref_frames
int ref_frames
Definition: snow.h:143
SnowContext::mecc
MECmpContext mecc
Definition: snow.h:118
SubBand::parent
struct SubBand * parent
Definition: diracdec.c:100
h264qpel.h
LOG2_OBMC_MAX
#define LOG2_OBMC_MAX
Definition: snow.h:49
BlockNode
Definition: snow.h:51
predict_slice
static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y)
Definition: snow.h:405
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
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1377
SnowContext::always_reset
int always_reset
Definition: snow.h:134
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:97
x_and_coeff::coeff
uint16_t coeff
Definition: snow.h:80
SnowContext::b_height
int b_height
Definition: snow.h:166
x_and_coeff
Definition: snow.h:78
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
get_symbol
static int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
Definition: snow.h:541
SnowContext::temporal_decomposition_type
int temporal_decomposition_type
Definition: snow.h:138
SnowContext::lambda
int lambda
Definition: snow.h:157
SnowContext::colorspace_type
int colorspace_type
Definition: snow.h:151
motion_vector.h
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
SnowContext::m
MpegEncContext m
Definition: snow.h:183
SnowContext::me_cache_generation
unsigned me_cache_generation
Definition: snow.h:174
ff_snow_common_init_after_header
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:511
SnowContext::scenechange_threshold
int scenechange_threshold
Definition: snow.h:181
SnowContext::qbias
int qbias
Definition: snow.h:162
SubBand::stride_line
int stride_line
Stride measured in lines, not pixels.
Definition: snow.h:93
SnowContext::chroma_v_shift
int chroma_v_shift
Definition: snow.h:153
SnowContext::header_state
uint8_t header_state[32]
Definition: snow.h:131
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:281
SnowContext::c
RangeCoder c
Definition: snow.h:117
SnowContext::avmv
AVMotionVector * avmv
Definition: snow.h:188
snow_horizontal_compose_lift_lead_out
static av_always_inline void snow_horizontal_compose_lift_lead_out(int i, IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref, int width, int w, int lift_high, int mul, int add, int shift)
Definition: snow.h:219
SnowContext::spatial_idwt_buffer
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:148
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:319
mul
static float mul(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:39
SnowContext::spatial_scalability
int spatial_scalability
Definition: snow.h:154
SnowContext::emu_edge_buffer
uint8_t * emu_edge_buffer
Definition: snow.h:186
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
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:53
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:203
SnowContext::mpvencdsp
MpegvideoEncDSPContext mpvencdsp
Definition: snow.h:123
BlockNode::my
int16_t my
Motion vector component Y, see mv_scale.
Definition: snow.h:53
SnowContext::qdsp
QpelDSPContext qdsp
Definition: snow.h:120
src
#define src
Definition: vp8dsp.c:255
mathops.h
get_symbol2
static int get_symbol2(RangeCoder *c, uint8_t *state, int log2)
Definition: snow.h:584
qpeldsp.h
ff_snow_common_init
int ff_snow_common_init(AVCodecContext *avctx)
Definition: snow.c:429
QROOT
#define QROOT
Definition: snow.h:44
SnowContext::temp_idwt_buffer
IDWTELEM * temp_idwt_buffer
Definition: snow.h:149
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ff_snow_common_end
void ff_snow_common_end(SnowContext *s)
Definition: snow.c:690
ff_snow_release_buffer
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:637
SnowContext::encoding_error
uint64_t encoding_error[AV_NUM_DATA_POINTERS]
Definition: snow.h:191
SnowContext::last_spatial_decomposition_type
int last_spatial_decomposition_type
Definition: snow.h:137
SnowContext::ref_scores
uint32_t * ref_scores[MAX_REF_FRAMES]
Definition: snow.h:145
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
SnowContext::spatial_decomposition_type
int spatial_decomposition_type
Definition: snow.h:136
SnowContext::intra_penalty
int intra_penalty
Definition: snow.h:178
SubBand::stride
ptrdiff_t stride
Definition: cfhd.h:110
Plane::height
int height
Definition: cfhd.h:120
Plane::last_hcoeff
int8_t last_hcoeff[HTAPS_MAX/2]
Definition: snow.h:110
obmc4
static const uint8_t obmc4[16]
Definition: snowdata.h:96
pred_mv
static void pred_mv(SnowContext *s, int *mx, int *my, int ref, const BlockNode *left, const BlockNode *top, const BlockNode *tr)
Definition: snow.h:255
SnowContext::spatial_dwt_buffer
DWTELEM * spatial_dwt_buffer
Definition: snow.h:146
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:304
SnowContext::last_qlog
int last_qlog
Definition: snow.h:156
SubBand
Definition: cfhd.h:109
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
Plane::htaps
int htaps
Definition: snow.h:104
Plane::last_htaps
int last_htaps
Definition: snow.h:109
Plane::width
int width
Definition: cfhd.h:119
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
SnowContext::vdsp
VideoDSPContext vdsp
Definition: snow.h:121
SnowContext::motion_est
int motion_est
Definition: snow.h:179
SnowContext::max_ref_frames
int max_ref_frames
Definition: snow.h:142
ff_quant3bA
const int8_t ff_quant3bA[256]
Definition: snowdata.h:104
Plane::hcoeff
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:105
DWTELEM
int DWTELEM
Definition: dirac_dwt.h:26
unpack_coeffs
static void unpack_coeffs(SnowContext *s, SubBand *b, SubBand *parent, int orientation)
Definition: snow.h:604
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:64
SnowContext::qlog
int qlog
Definition: snow.h:155
ff_snow_frame_start
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:652
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
BLOCK_INTRA
#define BLOCK_INTRA
Intra block, inter otherwise.
Definition: snow.h:58
SnowContext::last_mv_scale
int last_mv_scale
Definition: snow.h:161
SnowContext::temp_dwt_buffer
DWTELEM * temp_dwt_buffer
Definition: snow.h:147
SnowContext::lambda2
int lambda2
Definition: snow.h:158
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SnowContext::ref_mvs
int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]
Definition: snow.h:144
ff_qexp
const uint8_t ff_qexp[QROOT]
Definition: snowdata.h:128
predict_plane
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
Definition: snow.h:456
put_symbol2
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
Definition: snow.h:564
get_rac
static int get_rac(RangeCoder *c, uint8_t *const state)
Definition: rangecoder.h:127
H264QpelContext
Definition: h264qpel.h:27
MAX_PLANES
#define MAX_PLANES
Definition: snow.h:42
log2
#define log2(x)
Definition: libm.h:404
SnowContext::input_picture
AVFrame * input_picture
new_picture with the internal linesizes
Definition: snow.h:125
mid_pred
#define mid_pred
Definition: mathops.h:97
W_BS
#define W_BS
Definition: snow_dwt.h:79
SnowContext::nb_planes
int nb_planes
Definition: snow.h:169
SnowContext::last_qbias
int last_qbias
Definition: snow.h:163
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
SubBand::buf_x_offset
int buf_x_offset
Definition: snow.h:91
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)
me_cmp.h
SubBand::qlog
int qlog
log(qscale)/log[2^(1/6)]
Definition: snow.h:88
SnowContext::block
BlockNode * block
Definition: snow.h:171
QpelDSPContext
quarterpel DSP context
Definition: qpeldsp.h:72
SnowContext::temporal_decomposition_count
int temporal_decomposition_count
Definition: snow.h:141
AVCodecContext
main external API structure.
Definition: avcodec.h:383
SnowContext::halfpel_plane
uint8_t * halfpel_plane[MAX_REF_FRAMES][4][4]
Definition: snow.h:128
SnowContext::sb
slice_buffer sb
Definition: snow.h:175
ME_CACHE_SIZE
#define ME_CACHE_SIZE
Definition: snow.h:172
SnowContext::last_block_max_depth
int last_block_max_depth
Definition: snow.h:168
SnowContext::b_width
int b_width
Definition: snow.h:165
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
snow_horizontal_compose_liftS_lead_out
static av_always_inline void snow_horizontal_compose_liftS_lead_out(int i, IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref, int width, int w)
Definition: snow.h:229
SnowContext::mv_scale
int mv_scale
Definition: snow.h:160
SnowContext::plane
Plane plane[MAX_PLANES]
Definition: snow.h:170
Plane
Definition: cfhd.h:118
SnowContext::last_picture
AVFrame * last_picture[MAX_REF_FRAMES]
Definition: snow.h:127
VideoDSPContext
Definition: videodsp.h:41
SnowContext::block_max_depth
int block_max_depth
Definition: snow.h:167
shift
static int shift(int a, int b)
Definition: sonic.c:83
BlockNode::level
uint8_t level
Definition: snow.h:61
same_block
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
Definition: snow.h:271
add
static float add(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:35
Plane::band
SubBand band[DWT_LEVELS_3D][4]
Definition: cfhd.h:131
ff_scale_mv_ref
int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]
Definition: snowdata.h:135
BlockNode::mx
int16_t mx
Motion vector component X, see mv_scale.
Definition: snow.h:52
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:216
SnowContext::iterative_dia_size
int iterative_dia_size
Definition: snow.h:180
HTAPS_MAX
#define HTAPS_MAX
Definition: snow.h:76
SnowContext::spatial_decomposition_count
int spatial_decomposition_count
Definition: snow.h:139
null_block
static const BlockNode null_block
Definition: snow.h:64
hpeldsp.h
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:73
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
SnowContext::no_bitstream
int no_bitstream
Definition: snow.h:177
IDWTELEM
short IDWTELEM
Definition: dirac_dwt.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
RangeCoder
Definition: mss3.c:61
snow_interleave_line_header
static av_always_inline void snow_interleave_line_header(int *i, int width, IDWTELEM *low, IDWTELEM *high)
Definition: snow.h:203
SnowContext::mconly_picture
AVFrame * mconly_picture
Definition: snow.h:129
snow_interleave_line_footer
static av_always_inline void snow_interleave_line_footer(int *i, IDWTELEM *low, IDWTELEM *high)
Definition: snow.h:212
SubBand::buf_y_offset
int buf_y_offset
Definition: snow.h:92
SnowContext::last_spatial_decomposition_count
int last_spatial_decomposition_count
Definition: snow.h:140
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:71
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
BlockNode::ref
uint8_t ref
Reference frame index.
Definition: snow.h:54
SnowContext::avctx
AVCodecContext * avctx
Definition: snow.h:116
SnowContext::avmv_index
int avmv_index
Definition: snow.h:190
SnowContext::version
int version
Definition: snow.h:135
SnowContext::dwt
SnowDWTContext dwt
Definition: snow.h:124
SubBand::height
int height
Definition: cfhd.h:114
SubBand::x_coeff
x_and_coeff * x_coeff
Definition: snow.h:94