76e1e6501a85f01597c780d0240237c3eb7cb49e
[ffmpeg.git] / doc / snow.txt
1 =============================================
2 SNOW Video Codec Specification Draft 20070103
3 =============================================
4
5 Intro:
6 ======
7 This Specification describes the snow syntax and semmantics as well as
8 how to decode snow.
9 The decoding process is precissely described and any compliant decoder
10 MUST produce the exactly same output for a spec conformant snow stream.
11 For encoding though any process which generates a stream compliant to
12 the syntactical and semmantical requirements and which is decodeable by
13 the process described in this spec shall be considered a conformant
14 snow encoder.
15
16 Definitions:
17 ============
18
19 MUST    the specific part must be done to conform to this standard
20 SHOULD  it is recommended to be done that way, but not strictly required
21
22 ilog2(x) is the rounded down logarithm of x with basis 2
23 ilog2(0) = 0
24
25 Type definitions:
26 =================
27
28 b   1-bit range coded
29 u   unsigned scalar value range coded
30 s   signed scalar value range coded
31
32
33 Bitstream syntax:
34 =================
35
36 frame:
37     header
38     prediction
39     residual
40
41 header:
42     keyframe                            b   MID_STATE
43     if(keyframe || always_reset)
44         reset_contexts
45     if(keyframe){
46         version                         u   header_state
47         always_reset                    b   header_state
48         temporal_decomposition_type     u   header_state
49         temporal_decomposition_count    u   header_state
50         spatial_decomposition_count     u   header_state
51         colorspace_type                 u   header_state
52         chroma_h_shift                  u   header_state
53         chroma_v_shift                  u   header_state
54         spatial_scalability             b   header_state
55         max_ref_frames-1                u   header_state
56         qlogs
57     }
58     if(!keyframe){
59         update_mc                       b   header_state
60         if(update_mc){
61             for(plane=0; plane<2; plane++){
62                 diag_mc                 b   header_state
63                 htaps/2-1               u   header_state
64                 for(i= p->htaps/2; i; i--)
65                     |hcoeff[i]|         u   header_state
66             }
67         }
68         update_qlogs                    b   header_state
69         if(update_qlogs){
70             spatial_decomposition_count u   header_state
71             qlogs
72         }
73     }
74
75     spatial_decomposition_type          s   header_state
76     qlog                                s   header_state
77     mv_scale                            s   header_state
78     qbias                               s   header_state
79     block_max_depth                     s   header_state
80
81 qlogs:
82     for(plane=0; plane<2; plane++){
83         quant_table[plane][0][0]        s   header_state
84         for(level=0; level < spatial_decomposition_count; level++){
85             quant_table[plane][level][1]s   header_state
86             quant_table[plane][level][3]s   header_state
87         }
88     }
89
90 reset_contexts
91     *_state[*]= MID_STATE
92
93 prediction:
94     for(y=0; y<block_count_vertical; y++)
95         for(x=0; x<block_count_horizontal; x++)
96             block(0)
97
98 block(level):
99     if(keyframe){
100         intra=1
101         y_diff=cb_diff=cr_diff=0
102     }else{
103         if(level!=max_block_depth){
104             s_context= 2*left->level + 2*top->level + topleft->level + topright->level
105             leaf                        b   block_state[4 + s_context]
106         }
107         if(level==max_block_depth || leaf){
108             intra                       b   block_state[1 + left->intra + top->intra]
109             if(intra){
110                 y_diff                  s   block_state[32]
111                 cb_diff                 s   block_state[64]
112                 cr_diff                 s   block_state[96]
113             }else{
114                 ref_context= ilog2(2*left->ref) + ilog2(2*top->ref)
115                 if(ref_frames > 1)
116                     ref                 u   block_state[128 + 1024 + 32*ref_context]
117                 mx_context= ilog2(2*abs(left->mx - top->mx))
118                 my_context= ilog2(2*abs(left->my - top->my))
119                 mvx_diff                s   block_state[128 + 32*(mx_context + 16*!!ref)]
120                 mvy_diff                s   block_state[128 + 32*(my_context + 16*!!ref)]
121             }
122         }else{
123             block(level+1)
124             block(level+1)
125             block(level+1)
126             block(level+1)
127         }
128     }
129
130
131 residual:
132     FIXME
133
134
135
136 Tag description:
137 ----------------
138
139 version
140     0
141     this MUST NOT change within a bitstream
142
143 always_reset
144     if 1 then the range coder contexts will be reset after each frame
145
146 temporal_decomposition_type
147     0
148
149 temporal_decomposition_count
150     0
151
152 spatial_decomposition_count
153     FIXME
154
155 colorspace_type
156     0
157     this MUST NOT change within a bitstream
158
159 chroma_h_shift
160     log2(luma.width / chroma.width)
161     this MUST NOT change within a bitstream
162
163 chroma_v_shift
164     log2(luma.height / chroma.height)
165     this MUST NOT change within a bitstream
166
167 spatial_scalability
168     0
169
170 max_ref_frames
171     maximum number of reference frames
172     this MUST NOT change within a bitstream
173
174 update_mc
175     indicates that motion compensation filter parameters are stored in the
176     header
177
178 diag_mc
179     flag to enable faster diagonal interpolation
180     this SHOULD be 1 unless it turns out to be covered by a valid patent
181
182 htaps
183     number of half pel interpolation filter taps, MUST be even, >0 and <10
184
185 hcoeff
186     half pel interpolation filter coefficients, hcoeff[0] are the 2 middle
187     coefficients [1] are the next outer ones and so on, resulting in a filter
188     like: ...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ...
189     the sign of the coefficients is not explicitly stored but alternates
190     after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,...
191     hcoeff[0] is not explicitly stored but found by subtracting the sum
192     of all stored coefficients with signs from 32
193     hcoeff[0]= 32 - hcoeff[1] - hcoeff[2] - ...
194     a good choice for hcoeff and htaps is
195     htaps= 6
196     hcoeff={40,-10,2}
197     an alternative which requires more computations at both encoder and
198     decoder side and may or may not be better is
199     htaps= 8
200     hcoeff={42,-14,6,-2}
201
202
203 ref_frames
204     minimum of the number of available reference frames and max_ref_frames
205     for example the first frame after a key frame always has ref_frames=1
206
207 spatial_decomposition_type
208     wavelet type
209     0 is a 9/7 symmetric compact integer wavelet
210     1 is a 5/3 symmetric compact integer wavelet
211     others are reserved
212     stored as delta from last, last is reset to 0 if always_reset || keyframe
213
214 qlog
215     quality (logarthmic quantizer scale)
216     stored as delta from last, last is reset to 0 if always_reset || keyframe
217
218 mv_scale
219     stored as delta from last, last is reset to 0 if always_reset || keyframe
220     FIXME check that everything works fine if this changes between frames
221
222 qbias
223     dequantization bias
224     stored as delta from last, last is reset to 0 if always_reset || keyframe
225
226 block_max_depth
227     maximum depth of the block tree
228     stored as delta from last, last is reset to 0 if always_reset || keyframe
229
230 quant_table
231     quantiztation table
232
233 Range Coder:
234 ============
235 FIXME
236
237 Neighboring Blocks:
238 ===================
239 left and top are set to the respective blocks unless they are outside of
240 the image in which case they are set to the Null block
241
242 top-left is set to the top left block unless it is outside of the image in
243 which case it is set to the left block
244
245 if this block has no larger parent block or it is at the left side of its
246 parent block and the top right block is not outside of the image then the
247 top right block is used for top-right else the top-left block is used
248
249 Null block
250 y,cb,cr are 128
251 level, ref, mx and my are 0
252
253
254 Motion Vector Prediction:
255 =========================
256 1. the motion vectors of all the neighboring blocks are scaled to
257 compensate for the difference of reference frames
258
259 scaled_mv= (mv * (256 * (current_reference+1) / (mv.reference+1)) + 128)>>8
260
261 2. the median of the scaled left, top and top-right vectors is used as
262 motion vector prediction
263
264 3. the used motion vector is the sum of the predictor and
265    (mvx_diff, mvy_diff)*mv_scale
266
267
268 Intra DC Predicton:
269 ======================
270 the luma and chroma values of the left block are used as predictors
271
272 the used luma and chroma is the sum of the predictor and y_diff, cb_diff, cr_diff
273 to reverse this in the decoder apply the following:
274 block[y][x].dc[0] += block[y][x-1].dc[0];
275 block[y][x].dc[1] += block[y][x-1].dc[1];
276 block[y][x].dc[2] += block[y][x-1].dc[2];
277 block[*][-1].dc[*]= 128;
278
279
280 Motion Compensation:
281 ====================
282
283 Halfpel interpolation:
284 ----------------------
285 halfpel interpolation is done by convolution with the halfpel filter stored
286 in the header:
287
288 horizontal halfpel samples are found by
289 H1[y][x] =    hcoeff[0]*(F[y][x  ] + F[y][x+1])
290             + hcoeff[1]*(F[y][x-1] + F[y][x+2])
291             + hcoeff[2]*(F[y][x-2] + F[y][x+3])
292             + ...
293 h1[y][x] = (H1[y][x] + 32)>>6;
294
295 vertical halfpel samples are found by
296 H2[y][x] =    hcoeff[0]*(F[y  ][x] + F[y+1][x])
297             + hcoeff[1]*(F[y-1][x] + F[y+2][x])
298             + ...
299 h2[y][x] = (H2[y][x] + 32)>>6;
300
301 vertical+horizontal halfpel samples are found by
302 H3[y][x] =    hcoeff[0]*(H2[y][x  ] + H2[y][x+1])
303             + hcoeff[1]*(H2[y][x-1] + H2[y][x+2])
304             + ...
305 H3[y][x] =    hcoeff[0]*(H1[y  ][x] + H1[y+1][x])
306             + hcoeff[1]*(H1[y+1][x] + H1[y+2][x])
307             + ...
308 h3[y][x] = (H3[y][x] + 2048)>>12;
309
310
311                    F   H1  F
312                    |   |   |
313                    |   |   |
314                    |   |   |
315                    F   H1  F
316                    |   |   |
317                    |   |   |
318                    |   |   |
319    F-------F-------F-> H1<-F-------F-------F
320                    v   v   v
321                   H2   H3  H2
322                    ^   ^   ^
323    F-------F-------F-> H1<-F-------F-------F
324                    |   |   |
325                    |   |   |
326                    |   |   |
327                    F   H1  F
328                    |   |   |
329                    |   |   |
330                    |   |   |
331                    F   H1  F
332
333
334 unavailable fullpel samples (outside the picture for example) shall be equal
335 to the closest available fullpel sample
336
337
338 Smaller pel interpolation:
339 --------------------------
340 if diag_mc is set then points which lie on a line between 2 vertically,
341 horiziontally or diagonally adjacent halfpel points shall be interpolated
342 linearls with rounding to nearest and halfway values rounded up.
343 points which lie on 2 diagonals at the same time should only use the one
344 diagonal not containing the fullpel point
345
346
347
348            F-->O---q---O<--h1->O---q---O<--F
349            v \           / v \           / v
350            O   O       O   O   O       O   O
351            |         /     |     \         |
352            q       q       q       q       q
353            |     /         |         \     |
354            O   O       O   O   O       O   O
355            ^ /           \ ^ /           \ ^
356           h2-->O---q---O<--h3->O---q---O<--h2
357            v \           / v \           / v
358            O   O       O   O   O       O   O
359            |     \         |         /     |
360            q       q       q       q       q
361            |         \     |     /         |
362            O   O       O   O   O       O   O
363            ^ /           \ ^ /           \ ^
364            F-->O---q---O<--h1->O---q---O<--F
365
366
367
368 the remaining points shall be bilinearly interpolated from the
369 up to 4 surrounding halfpel and fullpel points, again rounding should be to
370 nearest and halfway values rounded up
371
372 compliant snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chroma
373 interpolation at least
374
375
376 Overlapped block motion compensation:
377 -------------------------------------
378 FIXME
379
380 LL band prediction:
381 ===================
382 Each sample in the LL0 subband is predicted by the median of the left, top and
383 left+top-topleft samples, samples outside the subband shall be considered to
384 be 0. To reverse this prediction in the decoder apply the following.
385 for(y=0; y<height; y++){
386     for(x=0; x<width; x++){
387         sample[y][x] += median(sample[y-1][x],
388                                sample[y][x-1],
389                                sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);
390     }
391 }
392 sample[-1][*]=sample[*][-1]= 0;
393 width,height here are the width and height of the LL0 subband not of the final
394 video
395
396
397 Dequantizaton:
398 ==============
399 FIXME
400
401 Wavelet Transform:
402 ==================
403
404 Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integer
405 transform and a integer approximation of the symmetric biorthogonal 9/7
406 daubechies wavelet.
407
408 2D IDWT (inverse discrete wavelet transform)
409 --------------------------------------------
410 The 2D IDWT applies a 2D filter recursively, each time combining the
411 4 lowest frequency subbands into a single subband until only 1 subband
412 remains.
413 The 2D filter is done by first applying a 1D filter in the vertical direction
414 and then applying it in the horizontal one.
415  ---------------    ---------------    ---------------    ---------------
416 |LL0|HL0|       |  |   |   |       |  |       |       |  |       |       |
417 |---+---|  HL1  |  | L0|H0 |  HL1  |  |  LL1  |  HL1  |  |       |       |
418 |LH0|HH0|       |  |   |   |       |  |       |       |  |       |       |
419 |-------+-------|->|-------+-------|->|-------+-------|->|   L1  |  H1   |->...
420 |       |       |  |       |       |  |       |       |  |       |       |
421 |  LH1  |  HH1  |  |  LH1  |  HH1  |  |  LH1  |  HH1  |  |       |       |
422 |       |       |  |       |       |  |       |       |  |       |       |
423  ---------------    ---------------    ---------------    ---------------
424
425
426 1D Filter:
427 ----------
428 1. interleave the samples of the low and high frequency subbands like
429 s={L0, H0, L1, H1, L2, H2, L3, H3, ... }
430 note, this can end with a L or a H, the number of elements shall be w
431 s[-1] shall be considered equivalent to s[1  ]
432 s[w ] shall be considered equivalent to s[w-2]
433
434 2. perform the lifting steps in order as described below
435
436 5/3 Integer filter:
437 1. s[i] -= (s[i-1] + s[i+1] + 2)>>2; for all even i < w
438 2. s[i] += (s[i-1] + s[i+1]    )>>1; for all odd  i < w
439
440 \ | /|\ | /|\ | /|\ | /|\
441  \|/ | \|/ | \|/ | \|/ |
442   +  |  +  |  +  |  +  |   -1/4
443  /|\ | /|\ | /|\ | /|\ |
444 / | \|/ | \|/ | \|/ | \|/
445   |  +  |  +  |  +  |  +   +1/2
446
447
448 snows 9/7 Integer filter:
449 1. s[i] -= (3*(s[i-1] + s[i+1])         + 4)>>3; for all even i < w
450 2. s[i] -=     s[i-1] + s[i+1]                 ; for all odd  i < w
451 3. s[i] += (   s[i-1] + s[i+1] + 4*s[i] + 8)>>4; for all even i < w
452 4. s[i] += (3*(s[i-1] + s[i+1])            )>>1; for all odd  i < w
453
454 \ | /|\ | /|\ | /|\ | /|\
455  \|/ | \|/ | \|/ | \|/ |
456   +  |  +  |  +  |  +  |   -3/8
457  /|\ | /|\ | /|\ | /|\ |
458 / | \|/ | \|/ | \|/ | \|/
459  (|  + (|  + (|  + (|  +   -1
460 \ + /|\ + /|\ + /|\ + /|\  +1/4
461  \|/ | \|/ | \|/ | \|/ |
462   +  |  +  |  +  |  +  |   +1/16
463  /|\ | /|\ | /|\ | /|\ |
464 / | \|/ | \|/ | \|/ | \|/
465   |  +  |  +  |  +  |  +   +3/2
466
467 optimization tips:
468 following are exactly identical
469 (3a)>>1 == a + (a>>1)
470 (a + 4b + 8)>>4 == ((a>>2) + b + 2)>>2
471
472 16bit implementation note:
473 The IDWT can be implemented with 16bits, but this requires some care to
474 prevent overflows, the following list, lists the minimum number of bits needed
475 for some terms
476 1. lifting step
477 A= s[i-1] + s[i+1]                              16bit
478 3*A + 4                                         18bit
479 A + (A>>1) + 2                                  17bit
480
481 3. lifting step
482 s[i-1] + s[i+1]                                 17bit
483
484 4. lifiting step
485 3*(s[i-1] + s[i+1])                             17bit
486
487
488 TODO:
489 =====
490 Important:
491 finetune initial contexts
492 flip wavelet?
493 try to use the wavelet transformed predicted image (motion compensated image) as context for coding the residual coefficients
494 try the MV length as context for coding the residual coefficients
495 use extradata for stuff which is in the keyframes now?
496 the MV median predictor is patented IIRC
497 implement per picture halfpel interpolation
498 try different range coder state transition tables for different contexts
499
500 Not Important:
501 compare the 6 tap and 8 tap hpel filters (psnr/bitrate and subjective quality)
502 spatial_scalability b vs u (!= 0 breaks syntax anyway so we can add a u later)
503
504
505 Credits:
506 ========
507 Michael Niedermayer
508 Loren Merritt
509
510
511 Copyright:
512 ==========
513 GPL + GFDL + whatever is needed to make this a RFC