FFmpeg: libavcodec/snow.h Source File

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 
25 #include "libavutil/motion_vector.h"
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)]
88   DWTELEM *buf;
89   IDWTELEM *ibuf;
90   int buf_x_offset;
91   int buf_y_offset;
92   int stride_line; ///< Stride measured in lines, not pixels.
93   x_and_coeff * x_coeff;
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;
101  SubBand band[MAX_DECOMPOSITIONS][4];
102 
103   int htaps;
104   int8_t hcoeff[HTAPS_MAX/2];
105   int diag_mc;
106   int fast_mc;
107 
108   int last_htaps;
109   int8_t last_hcoeff[HTAPS_MAX/2];
110   int last_diag_mc;
111 }Plane;
112 
113  typedef struct SnowContext{
114   AVClass *class;
115   AVCodecContext *avctx;
116   RangeCoder c;
117   HpelDSPContext hdsp;
118   VideoDSPContext vdsp;
119  union {
120  /// everything except size 2 are from H.264
121   qpel_mc_func put_snow_qpel_pixels_tab[4][16];
122   H264QpelContext h264qpel;
123  };
124   SnowDWTContext dwt;
125   AVFrame *input_picture; ///< new_picture with the internal linesizes
126   AVFrame *current_picture;
127   AVFrame *last_picture[MAX_REF_FRAMES];
128   AVFrame *mconly_picture;
129 // uint8_t q_context[16];
130   uint8_t header_state[32];
131   uint8_t block_state[128 + 32*128];
132   int keyframe;
133   int always_reset;
134   int version;
135   int spatial_decomposition_type;
136   int last_spatial_decomposition_type;
137   int temporal_decomposition_type;
138   int spatial_decomposition_count;
139   int last_spatial_decomposition_count;
140   int temporal_decomposition_count;
141   int max_ref_frames;
142   int ref_frames;
143   int16_t (*ref_mvs[MAX_REF_FRAMES])[2];
144   uint32_t *ref_scores[MAX_REF_FRAMES];
145   DWTELEM *spatial_dwt_buffer;
146   DWTELEM *temp_dwt_buffer;
147   IDWTELEM *spatial_idwt_buffer;
148   IDWTELEM *temp_idwt_buffer;
149   int *run_buffer;
150   int colorspace_type;
151   int chroma_h_shift;
152   int chroma_v_shift;
153   int spatial_scalability;
154   int qlog;
155   int last_qlog;
156   int mv_scale;
157   int last_mv_scale;
158   int qbias;
159   int last_qbias;
160  #define QBIAS_SHIFT 3
161   int b_width;
162   int b_height;
163   int block_max_depth;
164   int last_block_max_depth;
165   int nb_planes;
166   Plane plane[MAX_PLANES];
167   BlockNode *block;
168   slice_buffer sb;
169 
170   uint8_t *scratchbuf;
171   uint8_t *emu_edge_buffer;
172 
173   AVMotionVector *avmv;
174   unsigned avmv_size;
175   int avmv_index;
176 }SnowContext;
177 
178 /* Tables */
179 extern const uint8_t * const ff_obmc_tab[4];
180 extern const uint8_t ff_qexp[QROOT];
181 extern int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES];
182 
183 /* common code */
184 
185 int ff_snow_common_init(AVCodecContext *avctx);
186 int ff_snow_common_init_after_header(AVCodecContext *avctx);
187 void ff_snow_common_end(SnowContext *s);
188 void ff_snow_reset_contexts(SnowContext *s);
189 int ff_snow_alloc_blocks(SnowContext *s);
190 int ff_snow_frames_prepare(SnowContext *s);
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 
213  static av_always_inline int same_block(BlockNode *a, BlockNode *b){
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"
412  BlockNode block;
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
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
stride
#define stride
Definition: h264pred_template.c:536
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
Generated on Wed Nov 19 2025 19:22:29 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /