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 "avcodec.h"
28 #include "hpeldsp.h"
29 #include "snow_dwt.h"
30 
31 #include "rangecoder.h"
32 #include "mathops.h"
33 
34 #include "h264qpel.h"
35 #include "videodsp.h"
36 
37 #define SNOW_MAX_PLANES 4
38 
39 #define MID_STATE 128
40 
41 #define MAX_PLANES 4
42 #define QSHIFT 5
43 #define QROOT (1<<QSHIFT)
44 #define LOSSLESS_QLOG -128
45 #define FRAC_BITS 4
46 #define MAX_REF_FRAMES 8
47 
48 #define LOG2_OBMC_MAX 8
49 #define OBMC_MAX (1<<(LOG2_OBMC_MAX))
50 typedef struct BlockNode{
51  int16_t mx; ///< Motion vector component X, see mv_scale
52  int16_t my; ///< Motion vector component Y, see mv_scale
53  uint8_t ref; ///< Reference frame index
54  uint8_t color[3]; ///< Color for intra
55  uint8_t type; ///< Bitfield of BLOCK_*
56 //#define TYPE_SPLIT 1
57 #define BLOCK_INTRA 1 ///< Intra block, inter otherwise
58 #define BLOCK_OPT 2 ///< Block needs no checks in this round of iterative motion estiation
59 //#define TYPE_NOCOLOR 4
60  uint8_t level; //FIXME merge into type?
61 }BlockNode;
62 
63 static const BlockNode null_block= { //FIXME add border maybe
64  .color= {128,128,128},
65  .mx= 0,
66  .my= 0,
67  .ref= 0,
68  .type= 0,
69  .level= 0,
70 };
71 
72 #define LOG2_MB_SIZE 4
73 #define MB_SIZE (1<<LOG2_MB_SIZE)
74 #define ENCODER_EXTRA_BITS 4
75 #define HTAPS_MAX 8
76 
77 typedef struct x_and_coeff{
78  int16_t x;
79  uint16_t coeff;
80 } x_and_coeff;
81 
82 typedef struct SubBand{
83  int level;
84  int stride;
85  int width;
86  int height;
87  int qlog; ///< log(qscale)/log[2^(1/6)]
92  int stride_line; ///< Stride measured in lines, not pixels.
94  struct SubBand *parent;
95  uint8_t state[/*7*2*/ 7 + 512][32];
96 }SubBand;
97 
98 typedef struct Plane{
99  int width;
100  int height;
102 
103  int htaps;
104  int8_t hcoeff[HTAPS_MAX/2];
105  int diag_mc;
106  int fast_mc;
107 
111 }Plane;
112 
113 typedef struct SnowContext{
114  AVClass *class;
119  union {
120  /// everything except size 2 are from H.264
123  };
125  AVFrame *input_picture; ///< new_picture with the internal linesizes
129 // uint8_t q_context[16];
130  uint8_t header_state[32];
131  uint8_t block_state[128 + 32*128];
132  int keyframe;
134  int version;
143  int16_t (*ref_mvs[MAX_REF_FRAMES])[2];
154  int qlog;
156  int mv_scale;
158  int qbias;
160 #define QBIAS_SHIFT 3
161  int b_width;
162  int b_height;
168  slice_buffer sb;
169 
170  uint8_t *scratchbuf;
171  uint8_t *emu_edge_buffer;
172 
174  unsigned avmv_size;
176 }SnowContext;
177 
178 /* Tables */
179 extern const uint8_t * const ff_obmc_tab[4];
180 extern const uint8_t ff_qexp[QROOT];
182 
183 /* common code */
184 
191 void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride,
192  int sx, int sy, int b_w, int b_h, const BlockNode *block,
193  int plane_index, int w, int h);
194 /* common inline functions */
195 //XXX doublecheck all of them should stay inlined
196 
197 static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
198  const BlockNode *left, const BlockNode *top, const BlockNode *tr){
199  if(s->ref_frames == 1){
200  *mx = mid_pred(left->mx, top->mx, tr->mx);
201  *my = mid_pred(left->my, top->my, tr->my);
202  }else{
203  const int *scale = ff_scale_mv_ref[ref];
204  *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
205  (top ->mx * scale[top ->ref] + 128) >>8,
206  (tr ->mx * scale[tr ->ref] + 128) >>8);
207  *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
208  (top ->my * scale[top ->ref] + 128) >>8,
209  (tr ->my * scale[tr ->ref] + 128) >>8);
210  }
211 }
212 
214  if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
215  return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
216  }else{
217  return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
218  }
219 }
220 
221 //FIXME name cleanup (b_w, block_w, b_width stuff)
222 //XXX should we really inline it?
223 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){
224  const int b_width = s->b_width << s->block_max_depth;
225  const int b_height= s->b_height << s->block_max_depth;
226  const int b_stride= b_width;
227  BlockNode *lt= &s->block[b_x + b_y*b_stride];
228  BlockNode *rt= lt+1;
229  BlockNode *lb= lt+b_stride;
230  BlockNode *rb= lb+1;
231  uint8_t *block[4];
232  // When src_stride is large enough, it is possible to interleave the blocks.
233  // Otherwise the blocks are written sequentially in the tmp buffer.
234  int tmp_step= src_stride >= 7*MB_SIZE ? MB_SIZE : MB_SIZE*src_stride;
235  uint8_t *tmp = s->scratchbuf;
236  uint8_t *ptmp;
237  int x,y;
238 
239  if(b_x<0){
240  lt= rt;
241  lb= rb;
242  }else if(b_x + 1 >= b_width){
243  rt= lt;
244  rb= lb;
245  }
246  if(b_y<0){
247  lt= lb;
248  rt= rb;
249  }else if(b_y + 1 >= b_height){
250  lb= lt;
251  rb= rt;
252  }
253 
254  if(src_x<0){ //FIXME merge with prev & always round internal width up to *16
255  obmc -= src_x;
256  b_w += src_x;
257  if(!sliced && !offset_dst)
258  dst -= src_x;
259  src_x=0;
260  }
261  if(src_x + b_w > w){
262  b_w = w - src_x;
263  }
264  if(src_y<0){
265  obmc -= src_y*obmc_stride;
266  b_h += src_y;
267  if(!sliced && !offset_dst)
268  dst -= src_y*dst_stride;
269  src_y=0;
270  }
271  if(src_y + b_h> h){
272  b_h = h - src_y;
273  }
274 
275  if(b_w<=0 || b_h<=0) return;
276 
277  if(!sliced && offset_dst)
278  dst += src_x + src_y*dst_stride;
279  if (sliced || add)
280  dst8+= src_x + src_y*src_stride;
281 // src += src_x + src_y*src_stride;
282 
283  ptmp= tmp + 3*tmp_step;
284  block[0]= ptmp;
285  ptmp+=tmp_step;
286  ff_snow_pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
287 
288  if(same_block(lt, rt)){
289  block[1]= block[0];
290  }else{
291  block[1]= ptmp;
292  ptmp+=tmp_step;
293  ff_snow_pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
294  }
295 
296  if(same_block(lt, lb)){
297  block[2]= block[0];
298  }else if(same_block(rt, lb)){
299  block[2]= block[1];
300  }else{
301  block[2]= ptmp;
302  ptmp+=tmp_step;
303  ff_snow_pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
304  }
305 
306  if(same_block(lt, rb) ){
307  block[3]= block[0];
308  }else if(same_block(rt, rb)){
309  block[3]= block[1];
310  }else if(same_block(lb, rb)){
311  block[3]= block[2];
312  }else{
313  block[3]= ptmp;
314  ff_snow_pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
315  }
316  if(sliced){
317  s->dwt.inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
318  }else{
319  for(y=0; y<b_h; y++){
320  //FIXME ugly misuse of obmc_stride
321  const uint8_t *obmc1= obmc + y*obmc_stride;
322  const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
323  const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
324  const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
325  for(x=0; x<b_w; x++){
326  int v= obmc1[x] * block[3][x + y*src_stride]
327  +obmc2[x] * block[2][x + y*src_stride]
328  +obmc3[x] * block[1][x + y*src_stride]
329  +obmc4[x] * block[0][x + y*src_stride];
330 
331  v <<= 8 - LOG2_OBMC_MAX;
332  if(FRAC_BITS != 8){
333  v >>= 8 - FRAC_BITS;
334  }
335  if(add){
336  v += dst[x + y*dst_stride];
337  v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
338  if(v&(~255)) v= ~(v>>31);
339  dst8[x + y*src_stride] = v;
340  }else{
341  dst[x + y*dst_stride] -= v;
342  }
343  }
344  }
345  }
346 }
347 
348 static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y){
349  Plane *p= &s->plane[plane_index];
350  const int mb_w= s->b_width << s->block_max_depth;
351  const int mb_h= s->b_height << s->block_max_depth;
352  int x, y, mb_x;
353  int block_size = MB_SIZE >> s->block_max_depth;
354  int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
355  int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
356  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
357  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
358  int ref_stride= s->current_picture->linesize[plane_index];
359  uint8_t *dst8= s->current_picture->data[plane_index];
360  int w= p->width;
361  int h= p->height;
362  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // obmc params assume squares
363  if(s->keyframe || (s->avctx->debug&512)){
364  if(mb_y==mb_h)
365  return;
366 
367  if(add){
368  for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
369  for(x=0; x<w; x++){
370  int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
371  v >>= FRAC_BITS;
372  if(v&(~255)) v= ~(v>>31);
373  dst8[x + y*ref_stride]= v;
374  }
375  }
376  }else{
377  for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
378  for(x=0; x<w; x++){
379  buf[x + y*w]-= 128<<FRAC_BITS;
380  }
381  }
382  }
383 
384  return;
385  }
386 
387  for(mb_x=0; mb_x<=mb_w; mb_x++){
388  add_yblock(s, 0, NULL, buf, dst8, obmc,
389  block_w*mb_x - block_w/2,
390  block_h*mb_y - block_h/2,
391  block_w, block_h,
392  w, h,
393  w, ref_stride, obmc_stride,
394  mb_x - 1, mb_y - 1,
395  add, 1, plane_index);
396  }
397 }
398 
399 static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add){
400  const int mb_h= s->b_height << s->block_max_depth;
401  int mb_y;
402  for(mb_y=0; mb_y<=mb_h; mb_y++)
403  predict_slice(s, buf, plane_index, add, mb_y);
404 }
405 
406 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){
407  const int w= s->b_width << s->block_max_depth;
408  const int rem_depth= s->block_max_depth - level;
409  const int index= (x + y*w) << rem_depth;
410  const int block_w= 1<<rem_depth;
411  const int block_h= 1<<rem_depth; //FIXME "w!=h"
413  int i,j;
414 
415  block.color[0]= l;
416  block.color[1]= cb;
417  block.color[2]= cr;
418  block.mx= mx;
419  block.my= my;
420  block.ref= ref;
421  block.type= type;
422  block.level= level;
423 
424  for(j=0; j<block_h; j++){
425  for(i=0; i<block_w; i++){
426  s->block[index + i + j*w]= block;
427  }
428  }
429 }
430 
431 extern const int8_t ff_quant3bA[256];
432 
433 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
434 
435 #endif /* AVCODEC_SNOW_H */
BlockNode::color
uint8_t color[3]
Color for intra.
Definition: snow.h:54
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:164
SnowContext::avmv_size
unsigned avmv_size
Definition: snow.h:174
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:406
Plane::last_diag_mc
int last_diag_mc
Definition: snow.h:110
level
uint8_t level
Definition: svq3.c:208
MAX_DECOMPOSITIONS
#define MAX_DECOMPOSITIONS
Definition: dirac_dwt.h:30
Plane::fast_mc
int fast_mc
Definition: snow.h:106
color
Definition: vf_paletteuse.c:513
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:247
AVMotionVector
Definition: motion_vector.h:24
SnowContext::hdsp
HpelDSPContext hdsp
Definition: snow.h:117
SnowContext::current_picture
AVFrame * current_picture
Definition: snow.h:126
MB_SIZE
#define MB_SIZE
Definition: snow.h:73
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
w
uint8_t w
Definition: llviddspenc.c:38
SubBand::width
int width
Definition: cfhd.h:110
SubBand::level
int level
Definition: diracdec.c:94
b
#define b
Definition: input.c:42
rangecoder.h
FRAC_BITS
#define FRAC_BITS
Definition: snow.h:45
x_and_coeff::x
int16_t x
Definition: snow.h:78
SnowContext::scratchbuf
uint8_t * scratchbuf
Definition: snow.h:170
SnowDWTContext
Definition: snow_dwt.h:58
SnowContext::block_state
uint8_t block_state[128+32 *128]
Definition: snow.h:131
SnowContext
Definition: snow.h:113
SubBand::state
uint8_t state[7+512][32]
Definition: snow.h:95
MAX_REF_FRAMES
#define MAX_REF_FRAMES
Definition: snow.h:46
SnowContext::run_buffer
int * run_buffer
Definition: snow.h:149
SubBand::buf
DWTELEM * buf
Definition: snow.h:88
SnowContext::chroma_h_shift
int chroma_h_shift
Definition: snow.h:151
SnowContext::h264qpel
H264QpelContext h264qpel
Definition: snow.h:122
SnowContext::keyframe
int keyframe
Definition: snow.h:132
SubBand::ibuf
IDWTELEM * ibuf
Definition: snow.h:89
Plane::diag_mc
int diag_mc
Definition: snow.h:105
BlockNode::type
uint8_t type
Bitfield of BLOCK_*.
Definition: snow.h:55
SnowContext::ref_frames
int ref_frames
Definition: snow.h:142
SubBand::parent
struct SubBand * parent
Definition: diracdec.c:102
h264qpel.h
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition: dsp.h:57
LOG2_OBMC_MAX
#define LOG2_OBMC_MAX
Definition: snow.h:48
BlockNode
Definition: snow.h:50
predict_slice
static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y)
Definition: snow.h:348
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
SnowContext::always_reset
int always_reset
Definition: snow.h:133
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:150
x_and_coeff::coeff
uint16_t coeff
Definition: snow.h:79
SnowContext::b_height
int b_height
Definition: snow.h:162
x_and_coeff
Definition: snow.h:77
SnowContext::temporal_decomposition_type
int temporal_decomposition_type
Definition: snow.h:137
SnowContext::colorspace_type
int colorspace_type
Definition: snow.h:150
motion_vector.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_snow_common_init_after_header
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:538
SnowContext::qbias
int qbias
Definition: snow.h:158
SubBand::stride_line
int stride_line
Stride measured in lines, not pixels.
Definition: snow.h:92
SnowContext::chroma_v_shift
int chroma_v_shift
Definition: snow.h:152
SnowContext::header_state
uint8_t header_state[32]
Definition: snow.h:130
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:223
SnowContext::c
RangeCoder c
Definition: snow.h:116
ff_snow_frames_prepare
int ff_snow_frames_prepare(SnowContext *s)
Definition: snow.c:602
SnowContext::avmv
AVMotionVector * avmv
Definition: snow.h:173
SnowContext::spatial_idwt_buffer
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:147
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:372
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
SnowContext::spatial_scalability
int spatial_scalability
Definition: snow.h:153
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition: dsp.h:57
SnowContext::emu_edge_buffer
uint8_t * emu_edge_buffer
Definition: snow.h:171
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
NULL
#define NULL
Definition: coverity.c:32
BlockNode::my
int16_t my
Motion vector component Y, see mv_scale.
Definition: snow.h:52
mathops.h
ff_snow_common_init
int ff_snow_common_init(AVCodecContext *avctx)
Definition: snow.c:482
QROOT
#define QROOT
Definition: snow.h:43
SnowContext::temp_idwt_buffer
IDWTELEM * temp_idwt_buffer
Definition: snow.h:148
index
int index
Definition: gxfenc.c:90
ff_snow_common_end
void ff_snow_common_end(SnowContext *s)
Definition: snow.c:633
qpel_mc_func
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
SnowContext::last_spatial_decomposition_type
int last_spatial_decomposition_type
Definition: snow.h:136
SnowContext::ref_scores
uint32_t * ref_scores[MAX_REF_FRAMES]
Definition: snow.h:144
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:46
SnowContext::spatial_decomposition_type
int spatial_decomposition_type
Definition: snow.h:135
SubBand::stride
ptrdiff_t stride
Definition: cfhd.h:108
Plane::height
int height
Definition: cfhd.h:118
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
Plane::last_hcoeff
int8_t last_hcoeff[HTAPS_MAX/2]
Definition: snow.h:109
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:197
SnowContext::spatial_dwt_buffer
DWTELEM * spatial_dwt_buffer
Definition: snow.h:145
SnowContext::last_qlog
int last_qlog
Definition: snow.h:155
SubBand
Definition: cfhd.h:107
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:103
Plane::last_htaps
int last_htaps
Definition: snow.h:108
Plane::width
int width
Definition: cfhd.h:117
snow_dwt.h
SnowContext::vdsp
VideoDSPContext vdsp
Definition: snow.h:118
SnowContext::max_ref_frames
int max_ref_frames
Definition: snow.h:141
ff_quant3bA
const int8_t ff_quant3bA[256]
Definition: snowdata.h:104
Plane::hcoeff
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:104
DWTELEM
int DWTELEM
Definition: dirac_dwt.h:26
ff_obmc_tab
const uint8_t *const ff_obmc_tab[4]
Definition: snowdata.h:123
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
SnowContext::qlog
int qlog
Definition: snow.h:154
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
BLOCK_INTRA
#define BLOCK_INTRA
Intra block, inter otherwise.
Definition: snow.h:57
SnowContext::last_mv_scale
int last_mv_scale
Definition: snow.h:157
SnowContext::temp_dwt_buffer
DWTELEM * temp_dwt_buffer
Definition: snow.h:146
av_always_inline
#define av_always_inline
Definition: attributes.h:63
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SnowContext::ref_mvs
int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]
Definition: snow.h:143
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:399
H264QpelContext
Definition: h264qpel.h:27
MAX_PLANES
#define MAX_PLANES
Definition: snow.h:41
SnowContext::input_picture
AVFrame * input_picture
new_picture with the internal linesizes
Definition: snow.h:125
avcodec.h
stride
#define stride
Definition: h264pred_template.c:536
mid_pred
#define mid_pred
Definition: mathops.h:97
SnowContext::put_snow_qpel_pixels_tab
qpel_mc_func put_snow_qpel_pixels_tab[4][16]
everything except size 2 are from H.264
Definition: snow.h:121
SnowContext::nb_planes
int nb_planes
Definition: snow.h:165
SnowContext::last_qbias
int last_qbias
Definition: snow.h:159
SubBand::buf_x_offset
int buf_x_offset
Definition: snow.h:90
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
SubBand::qlog
int qlog
log(qscale)/log[2^(1/6)]
Definition: snow.h:87
SnowContext::block
BlockNode * block
Definition: snow.h:167
SnowContext::temporal_decomposition_count
int temporal_decomposition_count
Definition: snow.h:140
AVCodecContext
main external API structure.
Definition: avcodec.h:431
SnowContext::sb
slice_buffer sb
Definition: snow.h:168
SnowContext::last_block_max_depth
int last_block_max_depth
Definition: snow.h:164
SnowContext::b_width
int b_width
Definition: snow.h:161
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
SnowContext::mv_scale
int mv_scale
Definition: snow.h:156
SnowContext::plane
Plane plane[MAX_PLANES]
Definition: snow.h:166
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
Plane
Definition: cfhd.h:116
SnowContext::last_picture
AVFrame * last_picture[MAX_REF_FRAMES]
Definition: snow.h:127
VideoDSPContext
Definition: videodsp.h:40
SnowContext::block_max_depth
int block_max_depth
Definition: snow.h:163
BlockNode::level
uint8_t level
Definition: snow.h:60
same_block
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
Definition: snow.h:213
Plane::band
SubBand band[DWT_LEVELS_3D][4]
Definition: cfhd.h:129
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:51
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:248
videodsp.h
HTAPS_MAX
#define HTAPS_MAX
Definition: snow.h:75
SnowContext::spatial_decomposition_count
int spatial_decomposition_count
Definition: snow.h:138
null_block
static const BlockNode null_block
Definition: snow.h:63
hpeldsp.h
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
IDWTELEM
short IDWTELEM
Definition: dirac_dwt.h:27
h
h
Definition: vp9dsp_template.c:2070
RangeCoder
Definition: mss3.c:63
SnowContext::mconly_picture
AVFrame * mconly_picture
Definition: snow.h:128
SubBand::buf_y_offset
int buf_y_offset
Definition: snow.h:91
SnowContext::last_spatial_decomposition_count
int last_spatial_decomposition_count
Definition: snow.h:139
BlockNode::ref
uint8_t ref
Reference frame index.
Definition: snow.h:53
SnowContext::avctx
AVCodecContext * avctx
Definition: snow.h:115
SnowContext::avmv_index
int avmv_index
Definition: snow.h:175
SnowContext::version
int version
Definition: snow.h:134
SnowContext::dwt
SnowDWTContext dwt
Definition: snow.h:124
SubBand::height
int height
Definition: cfhd.h:112
SubBand::x_coeff
x_and_coeff * x_coeff
Definition: snow.h:93