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 SNOW_MAX_PLANES 4
39 
40 #define FF_ME_ITER 3
41 
42 #define MID_STATE 128
43 
44 #define MAX_PLANES 4
45 #define QSHIFT 5
46 #define QROOT (1<<QSHIFT)
47 #define LOSSLESS_QLOG -128
48 #define FRAC_BITS 4
49 #define MAX_REF_FRAMES 8
50 
51 #define LOG2_OBMC_MAX 8
52 #define OBMC_MAX (1<<(LOG2_OBMC_MAX))
53 typedef struct BlockNode{
54  int16_t mx; ///< Motion vector component X, see mv_scale
55  int16_t my; ///< Motion vector component Y, see mv_scale
56  uint8_t ref; ///< Reference frame index
57  uint8_t color[3]; ///< Color for intra
58  uint8_t type; ///< Bitfield of BLOCK_*
59 //#define TYPE_SPLIT 1
60 #define BLOCK_INTRA 1 ///< Intra block, inter otherwise
61 #define BLOCK_OPT 2 ///< Block needs no checks in this round of iterative motion estiation
62 //#define TYPE_NOCOLOR 4
63  uint8_t level; //FIXME merge into type?
64 }BlockNode;
65 
66 static const BlockNode null_block= { //FIXME add border maybe
67  .color= {128,128,128},
68  .mx= 0,
69  .my= 0,
70  .ref= 0,
71  .type= 0,
72  .level= 0,
73 };
74 
75 #define LOG2_MB_SIZE 4
76 #define MB_SIZE (1<<LOG2_MB_SIZE)
77 #define ENCODER_EXTRA_BITS 4
78 #define HTAPS_MAX 8
79 
80 typedef struct x_and_coeff{
81  int16_t x;
82  uint16_t coeff;
83 } x_and_coeff;
84 
85 typedef struct SubBand{
86  int level;
87  int stride;
88  int width;
89  int height;
90  int qlog; ///< log(qscale)/log[2^(1/6)]
95  int stride_line; ///< Stride measured in lines, not pixels.
97  struct SubBand *parent;
98  uint8_t state[/*7*2*/ 7 + 512][32];
99 }SubBand;
100 
101 typedef struct Plane{
102  int width;
103  int height;
105 
106  int htaps;
107  int8_t hcoeff[HTAPS_MAX/2];
108  int diag_mc;
109  int fast_mc;
110 
114 }Plane;
115 
116 typedef struct SnowContext{
117  AVClass *class;
127  AVFrame *input_picture; ///< new_picture with the internal linesizes
130  uint8_t *halfpel_plane[MAX_REF_FRAMES][4][4];
132 // uint8_t q_context[16];
133  uint8_t header_state[32];
134  uint8_t block_state[128 + 32*128];
135  int keyframe;
137  int version;
146  int16_t (*ref_mvs[MAX_REF_FRAMES])[2];
157  int qlog;
159  int lambda;
160  int lambda2;
161  int pass1_rc;
162  int mv_scale;
164  int qbias;
166 #define QBIAS_SHIFT 3
167  int b_width;
168  int b_height;
174 #define ME_CACHE_SIZE 1024
177  slice_buffer sb;
184 
185  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)
186 
187  uint8_t *scratchbuf;
188  uint8_t *emu_edge_buffer;
189 
191  unsigned avmv_size;
194 
195  int pred;
196 }SnowContext;
197 
198 /* Tables */
199 extern const uint8_t * const ff_obmc_tab[4];
200 extern const uint8_t ff_qexp[QROOT];
202 
203 /* C bits used by mmx/sse2/altivec */
204 
205 static av_always_inline void snow_interleave_line_header(int * i, int width, IDWTELEM * low, IDWTELEM * high){
206  (*i) = (width) - 2;
207 
208  if (width & 1){
209  low[(*i)+1] = low[((*i)+1)>>1];
210  (*i)--;
211  }
212 }
213 
215  for (; (*i)>=0; (*i)-=2){
216  low[(*i)+1] = high[(*i)>>1];
217  low[*i] = low[(*i)>>1];
218  }
219 }
220 
221 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){
222  for(; i<w; i++){
223  dst[i] = src[i] - ((mul * (ref[i] + ref[i + 1]) + add) >> shift);
224  }
225 
226  if((width^lift_high)&1){
227  dst[w] = src[w] - ((mul * 2 * ref[w] + add) >> shift);
228  }
229 }
230 
232  for(; i<w; i++){
233  dst[i] = src[i] + ((ref[i] + ref[(i+1)]+W_BO + 4 * src[i]) >> W_BS);
234  }
235 
236  if(width&1){
237  dst[w] = src[w] + ((2 * ref[w] + W_BO + 4 * src[w]) >> W_BS);
238  }
239 }
240 
241 /* common code */
242 
250 void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride,
251  int sx, int sy, int b_w, int b_h, const BlockNode *block,
252  int plane_index, int w, int h);
254 /* common inline functions */
255 //XXX doublecheck all of them should stay inlined
256 
257 static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
258  const BlockNode *left, const BlockNode *top, const BlockNode *tr){
259  if(s->ref_frames == 1){
260  *mx = mid_pred(left->mx, top->mx, tr->mx);
261  *my = mid_pred(left->my, top->my, tr->my);
262  }else{
263  const int *scale = ff_scale_mv_ref[ref];
264  *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
265  (top ->mx * scale[top ->ref] + 128) >>8,
266  (tr ->mx * scale[tr ->ref] + 128) >>8);
267  *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
268  (top ->my * scale[top ->ref] + 128) >>8,
269  (tr ->my * scale[tr ->ref] + 128) >>8);
270  }
271 }
272 
274  if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
275  return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
276  }else{
277  return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
278  }
279 }
280 
281 //FIXME name cleanup (b_w, block_w, b_width stuff)
282 //XXX should we really inline it?
283 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){
284  const int b_width = s->b_width << s->block_max_depth;
285  const int b_height= s->b_height << s->block_max_depth;
286  const int b_stride= b_width;
287  BlockNode *lt= &s->block[b_x + b_y*b_stride];
288  BlockNode *rt= lt+1;
289  BlockNode *lb= lt+b_stride;
290  BlockNode *rb= lb+1;
291  uint8_t *block[4];
292  // When src_stride is large enough, it is possible to interleave the blocks.
293  // Otherwise the blocks are written sequentially in the tmp buffer.
294  int tmp_step= src_stride >= 7*MB_SIZE ? MB_SIZE : MB_SIZE*src_stride;
295  uint8_t *tmp = s->scratchbuf;
296  uint8_t *ptmp;
297  int x,y;
298 
299  if(b_x<0){
300  lt= rt;
301  lb= rb;
302  }else if(b_x + 1 >= b_width){
303  rt= lt;
304  rb= lb;
305  }
306  if(b_y<0){
307  lt= lb;
308  rt= rb;
309  }else if(b_y + 1 >= b_height){
310  lb= lt;
311  rb= rt;
312  }
313 
314  if(src_x<0){ //FIXME merge with prev & always round internal width up to *16
315  obmc -= src_x;
316  b_w += src_x;
317  if(!sliced && !offset_dst)
318  dst -= src_x;
319  src_x=0;
320  }
321  if(src_x + b_w > w){
322  b_w = w - src_x;
323  }
324  if(src_y<0){
325  obmc -= src_y*obmc_stride;
326  b_h += src_y;
327  if(!sliced && !offset_dst)
328  dst -= src_y*dst_stride;
329  src_y=0;
330  }
331  if(src_y + b_h> h){
332  b_h = h - src_y;
333  }
334 
335  if(b_w<=0 || b_h<=0) return;
336 
337  if(!sliced && offset_dst)
338  dst += src_x + src_y*dst_stride;
339  dst8+= src_x + src_y*src_stride;
340 // src += src_x + src_y*src_stride;
341 
342  ptmp= tmp + 3*tmp_step;
343  block[0]= ptmp;
344  ptmp+=tmp_step;
345  ff_snow_pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
346 
347  if(same_block(lt, rt)){
348  block[1]= block[0];
349  }else{
350  block[1]= ptmp;
351  ptmp+=tmp_step;
352  ff_snow_pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
353  }
354 
355  if(same_block(lt, lb)){
356  block[2]= block[0];
357  }else if(same_block(rt, lb)){
358  block[2]= block[1];
359  }else{
360  block[2]= ptmp;
361  ptmp+=tmp_step;
362  ff_snow_pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
363  }
364 
365  if(same_block(lt, rb) ){
366  block[3]= block[0];
367  }else if(same_block(rt, rb)){
368  block[3]= block[1];
369  }else if(same_block(lb, rb)){
370  block[3]= block[2];
371  }else{
372  block[3]= ptmp;
373  ff_snow_pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
374  }
375  if(sliced){
376  s->dwt.inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
377  }else{
378  for(y=0; y<b_h; y++){
379  //FIXME ugly misuse of obmc_stride
380  const uint8_t *obmc1= obmc + y*obmc_stride;
381  const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
382  const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
383  const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
384  for(x=0; x<b_w; x++){
385  int v= obmc1[x] * block[3][x + y*src_stride]
386  +obmc2[x] * block[2][x + y*src_stride]
387  +obmc3[x] * block[1][x + y*src_stride]
388  +obmc4[x] * block[0][x + y*src_stride];
389 
390  v <<= 8 - LOG2_OBMC_MAX;
391  if(FRAC_BITS != 8){
392  v >>= 8 - FRAC_BITS;
393  }
394  if(add){
395  v += dst[x + y*dst_stride];
396  v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
397  if(v&(~255)) v= ~(v>>31);
398  dst8[x + y*src_stride] = v;
399  }else{
400  dst[x + y*dst_stride] -= v;
401  }
402  }
403  }
404  }
405 }
406 
407 static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y){
408  Plane *p= &s->plane[plane_index];
409  const int mb_w= s->b_width << s->block_max_depth;
410  const int mb_h= s->b_height << s->block_max_depth;
411  int x, y, mb_x;
412  int block_size = MB_SIZE >> s->block_max_depth;
413  int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
414  int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
415  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
416  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
417  int ref_stride= s->current_picture->linesize[plane_index];
418  uint8_t *dst8= s->current_picture->data[plane_index];
419  int w= p->width;
420  int h= p->height;
421  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // obmc params assume squares
422  if(s->keyframe || (s->avctx->debug&512)){
423  if(mb_y==mb_h)
424  return;
425 
426  if(add){
427  for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
428  for(x=0; x<w; x++){
429  int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
430  v >>= FRAC_BITS;
431  if(v&(~255)) v= ~(v>>31);
432  dst8[x + y*ref_stride]= v;
433  }
434  }
435  }else{
436  for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
437  for(x=0; x<w; x++){
438  buf[x + y*w]-= 128<<FRAC_BITS;
439  }
440  }
441  }
442 
443  return;
444  }
445 
446  for(mb_x=0; mb_x<=mb_w; mb_x++){
447  add_yblock(s, 0, NULL, buf, dst8, obmc,
448  block_w*mb_x - block_w/2,
449  block_h*mb_y - block_h/2,
450  block_w, block_h,
451  w, h,
452  w, ref_stride, obmc_stride,
453  mb_x - 1, mb_y - 1,
454  add, 1, plane_index);
455  }
456 }
457 
458 static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add){
459  const int mb_h= s->b_height << s->block_max_depth;
460  int mb_y;
461  for(mb_y=0; mb_y<=mb_h; mb_y++)
462  predict_slice(s, buf, plane_index, add, mb_y);
463 }
464 
465 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){
466  const int w= s->b_width << s->block_max_depth;
467  const int rem_depth= s->block_max_depth - level;
468  const int index= (x + y*w) << rem_depth;
469  const int block_w= 1<<rem_depth;
470  const int block_h= 1<<rem_depth; //FIXME "w!=h"
472  int i,j;
473 
474  block.color[0]= l;
475  block.color[1]= cb;
476  block.color[2]= cr;
477  block.mx= mx;
478  block.my= my;
479  block.ref= ref;
480  block.type= type;
481  block.level= level;
482 
483  for(j=0; j<block_h; j++){
484  for(i=0; i<block_w; i++){
485  s->block[index + i + j*w]= block;
486  }
487  }
488 }
489 
490 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){
491  SnowContext *s = c->avctx->priv_data;
492  const int offset[3]= {
493  y*c-> stride + x,
494  ((y*c->uvstride + x)>>s->chroma_h_shift),
495  ((y*c->uvstride + x)>>s->chroma_h_shift),
496  };
497  int i;
498  for(i=0; i<3; i++){
499  c->src[0][i]= src [i];
500  c->ref[0][i]= ref [i] + offset[i];
501  }
502  av_assert2(!ref_index);
503 }
504 
505 
506 /* bitstream functions */
507 
508 extern const int8_t ff_quant3bA[256];
509 
510 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
511 
512 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
513  int i;
514 
515  if(v){
516  const int a= FFABS(v);
517  const int e= av_log2(a);
518  const int el= FFMIN(e, 10);
519  put_rac(c, state+0, 0);
520 
521  for(i=0; i<el; i++){
522  put_rac(c, state+1+i, 1); //1..10
523  }
524  for(; i<e; i++){
525  put_rac(c, state+1+9, 1); //1..10
526  }
527  put_rac(c, state+1+FFMIN(i,9), 0);
528 
529  for(i=e-1; i>=el; i--){
530  put_rac(c, state+22+9, (a>>i)&1); //22..31
531  }
532  for(; i>=0; i--){
533  put_rac(c, state+22+i, (a>>i)&1); //22..31
534  }
535 
536  if(is_signed)
537  put_rac(c, state+11 + el, v < 0); //11..21
538  }else{
539  put_rac(c, state+0, 1);
540  }
541 }
542 
543 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
544  if(get_rac(c, state+0))
545  return 0;
546  else{
547  int i, e;
548  unsigned a;
549  e= 0;
550  while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
551  e++;
552  if (e > 31)
553  return AVERROR_INVALIDDATA;
554  }
555 
556  a= 1;
557  for(i=e-1; i>=0; i--){
558  a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
559  }
560 
561  e= -(is_signed && get_rac(c, state+11 + FFMIN(e,10))); //11..21
562  return (a^e)-e;
563  }
564 }
565 
566 static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2){
567  int i;
568  int r= log2>=0 ? 1<<log2 : 1;
569 
570  av_assert2(v>=0);
571  av_assert2(log2>=-4);
572 
573  while(v >= r){
574  put_rac(c, state+4+log2, 1);
575  v -= r;
576  log2++;
577  if(log2>0) r+=r;
578  }
579  put_rac(c, state+4+log2, 0);
580 
581  for(i=log2-1; i>=0; i--){
582  put_rac(c, state+31-i, (v>>i)&1);
583  }
584 }
585 
586 static inline int get_symbol2(RangeCoder *c, uint8_t *state, int log2){
587  int i;
588  int r= log2>=0 ? 1<<log2 : 1;
589  int v=0;
590 
591  av_assert2(log2>=-4);
592 
593  while(log2<28 && get_rac(c, state+4+log2)){
594  v+= r;
595  log2++;
596  if(log2>0) r+=r;
597  }
598 
599  for(i=log2-1; i>=0; i--){
600  v+= get_rac(c, state+31-i)<<i;
601  }
602 
603  return v;
604 }
605 
606 static inline void unpack_coeffs(SnowContext *s, SubBand *b, SubBand * parent, int orientation){
607  const int w= b->width;
608  const int h= b->height;
609  int x,y;
610 
611  int run, runs;
612  x_and_coeff *xc= b->x_coeff;
613  x_and_coeff *prev_xc= NULL;
614  x_and_coeff *prev2_xc= xc;
615  x_and_coeff *parent_xc= parent ? parent->x_coeff : NULL;
616  x_and_coeff *prev_parent_xc= parent_xc;
617 
618  runs= get_symbol2(&s->c, b->state[30], 0);
619  if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
620  else run= INT_MAX;
621 
622  for(y=0; y<h; y++){
623  int v=0;
624  int lt=0, t=0, rt=0;
625 
626  if(y && prev_xc->x == 0){
627  rt= prev_xc->coeff;
628  }
629  for(x=0; x<w; x++){
630  int p=0;
631  const int l= v;
632 
633  lt= t; t= rt;
634 
635  if(y){
636  if(prev_xc->x <= x)
637  prev_xc++;
638  if(prev_xc->x == x + 1)
639  rt= prev_xc->coeff;
640  else
641  rt=0;
642  }
643  if(parent_xc){
644  if(x>>1 > parent_xc->x){
645  parent_xc++;
646  }
647  if(x>>1 == parent_xc->x){
648  p= parent_xc->coeff;
649  }
650  }
651  if(/*ll|*/l|lt|t|rt|p){
652  int context= av_log2(/*FFABS(ll) + */3*(l>>1) + (lt>>1) + (t&~1) + (rt>>1) + (p>>1));
653 
654  v=get_rac(&s->c, &b->state[0][context]);
655  if(v){
656  v= 2*(get_symbol2(&s->c, b->state[context + 2], context-4) + 1);
657  v+=get_rac(&s->c, &b->state[0][16 + 1 + 3 + ff_quant3bA[l&0xFF] + 3*ff_quant3bA[t&0xFF]]);
658  if ((uint16_t)v != v) {
659  av_log(s->avctx, AV_LOG_ERROR, "Coefficient damaged\n");
660  v = 1;
661  }
662  xc->x=x;
663  (xc++)->coeff= v;
664  }
665  }else{
666  if(!run){
667  if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
668  else run= INT_MAX;
669  v= 2*(get_symbol2(&s->c, b->state[0 + 2], 0-4) + 1);
670  v+=get_rac(&s->c, &b->state[0][16 + 1 + 3]);
671  if ((uint16_t)v != v) {
672  av_log(s->avctx, AV_LOG_ERROR, "Coefficient damaged\n");
673  v = 1;
674  }
675 
676  xc->x=x;
677  (xc++)->coeff= v;
678  }else{
679  int max_run;
680  run--;
681  v=0;
682  av_assert2(run >= 0);
683  if(y) max_run= FFMIN(run, prev_xc->x - x - 2);
684  else max_run= FFMIN(run, w-x-1);
685  if(parent_xc)
686  max_run= FFMIN(max_run, 2*parent_xc->x - x - 1);
687  av_assert2(max_run >= 0 && max_run <= run);
688 
689  x+= max_run;
690  run-= max_run;
691  }
692  }
693  }
694  (xc++)->x= w+1; //end marker
695  prev_xc= prev2_xc;
696  prev2_xc= xc;
697 
698  if(parent_xc){
699  if(y&1){
700  while(parent_xc->x != parent->width+1)
701  parent_xc++;
702  parent_xc++;
703  prev_parent_xc= parent_xc;
704  }else{
705  parent_xc= prev_parent_xc;
706  }
707  }
708  }
709 
710  (xc++)->x= w+1; //end marker
711 }
712 
713 #endif /* AVCODEC_SNOW_H */
BlockNode::color
uint8_t color[3]
Color for intra.
Definition: snow.h:57
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:110
SnowContext::avmv_size
unsigned avmv_size
Definition: snow.h:191
SnowContext::me_cache
unsigned me_cache[ME_CACHE_SIZE]
Definition: snow.h:175
ff_snow_get_buffer
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
Definition: snow.c:69
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:465
Plane::last_diag_mc
int last_diag_mc
Definition: snow.h:113
level
uint8_t level
Definition: svq3.c:205
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:109
color
Definition: vf_paletteuse.c:600
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
state
static struct @322 state
AVMotionVector
Definition: motion_vector.h:24
SnowContext::pred
int pred
Definition: snow.h:195
W_BO
#define W_BO
Definition: snow_dwt.h:78
SnowContext::pass1_rc
int pass1_rc
Definition: snow.h:161
SnowContext::hdsp
HpelDSPContext hdsp
Definition: snow.h:121
SnowContext::memc_only
int memc_only
Definition: snow.h:178
put_symbol
static void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: snow.h:512
MotionEstContext
Motion estimation context.
Definition: motion_est.h:47
SnowContext::current_picture
AVFrame * current_picture
Definition: snow.h:128
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:490
MB_SIZE
#define MB_SIZE
Definition: snow.h:76
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
index
fg index
Definition: ffmpeg_filter.c:167
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:48
x_and_coeff::x
int16_t x
Definition: snow.h:81
SnowContext::scratchbuf
uint8_t * scratchbuf
Definition: snow.h:187
mpegvideo.h
SnowDWTContext
Definition: snow_dwt.h:56
SnowContext::block_state
uint8_t block_state[128+32 *128]
Definition: snow.h:134
SnowContext
Definition: snow.h:116
SubBand::state
uint8_t state[7+512][32]
Definition: snow.h:98
MAX_REF_FRAMES
#define MAX_REF_FRAMES
Definition: snow.h:49
SnowContext::run_buffer
int * run_buffer
Definition: snow.h:152
SubBand::buf
DWTELEM * buf
Definition: snow.h:91
SnowContext::chroma_h_shift
int chroma_h_shift
Definition: snow.h:154
SnowContext::h264qpel
H264QpelContext h264qpel
Definition: snow.h:124
SnowContext::keyframe
int keyframe
Definition: snow.h:135
SubBand::ibuf
IDWTELEM * ibuf
Definition: snow.h:92
Plane::diag_mc
int diag_mc
Definition: snow.h:108
BlockNode::type
uint8_t type
Bitfield of BLOCK_*.
Definition: snow.h:58
SnowContext::ref_frames
int ref_frames
Definition: snow.h:145
SnowContext::mecc
MECmpContext mecc
Definition: snow.h:120
SubBand::parent
struct SubBand * parent
Definition: diracdec.c:100
h264qpel.h
LOG2_OBMC_MAX
#define LOG2_OBMC_MAX
Definition: snow.h:51
BlockNode
Definition: snow.h:53
predict_slice
static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y)
Definition: snow.h:407
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:1388
SnowContext::always_reset
int always_reset
Definition: snow.h:136
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:96
x_and_coeff::coeff
uint16_t coeff
Definition: snow.h:82
SnowContext::b_height
int b_height
Definition: snow.h:168
x_and_coeff
Definition: snow.h:80
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:543
SnowContext::temporal_decomposition_type
int temporal_decomposition_type
Definition: snow.h:140
SnowContext::lambda
int lambda
Definition: snow.h:159
SnowContext::colorspace_type
int colorspace_type
Definition: snow.h:153
motion_vector.h
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
SnowContext::m
MpegEncContext m
Definition: snow.h:185
SnowContext::me_cache_generation
unsigned me_cache_generation
Definition: snow.h:176
ff_snow_common_init_after_header
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:510
SnowContext::scenechange_threshold
int scenechange_threshold
Definition: snow.h:183
SnowContext::qbias
int qbias
Definition: snow.h:164
SubBand::stride_line
int stride_line
Stride measured in lines, not pixels.
Definition: snow.h:95
SnowContext::chroma_v_shift
int chroma_v_shift
Definition: snow.h:155
SnowContext::header_state
uint8_t header_state[32]
Definition: snow.h:133
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:283
SnowContext::c
RangeCoder c
Definition: snow.h:119
SnowContext::avmv
AVMotionVector * avmv
Definition: snow.h:190
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:221
SnowContext::spatial_idwt_buffer
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:150
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:318
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:156
SnowContext::emu_edge_buffer
uint8_t * emu_edge_buffer
Definition: snow.h:188
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:204
SnowContext::mpvencdsp
MpegvideoEncDSPContext mpvencdsp
Definition: snow.h:125
BlockNode::my
int16_t my
Motion vector component Y, see mv_scale.
Definition: snow.h:55
SnowContext::qdsp
QpelDSPContext qdsp
Definition: snow.h:122
mathops.h
get_symbol2
static int get_symbol2(RangeCoder *c, uint8_t *state, int log2)
Definition: snow.h:586
qpeldsp.h
ff_snow_common_init
int ff_snow_common_init(AVCodecContext *avctx)
Definition: snow.c:428
QROOT
#define QROOT
Definition: snow.h:46
SnowContext::temp_idwt_buffer
IDWTELEM * temp_idwt_buffer
Definition: snow.h:151
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::last_spatial_decomposition_type
int last_spatial_decomposition_type
Definition: snow.h:139
SnowContext::ref_scores
uint32_t * ref_scores[MAX_REF_FRAMES]
Definition: snow.h:147
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
SnowContext::spatial_decomposition_type
int spatial_decomposition_type
Definition: snow.h:138
SnowContext::intra_penalty
int intra_penalty
Definition: snow.h:180
SNOW_MAX_PLANES
#define SNOW_MAX_PLANES
Definition: snow.h:38
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:112
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:257
SnowContext::spatial_dwt_buffer
DWTELEM * spatial_dwt_buffer
Definition: snow.h:148
SnowContext::last_qlog
int last_qlog
Definition: snow.h:158
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:106
Plane::last_htaps
int last_htaps
Definition: snow.h:111
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:123
SnowContext::motion_est
int motion_est
Definition: snow.h:181
SnowContext::max_ref_frames
int max_ref_frames
Definition: snow.h:144
SnowContext::encoding_error
uint64_t encoding_error[SNOW_MAX_PLANES]
Definition: snow.h:193
ff_quant3bA
const int8_t ff_quant3bA[256]
Definition: snowdata.h:104
Plane::hcoeff
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:107
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:606
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:157
ff_snow_frame_start
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:651
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:60
SnowContext::last_mv_scale
int last_mv_scale
Definition: snow.h:163
SnowContext::temp_dwt_buffer
DWTELEM * temp_dwt_buffer
Definition: snow.h:149
SnowContext::lambda2
int lambda2
Definition: snow.h:160
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:146
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:458
put_symbol2
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
Definition: snow.h:566
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:44
log2
#define log2(x)
Definition: libm.h:404
SnowContext::input_picture
AVFrame * input_picture
new_picture with the internal linesizes
Definition: snow.h:127
stride
#define stride
Definition: h264pred_template.c:537
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:171
SnowContext::last_qbias
int last_qbias
Definition: snow.h:165
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:93
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:90
SnowContext::block
BlockNode * block
Definition: snow.h:173
QpelDSPContext
quarterpel DSP context
Definition: qpeldsp.h:72
SnowContext::temporal_decomposition_count
int temporal_decomposition_count
Definition: snow.h:143
AVCodecContext
main external API structure.
Definition: avcodec.h:383
SnowContext::halfpel_plane
uint8_t * halfpel_plane[MAX_REF_FRAMES][4][4]
Definition: snow.h:130
SnowContext::sb
slice_buffer sb
Definition: snow.h:177
ME_CACHE_SIZE
#define ME_CACHE_SIZE
Definition: snow.h:174
SnowContext::last_block_max_depth
int last_block_max_depth
Definition: snow.h:170
SnowContext::b_width
int b_width
Definition: snow.h:167
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:231
SnowContext::mv_scale
int mv_scale
Definition: snow.h:162
SnowContext::plane
Plane plane[MAX_PLANES]
Definition: snow.h:172
Plane
Definition: cfhd.h:118
SnowContext::last_picture
AVFrame * last_picture[MAX_REF_FRAMES]
Definition: snow.h:129
VideoDSPContext
Definition: videodsp.h:41
SnowContext::block_max_depth
int block_max_depth
Definition: snow.h:169
shift
static int shift(int a, int b)
Definition: sonic.c:84
BlockNode::level
uint8_t level
Definition: snow.h:63
same_block
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
Definition: snow.h:273
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:54
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:216
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
SnowContext::iterative_dia_size
int iterative_dia_size
Definition: snow.h:182
HTAPS_MAX
#define HTAPS_MAX
Definition: snow.h:78
SnowContext::spatial_decomposition_count
int spatial_decomposition_count
Definition: snow.h:141
null_block
static const BlockNode null_block
Definition: snow.h:66
hpeldsp.h
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
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:179
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:205
SnowContext::mconly_picture
AVFrame * mconly_picture
Definition: snow.h:131
snow_interleave_line_footer
static av_always_inline void snow_interleave_line_footer(int *i, IDWTELEM *low, IDWTELEM *high)
Definition: snow.h:214
SubBand::buf_y_offset
int buf_y_offset
Definition: snow.h:94
SnowContext::last_spatial_decomposition_count
int last_spatial_decomposition_count
Definition: snow.h:142
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:69
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
BlockNode::ref
uint8_t ref
Reference frame index.
Definition: snow.h:56
SnowContext::avctx
AVCodecContext * avctx
Definition: snow.h:118
SnowContext::avmv_index
int avmv_index
Definition: snow.h:192
SnowContext::version
int version
Definition: snow.h:137
SnowContext::dwt
SnowDWTContext dwt
Definition: snow.h:126
SubBand::height
int height
Definition: cfhd.h:114
SubBand::x_coeff
x_and_coeff * x_coeff
Definition: snow.h:96