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