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;
121  AVFrame *input_picture; ///< new_picture with the internal linesizes
125 // uint8_t q_context[16];
126  uint8_t header_state[32];
127  uint8_t block_state[128 + 32*128];
128  int keyframe;
130  int version;
139  int16_t (*ref_mvs[MAX_REF_FRAMES])[2];
150  int qlog;
152  int mv_scale;
154  int qbias;
156 #define QBIAS_SHIFT 3
157  int b_width;
158  int b_height;
164  slice_buffer sb;
165 
166  uint8_t *scratchbuf;
167  uint8_t *emu_edge_buffer;
168 
170  unsigned avmv_size;
172 }SnowContext;
173 
174 /* Tables */
175 extern const uint8_t * const ff_obmc_tab[4];
176 extern const uint8_t ff_qexp[QROOT];
178 
179 /* common code */
180 
188 void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride,
189  int sx, int sy, int b_w, int b_h, const BlockNode *block,
190  int plane_index, int w, int h);
191 /* common inline functions */
192 //XXX doublecheck all of them should stay inlined
193 
194 static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
195  const BlockNode *left, const BlockNode *top, const BlockNode *tr){
196  if(s->ref_frames == 1){
197  *mx = mid_pred(left->mx, top->mx, tr->mx);
198  *my = mid_pred(left->my, top->my, tr->my);
199  }else{
200  const int *scale = ff_scale_mv_ref[ref];
201  *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
202  (top ->mx * scale[top ->ref] + 128) >>8,
203  (tr ->mx * scale[tr ->ref] + 128) >>8);
204  *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
205  (top ->my * scale[top ->ref] + 128) >>8,
206  (tr ->my * scale[tr ->ref] + 128) >>8);
207  }
208 }
209 
211  if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
212  return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
213  }else{
214  return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
215  }
216 }
217 
218 //FIXME name cleanup (b_w, block_w, b_width stuff)
219 //XXX should we really inline it?
220 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){
221  const int b_width = s->b_width << s->block_max_depth;
222  const int b_height= s->b_height << s->block_max_depth;
223  const int b_stride= b_width;
224  BlockNode *lt= &s->block[b_x + b_y*b_stride];
225  BlockNode *rt= lt+1;
226  BlockNode *lb= lt+b_stride;
227  BlockNode *rb= lb+1;
228  uint8_t *block[4];
229  // When src_stride is large enough, it is possible to interleave the blocks.
230  // Otherwise the blocks are written sequentially in the tmp buffer.
231  int tmp_step= src_stride >= 7*MB_SIZE ? MB_SIZE : MB_SIZE*src_stride;
232  uint8_t *tmp = s->scratchbuf;
233  uint8_t *ptmp;
234  int x,y;
235 
236  if(b_x<0){
237  lt= rt;
238  lb= rb;
239  }else if(b_x + 1 >= b_width){
240  rt= lt;
241  rb= lb;
242  }
243  if(b_y<0){
244  lt= lb;
245  rt= rb;
246  }else if(b_y + 1 >= b_height){
247  lb= lt;
248  rb= rt;
249  }
250 
251  if(src_x<0){ //FIXME merge with prev & always round internal width up to *16
252  obmc -= src_x;
253  b_w += src_x;
254  if(!sliced && !offset_dst)
255  dst -= src_x;
256  src_x=0;
257  }
258  if(src_x + b_w > w){
259  b_w = w - src_x;
260  }
261  if(src_y<0){
262  obmc -= src_y*obmc_stride;
263  b_h += src_y;
264  if(!sliced && !offset_dst)
265  dst -= src_y*dst_stride;
266  src_y=0;
267  }
268  if(src_y + b_h> h){
269  b_h = h - src_y;
270  }
271 
272  if(b_w<=0 || b_h<=0) return;
273 
274  if(!sliced && offset_dst)
275  dst += src_x + src_y*dst_stride;
276  dst8+= src_x + src_y*src_stride;
277 // src += src_x + src_y*src_stride;
278 
279  ptmp= tmp + 3*tmp_step;
280  block[0]= ptmp;
281  ptmp+=tmp_step;
282  ff_snow_pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
283 
284  if(same_block(lt, rt)){
285  block[1]= block[0];
286  }else{
287  block[1]= ptmp;
288  ptmp+=tmp_step;
289  ff_snow_pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
290  }
291 
292  if(same_block(lt, lb)){
293  block[2]= block[0];
294  }else if(same_block(rt, lb)){
295  block[2]= block[1];
296  }else{
297  block[2]= ptmp;
298  ptmp+=tmp_step;
299  ff_snow_pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
300  }
301 
302  if(same_block(lt, rb) ){
303  block[3]= block[0];
304  }else if(same_block(rt, rb)){
305  block[3]= block[1];
306  }else if(same_block(lb, rb)){
307  block[3]= block[2];
308  }else{
309  block[3]= ptmp;
310  ff_snow_pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
311  }
312  if(sliced){
313  s->dwt.inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
314  }else{
315  for(y=0; y<b_h; y++){
316  //FIXME ugly misuse of obmc_stride
317  const uint8_t *obmc1= obmc + y*obmc_stride;
318  const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
319  const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
320  const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
321  for(x=0; x<b_w; x++){
322  int v= obmc1[x] * block[3][x + y*src_stride]
323  +obmc2[x] * block[2][x + y*src_stride]
324  +obmc3[x] * block[1][x + y*src_stride]
325  +obmc4[x] * block[0][x + y*src_stride];
326 
327  v <<= 8 - LOG2_OBMC_MAX;
328  if(FRAC_BITS != 8){
329  v >>= 8 - FRAC_BITS;
330  }
331  if(add){
332  v += dst[x + y*dst_stride];
333  v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
334  if(v&(~255)) v= ~(v>>31);
335  dst8[x + y*src_stride] = v;
336  }else{
337  dst[x + y*dst_stride] -= v;
338  }
339  }
340  }
341  }
342 }
343 
344 static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y){
345  Plane *p= &s->plane[plane_index];
346  const int mb_w= s->b_width << s->block_max_depth;
347  const int mb_h= s->b_height << s->block_max_depth;
348  int x, y, mb_x;
349  int block_size = MB_SIZE >> s->block_max_depth;
350  int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
351  int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
352  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
353  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
354  int ref_stride= s->current_picture->linesize[plane_index];
355  uint8_t *dst8= s->current_picture->data[plane_index];
356  int w= p->width;
357  int h= p->height;
358  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // obmc params assume squares
359  if(s->keyframe || (s->avctx->debug&512)){
360  if(mb_y==mb_h)
361  return;
362 
363  if(add){
364  for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
365  for(x=0; x<w; x++){
366  int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
367  v >>= FRAC_BITS;
368  if(v&(~255)) v= ~(v>>31);
369  dst8[x + y*ref_stride]= v;
370  }
371  }
372  }else{
373  for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
374  for(x=0; x<w; x++){
375  buf[x + y*w]-= 128<<FRAC_BITS;
376  }
377  }
378  }
379 
380  return;
381  }
382 
383  for(mb_x=0; mb_x<=mb_w; mb_x++){
384  add_yblock(s, 0, NULL, buf, dst8, obmc,
385  block_w*mb_x - block_w/2,
386  block_h*mb_y - block_h/2,
387  block_w, block_h,
388  w, h,
389  w, ref_stride, obmc_stride,
390  mb_x - 1, mb_y - 1,
391  add, 1, plane_index);
392  }
393 }
394 
395 static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add){
396  const int mb_h= s->b_height << s->block_max_depth;
397  int mb_y;
398  for(mb_y=0; mb_y<=mb_h; mb_y++)
399  predict_slice(s, buf, plane_index, add, mb_y);
400 }
401 
402 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){
403  const int w= s->b_width << s->block_max_depth;
404  const int rem_depth= s->block_max_depth - level;
405  const int index= (x + y*w) << rem_depth;
406  const int block_w= 1<<rem_depth;
407  const int block_h= 1<<rem_depth; //FIXME "w!=h"
409  int i,j;
410 
411  block.color[0]= l;
412  block.color[1]= cb;
413  block.color[2]= cr;
414  block.mx= mx;
415  block.my= my;
416  block.ref= ref;
417  block.type= type;
418  block.level= level;
419 
420  for(j=0; j<block_h; j++){
421  for(i=0; i<block_w; i++){
422  s->block[index + i + j*w]= block;
423  }
424  }
425 }
426 
427 extern const int8_t ff_quant3bA[256];
428 
429 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
430 
431 #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:77
SnowContext::avmv_size
unsigned avmv_size
Definition: snow.h:170
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:402
Plane::last_diag_mc
int last_diag_mc
Definition: snow.h:110
level
uint8_t level
Definition: svq3.c:205
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:512
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:246
AVMotionVector
Definition: motion_vector.h:24
SnowContext::hdsp
HpelDSPContext hdsp
Definition: snow.h:117
SnowContext::current_picture
AVFrame * current_picture
Definition: snow.h:122
MB_SIZE
#define MB_SIZE
Definition: snow.h:73
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
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:111
SubBand::level
int level
Definition: diracdec.c:94
b
#define b
Definition: input.c:41
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:166
SnowDWTContext
Definition: snow_dwt.h:58
SnowContext::block_state
uint8_t block_state[128+32 *128]
Definition: snow.h:127
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:145
SubBand::buf
DWTELEM * buf
Definition: snow.h:88
SnowContext::chroma_h_shift
int chroma_h_shift
Definition: snow.h:147
SnowContext::h264qpel
H264QpelContext h264qpel
Definition: snow.h:119
SnowContext::keyframe
int keyframe
Definition: snow.h:128
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:138
SubBand::parent
struct SubBand * parent
Definition: diracdec.c:102
h264qpel.h
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:344
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:129
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:63
x_and_coeff::coeff
uint16_t coeff
Definition: snow.h:79
SnowContext::b_height
int b_height
Definition: snow.h:158
x_and_coeff
Definition: snow.h:77
SnowContext::temporal_decomposition_type
int temporal_decomposition_type
Definition: snow.h:133
SnowContext::colorspace_type
int colorspace_type
Definition: snow.h:146
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:450
SnowContext::qbias
int qbias
Definition: snow.h:154
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:148
SnowContext::header_state
uint8_t header_state[32]
Definition: snow.h:126
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:220
SnowContext::c
RangeCoder c
Definition: snow.h:116
ff_snow_frames_prepare
int ff_snow_frames_prepare(SnowContext *s)
Definition: snow.c:523
SnowContext::avmv
AVMotionVector * avmv
Definition: snow.h:169
SnowContext::spatial_idwt_buffer
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:143
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:285
SnowContext::spatial_scalability
int spatial_scalability
Definition: snow.h:149
SnowContext::emu_edge_buffer
uint8_t * emu_edge_buffer
Definition: snow.h:167
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
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:395
QROOT
#define QROOT
Definition: snow.h:43
SnowContext::temp_idwt_buffer
IDWTELEM * temp_idwt_buffer
Definition: snow.h:144
index
int index
Definition: gxfenc.c:90
ff_snow_common_end
void ff_snow_common_end(SnowContext *s)
Definition: snow.c:554
ff_snow_release_buffer
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:514
SnowContext::last_spatial_decomposition_type
int last_spatial_decomposition_type
Definition: snow.h:132
SnowContext::ref_scores
uint32_t * ref_scores[MAX_REF_FRAMES]
Definition: snow.h:140
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
SnowContext::spatial_decomposition_type
int spatial_decomposition_type
Definition: snow.h:131
SubBand::stride
ptrdiff_t stride
Definition: cfhd.h:109
Plane::height
int height
Definition: cfhd.h:119
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:194
SnowContext::spatial_dwt_buffer
DWTELEM * spatial_dwt_buffer
Definition: snow.h:141
SnowContext::last_qlog
int last_qlog
Definition: snow.h:151
SubBand
Definition: cfhd.h:108
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:118
snow_dwt.h
SnowContext::vdsp
VideoDSPContext vdsp
Definition: snow.h:118
SnowContext::max_ref_frames
int max_ref_frames
Definition: snow.h:137
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:67
SnowContext::qlog
int qlog
Definition: snow.h:150
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:153
SnowContext::temp_dwt_buffer
DWTELEM * temp_dwt_buffer
Definition: snow.h:142
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:139
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:395
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:121
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
mid_pred
#define mid_pred
Definition: mathops.h:96
SnowContext::nb_planes
int nb_planes
Definition: snow.h:161
SnowContext::last_qbias
int last_qbias
Definition: snow.h:155
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:163
SnowContext::temporal_decomposition_count
int temporal_decomposition_count
Definition: snow.h:136
AVCodecContext
main external API structure.
Definition: avcodec.h:445
SnowContext::sb
slice_buffer sb
Definition: snow.h:164
SnowContext::last_block_max_depth
int last_block_max_depth
Definition: snow.h:160
SnowContext::b_width
int b_width
Definition: snow.h:157
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
SnowContext::mv_scale
int mv_scale
Definition: snow.h:152
SnowContext::plane
Plane plane[MAX_PLANES]
Definition: snow.h:162
Plane
Definition: cfhd.h:117
SnowContext::last_picture
AVFrame * last_picture[MAX_REF_FRAMES]
Definition: snow.h:123
VideoDSPContext
Definition: videodsp.h:40
SnowContext::block_max_depth
int block_max_depth
Definition: snow.h:159
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:210
Plane::band
SubBand band[DWT_LEVELS_3D][4]
Definition: cfhd.h:130
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:291
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:247
videodsp.h
HTAPS_MAX
#define HTAPS_MAX
Definition: snow.h:75
SnowContext::spatial_decomposition_count
int spatial_decomposition_count
Definition: snow.h:134
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:2038
RangeCoder
Definition: mss3.c:63
SnowContext::mconly_picture
AVFrame * mconly_picture
Definition: snow.h:124
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:135
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:171
SnowContext::version
int version
Definition: snow.h:130
SnowContext::dwt
SnowDWTContext dwt
Definition: snow.h:120
SubBand::height
int height
Definition: cfhd.h:113
SubBand::x_coeff
x_and_coeff * x_coeff
Definition: snow.h:93