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 
191 
192  int pred;
193 }SnowContext;
194 
195 /* Tables */
196 extern const uint8_t * const ff_obmc_tab[4];
197 extern const uint8_t ff_qexp[QROOT];
199 
200 /* C bits used by mmx/sse2/altivec */
201 
202 static av_always_inline void snow_interleave_line_header(int * i, int width, IDWTELEM * low, IDWTELEM * high){
203  (*i) = (width) - 2;
204 
205  if (width & 1){
206  low[(*i)+1] = low[((*i)+1)>>1];
207  (*i)--;
208  }
209 }
210 
212  for (; (*i)>=0; (*i)-=2){
213  low[(*i)+1] = high[(*i)>>1];
214  low[*i] = low[(*i)>>1];
215  }
216 }
217 
218 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){
219  for(; i<w; i++){
220  dst[i] = src[i] - ((mul * (ref[i] + ref[i + 1]) + add) >> shift);
221  }
222 
223  if((width^lift_high)&1){
224  dst[w] = src[w] - ((mul * 2 * ref[w] + add) >> shift);
225  }
226 }
227 
229  for(; i<w; i++){
230  dst[i] = src[i] + ((ref[i] + ref[(i+1)]+W_BO + 4 * src[i]) >> W_BS);
231  }
232 
233  if(width&1){
234  dst[w] = src[w] + ((2 * ref[w] + W_BO + 4 * src[w]) >> W_BS);
235  }
236 }
237 
238 /* common code */
239 
247 void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride,
248  int sx, int sy, int b_w, int b_h, const BlockNode *block,
249  int plane_index, int w, int h);
251 /* common inline functions */
252 //XXX doublecheck all of them should stay inlined
253 
254 static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
255  const BlockNode *left, const BlockNode *top, const BlockNode *tr){
256  if(s->ref_frames == 1){
257  *mx = mid_pred(left->mx, top->mx, tr->mx);
258  *my = mid_pred(left->my, top->my, tr->my);
259  }else{
260  const int *scale = ff_scale_mv_ref[ref];
261  *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
262  (top ->mx * scale[top ->ref] + 128) >>8,
263  (tr ->mx * scale[tr ->ref] + 128) >>8);
264  *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
265  (top ->my * scale[top ->ref] + 128) >>8,
266  (tr ->my * scale[tr ->ref] + 128) >>8);
267  }
268 }
269 
271  if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
272  return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
273  }else{
274  return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
275  }
276 }
277 
278 //FIXME name cleanup (b_w, block_w, b_width stuff)
279 //XXX should we really inline it?
280 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){
281  const int b_width = s->b_width << s->block_max_depth;
282  const int b_height= s->b_height << s->block_max_depth;
283  const int b_stride= b_width;
284  BlockNode *lt= &s->block[b_x + b_y*b_stride];
285  BlockNode *rt= lt+1;
286  BlockNode *lb= lt+b_stride;
287  BlockNode *rb= lb+1;
288  uint8_t *block[4];
289  // When src_stride is large enough, it is possible to interleave the blocks.
290  // Otherwise the blocks are written sequentially in the tmp buffer.
291  int tmp_step= src_stride >= 7*MB_SIZE ? MB_SIZE : MB_SIZE*src_stride;
292  uint8_t *tmp = s->scratchbuf;
293  uint8_t *ptmp;
294  int x,y;
295 
296  if(b_x<0){
297  lt= rt;
298  lb= rb;
299  }else if(b_x + 1 >= b_width){
300  rt= lt;
301  rb= lb;
302  }
303  if(b_y<0){
304  lt= lb;
305  rt= rb;
306  }else if(b_y + 1 >= b_height){
307  lb= lt;
308  rb= rt;
309  }
310 
311  if(src_x<0){ //FIXME merge with prev & always round internal width up to *16
312  obmc -= src_x;
313  b_w += src_x;
314  if(!sliced && !offset_dst)
315  dst -= src_x;
316  src_x=0;
317  }
318  if(src_x + b_w > w){
319  b_w = w - src_x;
320  }
321  if(src_y<0){
322  obmc -= src_y*obmc_stride;
323  b_h += src_y;
324  if(!sliced && !offset_dst)
325  dst -= src_y*dst_stride;
326  src_y=0;
327  }
328  if(src_y + b_h> h){
329  b_h = h - src_y;
330  }
331 
332  if(b_w<=0 || b_h<=0) return;
333 
334  if(!sliced && offset_dst)
335  dst += src_x + src_y*dst_stride;
336  dst8+= src_x + src_y*src_stride;
337 // src += src_x + src_y*src_stride;
338 
339  ptmp= tmp + 3*tmp_step;
340  block[0]= ptmp;
341  ptmp+=tmp_step;
342  ff_snow_pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
343 
344  if(same_block(lt, rt)){
345  block[1]= block[0];
346  }else{
347  block[1]= ptmp;
348  ptmp+=tmp_step;
349  ff_snow_pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
350  }
351 
352  if(same_block(lt, lb)){
353  block[2]= block[0];
354  }else if(same_block(rt, lb)){
355  block[2]= block[1];
356  }else{
357  block[2]= ptmp;
358  ptmp+=tmp_step;
359  ff_snow_pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
360  }
361 
362  if(same_block(lt, rb) ){
363  block[3]= block[0];
364  }else if(same_block(rt, rb)){
365  block[3]= block[1];
366  }else if(same_block(lb, rb)){
367  block[3]= block[2];
368  }else{
369  block[3]= ptmp;
370  ff_snow_pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
371  }
372  if(sliced){
373  s->dwt.inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
374  }else{
375  for(y=0; y<b_h; y++){
376  //FIXME ugly misuse of obmc_stride
377  const uint8_t *obmc1= obmc + y*obmc_stride;
378  const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
379  const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
380  const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
381  for(x=0; x<b_w; x++){
382  int v= obmc1[x] * block[3][x + y*src_stride]
383  +obmc2[x] * block[2][x + y*src_stride]
384  +obmc3[x] * block[1][x + y*src_stride]
385  +obmc4[x] * block[0][x + y*src_stride];
386 
387  v <<= 8 - LOG2_OBMC_MAX;
388  if(FRAC_BITS != 8){
389  v >>= 8 - FRAC_BITS;
390  }
391  if(add){
392  v += dst[x + y*dst_stride];
393  v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
394  if(v&(~255)) v= ~(v>>31);
395  dst8[x + y*src_stride] = v;
396  }else{
397  dst[x + y*dst_stride] -= v;
398  }
399  }
400  }
401  }
402 }
403 
404 static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y){
405  Plane *p= &s->plane[plane_index];
406  const int mb_w= s->b_width << s->block_max_depth;
407  const int mb_h= s->b_height << s->block_max_depth;
408  int x, y, mb_x;
409  int block_size = MB_SIZE >> s->block_max_depth;
410  int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
411  int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
412  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
413  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
414  int ref_stride= s->current_picture->linesize[plane_index];
415  uint8_t *dst8= s->current_picture->data[plane_index];
416  int w= p->width;
417  int h= p->height;
418  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // obmc params assume squares
419  if(s->keyframe || (s->avctx->debug&512)){
420  if(mb_y==mb_h)
421  return;
422 
423  if(add){
424  for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
425  for(x=0; x<w; x++){
426  int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
427  v >>= FRAC_BITS;
428  if(v&(~255)) v= ~(v>>31);
429  dst8[x + y*ref_stride]= v;
430  }
431  }
432  }else{
433  for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
434  for(x=0; x<w; x++){
435  buf[x + y*w]-= 128<<FRAC_BITS;
436  }
437  }
438  }
439 
440  return;
441  }
442 
443  for(mb_x=0; mb_x<=mb_w; mb_x++){
444  add_yblock(s, 0, NULL, buf, dst8, obmc,
445  block_w*mb_x - block_w/2,
446  block_h*mb_y - block_h/2,
447  block_w, block_h,
448  w, h,
449  w, ref_stride, obmc_stride,
450  mb_x - 1, mb_y - 1,
451  add, 1, plane_index);
452  }
453 }
454 
455 static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add){
456  const int mb_h= s->b_height << s->block_max_depth;
457  int mb_y;
458  for(mb_y=0; mb_y<=mb_h; mb_y++)
459  predict_slice(s, buf, plane_index, add, mb_y);
460 }
461 
462 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){
463  const int w= s->b_width << s->block_max_depth;
464  const int rem_depth= s->block_max_depth - level;
465  const int index= (x + y*w) << rem_depth;
466  const int block_w= 1<<rem_depth;
467  const int block_h= 1<<rem_depth; //FIXME "w!=h"
469  int i,j;
470 
471  block.color[0]= l;
472  block.color[1]= cb;
473  block.color[2]= cr;
474  block.mx= mx;
475  block.my= my;
476  block.ref= ref;
477  block.type= type;
478  block.level= level;
479 
480  for(j=0; j<block_h; j++){
481  for(i=0; i<block_w; i++){
482  s->block[index + i + j*w]= block;
483  }
484  }
485 }
486 
487 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){
488  SnowContext *s = c->avctx->priv_data;
489  const int offset[3]= {
490  y*c-> stride + x,
491  ((y*c->uvstride + x)>>s->chroma_h_shift),
492  ((y*c->uvstride + x)>>s->chroma_h_shift),
493  };
494  int i;
495  for(i=0; i<3; i++){
496  c->src[0][i]= src [i];
497  c->ref[0][i]= ref [i] + offset[i];
498  }
499  av_assert2(!ref_index);
500 }
501 
502 
503 /* bitstream functions */
504 
505 extern const int8_t ff_quant3bA[256];
506 
507 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
508 
509 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
510  int i;
511 
512  if(v){
513  const int a= FFABS(v);
514  const int e= av_log2(a);
515  const int el= FFMIN(e, 10);
516  put_rac(c, state+0, 0);
517 
518  for(i=0; i<el; i++){
519  put_rac(c, state+1+i, 1); //1..10
520  }
521  for(; i<e; i++){
522  put_rac(c, state+1+9, 1); //1..10
523  }
524  put_rac(c, state+1+FFMIN(i,9), 0);
525 
526  for(i=e-1; i>=el; i--){
527  put_rac(c, state+22+9, (a>>i)&1); //22..31
528  }
529  for(; i>=0; i--){
530  put_rac(c, state+22+i, (a>>i)&1); //22..31
531  }
532 
533  if(is_signed)
534  put_rac(c, state+11 + el, v < 0); //11..21
535  }else{
536  put_rac(c, state+0, 1);
537  }
538 }
539 
540 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
541  if(get_rac(c, state+0))
542  return 0;
543  else{
544  int i, e;
545  unsigned a;
546  e= 0;
547  while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
548  e++;
549  if (e > 31)
550  return AVERROR_INVALIDDATA;
551  }
552 
553  a= 1;
554  for(i=e-1; i>=0; i--){
555  a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
556  }
557 
558  e= -(is_signed && get_rac(c, state+11 + FFMIN(e,10))); //11..21
559  return (a^e)-e;
560  }
561 }
562 
563 static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2){
564  int i;
565  int r= log2>=0 ? 1<<log2 : 1;
566 
567  av_assert2(v>=0);
568  av_assert2(log2>=-4);
569 
570  while(v >= r){
571  put_rac(c, state+4+log2, 1);
572  v -= r;
573  log2++;
574  if(log2>0) r+=r;
575  }
576  put_rac(c, state+4+log2, 0);
577 
578  for(i=log2-1; i>=0; i--){
579  put_rac(c, state+31-i, (v>>i)&1);
580  }
581 }
582 
583 static inline int get_symbol2(RangeCoder *c, uint8_t *state, int log2){
584  int i;
585  int r= log2>=0 ? 1<<log2 : 1;
586  int v=0;
587 
588  av_assert2(log2>=-4);
589 
590  while(log2<28 && get_rac(c, state+4+log2)){
591  v+= r;
592  log2++;
593  if(log2>0) r+=r;
594  }
595 
596  for(i=log2-1; i>=0; i--){
597  v+= get_rac(c, state+31-i)<<i;
598  }
599 
600  return v;
601 }
602 
603 static inline void unpack_coeffs(SnowContext *s, SubBand *b, SubBand * parent, int orientation){
604  const int w= b->width;
605  const int h= b->height;
606  int x,y;
607 
608  int run, runs;
609  x_and_coeff *xc= b->x_coeff;
610  x_and_coeff *prev_xc= NULL;
611  x_and_coeff *prev2_xc= xc;
612  x_and_coeff *parent_xc= parent ? parent->x_coeff : NULL;
613  x_and_coeff *prev_parent_xc= parent_xc;
614 
615  runs= get_symbol2(&s->c, b->state[30], 0);
616  if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
617  else run= INT_MAX;
618 
619  for(y=0; y<h; y++){
620  int v=0;
621  int lt=0, t=0, rt=0;
622 
623  if(y && prev_xc->x == 0){
624  rt= prev_xc->coeff;
625  }
626  for(x=0; x<w; x++){
627  int p=0;
628  const int l= v;
629 
630  lt= t; t= rt;
631 
632  if(y){
633  if(prev_xc->x <= x)
634  prev_xc++;
635  if(prev_xc->x == x + 1)
636  rt= prev_xc->coeff;
637  else
638  rt=0;
639  }
640  if(parent_xc){
641  if(x>>1 > parent_xc->x){
642  parent_xc++;
643  }
644  if(x>>1 == parent_xc->x){
645  p= parent_xc->coeff;
646  }
647  }
648  if(/*ll|*/l|lt|t|rt|p){
649  int context= av_log2(/*FFABS(ll) + */3*(l>>1) + (lt>>1) + (t&~1) + (rt>>1) + (p>>1));
650 
651  v=get_rac(&s->c, &b->state[0][context]);
652  if(v){
653  v= 2*(get_symbol2(&s->c, b->state[context + 2], context-4) + 1);
654  v+=get_rac(&s->c, &b->state[0][16 + 1 + 3 + ff_quant3bA[l&0xFF] + 3*ff_quant3bA[t&0xFF]]);
655  if ((uint16_t)v != v) {
656  av_log(s->avctx, AV_LOG_ERROR, "Coefficient damaged\n");
657  v = 1;
658  }
659  xc->x=x;
660  (xc++)->coeff= v;
661  }
662  }else{
663  if(!run){
664  if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
665  else run= INT_MAX;
666  v= 2*(get_symbol2(&s->c, b->state[0 + 2], 0-4) + 1);
667  v+=get_rac(&s->c, &b->state[0][16 + 1 + 3]);
668  if ((uint16_t)v != v) {
669  av_log(s->avctx, AV_LOG_ERROR, "Coefficient damaged\n");
670  v = 1;
671  }
672 
673  xc->x=x;
674  (xc++)->coeff= v;
675  }else{
676  int max_run;
677  run--;
678  v=0;
679  av_assert2(run >= 0);
680  if(y) max_run= FFMIN(run, prev_xc->x - x - 2);
681  else max_run= FFMIN(run, w-x-1);
682  if(parent_xc)
683  max_run= FFMIN(max_run, 2*parent_xc->x - x - 1);
684  av_assert2(max_run >= 0 && max_run <= run);
685 
686  x+= max_run;
687  run-= max_run;
688  }
689  }
690  }
691  (xc++)->x= w+1; //end marker
692  prev_xc= prev2_xc;
693  prev2_xc= xc;
694 
695  if(parent_xc){
696  if(y&1){
697  while(parent_xc->x != parent->width+1)
698  parent_xc++;
699  parent_xc++;
700  prev_parent_xc= parent_xc;
701  }else{
702  parent_xc= prev_parent_xc;
703  }
704  }
705  }
706 
707  (xc++)->x= w+1; //end marker
708 }
709 
710 #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::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:462
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:583
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:192
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:509
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:487
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
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:404
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
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:540
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:280
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:218
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
state
static struct @317 state
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:583
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:689
ff_snow_release_buffer
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:636
SnowContext::encoding_error
uint64_t encoding_error[AV_NUM_DATA_POINTERS]
Definition: snow.h:190
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:254
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:603
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
i
int i
Definition: input.c:406
ff_snow_frame_start
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:651
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:455
put_symbol2
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
Definition: snow.h:563
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:379
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:228
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:270
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:202
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:211
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:81
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:189
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