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;
102  SubBand band[MAX_DECOMPOSITIONS][4];
103 
104  int htaps;
105  int8_t hcoeff[HTAPS_MAX/2];
106  int diag_mc;
107  int fast_mc;
108 
110  int8_t last_hcoeff[HTAPS_MAX/2];
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];
145  uint32_t *ref_scores[MAX_REF_FRAMES];
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
173  unsigned me_cache[ME_CACHE_SIZE];
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 
187 
190  uint64_t encoding_error[AV_NUM_DATA_POINTERS];
191 
192  int pred;
193 }SnowContext;
194 
195 /* Tables */
196 extern const uint8_t * const ff_obmc_tab[4];
197 extern 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 */
int last_block_max_depth
Definition: snow.h:168
int plane
Definition: avisynth_c.h:384
int version
Definition: snow.h:135
MpegEncContext m
Definition: snow.h:183
int mv_scale
Definition: snow.h:160
#define NULL
Definition: coverity.c:32
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
Definition: snow.h:455
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVCodecContext * avctx
Definition: snow.h:116
int block_max_depth
Definition: snow.h:167
#define AV_NUM_DATA_POINTERS
Definition: frame.h:296
int last_spatial_decomposition_count
Definition: snow.h:140
AVFrame * mconly_picture
Definition: snow.h:129
static int shift(int a, int b)
Definition: sonic.c:82
int chroma_v_shift
Definition: snow.h:153
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int pass1_rc
Definition: snow.h:159
static int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
Definition: snow.h:540
int * run_buffer
Definition: snow.h:150
int always_reset
Definition: snow.h:134
int no_bitstream
Definition: snow.h:177
#define BLOCK_INTRA
Intra block, inter otherwise.
Definition: snow.h:58
IDWTELEM * ibuf
Definition: snow.h:90
Range coder.
#define W_BO
Definition: snow_dwt.h:78
int av_log2(unsigned v)
Definition: intmath.c:26
int scenechange_threshold
Definition: snow.h:181
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:36
#define MAX_PLANES
Definition: snow.h:42
GLint GLenum type
Definition: opengl_enc.c:104
int max_ref_frames
Definition: snow.h:142
mpegvideo header.
static const uint8_t obmc4[16]
Definition: snowdata.h:96
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
int keyframe
Definition: snow.h:133
uint8_t run
Definition: svq3.c:206
#define src
Definition: vp8dsp.c:254
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
short IDWTELEM
Definition: dirac_dwt.h:27
uint8_t * ref[4][4]
Definition: motion_est.h:81
enum AVPictureType last_picture
Definition: movenc.c:68
HpelDSPContext hdsp
Definition: snow.h:119
#define log2(x)
Definition: libm.h:404
MECmpContext mecc
Definition: snow.h:118
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:514
int qlog
log(qscale)/log[2^(1/6)]
Definition: snow.h:88
Definition: snow.h:51
int width
Definition: cfhd.h:49
#define HTAPS_MAX
Definition: snow.h:76
uint8_t level
Definition: snow.h:61
uint8_t ref
Reference frame index.
Definition: snow.h:54
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:139
int b_height
Definition: snow.h:166
static int get_symbol2(RangeCoder *c, uint8_t *state, int log2)
Definition: snow.h:583
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
int16_t mx
Motion vector component X, see mv_scale.
Definition: snow.h:52
static int get_rac(RangeCoder *c, uint8_t *const state)
Definition: rangecoder.h:136
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
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
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
#define MB_SIZE
Definition: snow.h:74
Motion estimation context.
Definition: motion_est.h:47
quarterpel DSP functions
#define height
int16_t my
Motion vector component Y, see mv_scale.
Definition: snow.h:53
static const BlockNode null_block
Definition: snow.h:64
#define FRAC_BITS
Definition: snow.h:46
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
Definition: snow.c:69
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
Definition: snow.h:563
#define av_log(a,...)
Definition: cfhd.h:44
BlockNode * block
Definition: snow.h:171
MpegvideoEncDSPContext mpvencdsp
Definition: snow.h:123
int last_diag_mc
Definition: snow.h:111
SnowDWTContext dwt
Definition: snow.h:124
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:640
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
unsigned me_cache_generation
Definition: snow.h:174
int avmv_index
Definition: snow.h:189
int diag_mc
Definition: snow.h:106
const char * r
Definition: vf_curves.c:114
AVMotionVector * avmv
Definition: snow.h:188
const uint8_t *const ff_obmc_tab[4]
Definition: snowdata.h:123
int lambda
Definition: snow.h:157
int intra_penalty
Definition: snow.h:178
uint8_t * emu_edge_buffer
Definition: snow.h:186
uint8_t color[3]
Color for intra.
Definition: snow.h:55
int ref_frames
Definition: snow.h:143
x_and_coeff * x_coeff
Definition: snow.h:94
int htaps
Definition: snow.h:104
int qlog
Definition: snow.h:155
uint8_t * src[4][4]
Definition: motion_est.h:80
Half-pel DSP context.
Definition: hpeldsp.h:45
#define b
Definition: input.c:41
const int8_t ff_quant3bA[256]
Definition: snowdata.h:104
#define FFMIN(a, b)
Definition: common.h:96
static void unpack_coeffs(SnowContext *s, SubBand *b, SubBand *parent, int orientation)
Definition: snow.h:603
#define width
#define ME_CACHE_SIZE
Definition: snow.h:172
uint8_t w
Definition: llviddspenc.c:38
int16_t x
Definition: snow.h:79
uint8_t * scratchbuf
Definition: snow.h:185
Plane plane[MAX_PLANES]
Definition: snow.h:170
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
int b_width
Definition: snow.h:165
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
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int last_mv_scale
Definition: snow.h:161
int chroma_h_shift
Definition: snow.h:152
VideoDSPContext vdsp
Definition: snow.h:121
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
Definition: snow.h:270
int qbias
Definition: snow.h:162
#define W_BS
Definition: snow_dwt.h:79
int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]
Definition: snowdata.h:129
Half-pel DSP functions.
static struct @320 state
AVCodecContext * avctx
Definition: motion_est.h:48
#define LOG2_OBMC_MAX
Definition: snow.h:49
int spatial_decomposition_count
Definition: snow.h:139
int DWTELEM
Definition: dirac_dwt.h:26
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
int debug
debug
Definition: avcodec.h:2653
main external API structure.
Definition: avcodec.h:1568
static av_always_inline void snow_interleave_line_footer(int *i, IDWTELEM *low, IDWTELEM *high)
Definition: snow.h:211
#define QROOT
Definition: snow.h:44
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:206
struct SubBand * parent
Definition: diracdec.c:99
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:96
void * buf
Definition: avisynth_c.h:766
Describe the class of an AVClass context structure.
Definition: log.h:67
int index
Definition: gxfenc.c:89
int nb_planes
Definition: snow.h:169
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:110
int pred
Definition: snow.h:192
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
#define mid_pred
Definition: mathops.h:97
int buf_y_offset
Definition: snow.h:92
DWTELEM * temp_dwt_buffer
Definition: snow.h:147
int motion_est
Definition: snow.h:179
int last_qlog
Definition: snow.h:156
int spatial_scalability
Definition: snow.h:154
quarterpel DSP context
Definition: qpeldsp.h:72
int ff_snow_common_init(AVCodecContext *avctx)
uint16_t coeff
Definition: snow.h:80
int iterative_dia_size
Definition: snow.h:180
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int spatial_decomposition_type
Definition: snow.h:136
AVFrame * current_picture
Definition: snow.h:126
int memc_only
Definition: snow.h:176
void ff_snow_common_end(SnowContext *s)
Definition: snow.c:693
static av_always_inline void snow_interleave_line_header(int *i, int width, IDWTELEM *low, IDWTELEM *high)
Definition: snow.h:202
#define MAX_DECOMPOSITIONS
Definition: dirac_dwt.h:30
MpegEncContext.
Definition: mpegvideo.h:81
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:327
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
int temporal_decomposition_type
Definition: snow.h:138
IDWTELEM * temp_idwt_buffer
Definition: snow.h:149
H264QpelContext h264qpel
Definition: snow.h:122
static void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: snow.h:509
#define put_rac(C, S, B)
DWTELEM * spatial_dwt_buffer
Definition: snow.h:146
void(* inner_add_yblock)(const uint8_t *obmc, const int obmc_stride, uint8_t **block, int b_w, int b_h, int src_x, int src_y, int src_stride, slice_buffer *sb, int add, uint8_t *dst8)
Definition: snow_dwt.h:61
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
int lambda2
Definition: snow.h:158
uint8_t state[7+512][32]
Definition: snow.h:96
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:148
void * priv_data
Definition: avcodec.h:1595
int buf_x_offset
Definition: snow.h:91
int colorspace_type
Definition: snow.h:151
int last_htaps
Definition: snow.h:109
int height
Definition: cfhd.h:51
slice_buffer sb
Definition: snow.h:175
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
int fast_mc
Definition: snow.h:107
int width
Definition: cfhd.h:58
RangeCoder c
Definition: snow.h:117
uint8_t ff_qexp[QROOT]
Definition: snowdata.h:128
DWTELEM * buf
Definition: snow.h:89
#define MAX_REF_FRAMES
Definition: snow.h:47
#define av_always_inline
Definition: attributes.h:39
uint8_t type
Bitfield of BLOCK_*.
Definition: snow.h:56
#define stride
Used to minimize the amount of memory used in order to optimize cache performance.
Definition: snow_dwt.h:44
int height
Definition: cfhd.h:59
int last_qbias
Definition: snow.h:163
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:140
AVFrame * input_picture
new_picture with the internal linesizes
Definition: snow.h:125
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 local context
int temporal_decomposition_count
Definition: snow.h:141
static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y)
Definition: snow.h:404
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:655
int last_spatial_decomposition_type
Definition: snow.h:137
Definition: cfhd.h:57
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
int stride_line
Stride measured in lines, not pixels.
Definition: snow.h:93
QpelDSPContext qdsp
Definition: snow.h:120
static uint8_t tmp[11]
Definition: aes_ctr.c:26