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