1 % -*- mode: latex; TeX-master: "Vorbis_I_spec"; -*-
2 %!TEX root = Vorbis_I_spec.tex
4 \section{Probability Model and Codebooks} \label{vorbis:spec:codebook}
8 Unlike practically every other mainstream audio codec, Vorbis has no
9 statically configured probability model, instead packing all entropy
10 decoding configuration, VQ and Huffman, into the bitstream itself in
11 the third header, the codec setup header. This packed configuration
12 consists of multiple 'codebooks', each containing a specific
13 Huffman-equivalent representation for decoding compressed codewords as
14 well as an optional lookup table of output vector values to which a
15 decoded Huffman value is applied as an offset, generating the final
16 decoded output corresponding to a given compressed codeword.
18 \subsubsection{Bitwise operation}
19 The codebook mechanism is built on top of the vorbis bitpacker. Both
20 the codebooks themselves and the codewords they decode are unrolled
21 from a packet as a series of arbitrary-width values read from the
22 stream according to \xref{vorbis:spec:bitpacking}.
27 \subsection{Packed codebook format}
29 For purposes of the examples below, we assume that the storage
30 system's native byte width is eight bits. This is not universally
31 true; see \xref{vorbis:spec:bitpacking} for discussion
32 relating to non-eight-bit bytes.
34 \subsubsection{codebook decode}
36 A codebook begins with a 24 bit sync pattern, 0x564342:
38 \begin{Verbatim}[commandchars=\\\{\}]
39 byte 0: [ 0 1 0 0 0 0 1 0 ] (0x42)
40 byte 1: [ 0 1 0 0 0 0 1 1 ] (0x43)
41 byte 2: [ 0 1 0 1 0 1 1 0 ] (0x56)
44 16 bit \varname{[codebook\_dimensions]} and 24 bit \varname{[codebook\_entries]} fields:
46 \begin{Verbatim}[commandchars=\\\{\}]
48 byte 3: [ X X X X X X X X ]
49 byte 4: [ X X X X X X X X ] [codebook\_dimensions] (16 bit unsigned)
51 byte 5: [ X X X X X X X X ]
52 byte 6: [ X X X X X X X X ]
53 byte 7: [ X X X X X X X X ] [codebook\_entries] (24 bit unsigned)
57 Next is the \varname{[ordered]} bit flag:
59 \begin{Verbatim}[commandchars=\\\{\}]
61 byte 8: [ X ] [ordered] (1 bit)
65 Each entry, numbering a
66 total of \varname{[codebook\_entries]}, is assigned a codeword length.
67 We now read the list of codeword lengths and store these lengths in
68 the array \varname{[codebook\_codeword\_lengths]}. Decode of lengths is
69 according to whether the \varname{[ordered]} flag is set or unset.
73 If the \varname{[ordered]} flag is unset, the codeword list is not
74 length ordered and the decoder needs to read each codeword length
77 The decoder first reads one additional bit flag, the
78 \varname{[sparse]} flag. This flag determines whether or not the
79 codebook contains unused entries that are not to be included in the
82 \begin{Verbatim}[commandchars=\\\{\}]
83 byte 8: [ X 1 ] [sparse] flag (1 bit)
86 The decoder now performs for each of the \varname{[codebook\_entries]}
89 \begin{Verbatim}[commandchars=\\\{\}]
91 1) if([sparse] is set) \{
93 2) [flag] = read one bit;
94 3) if([flag] is set) \{
96 4) [length] = read a five bit unsigned integer;
97 5) codeword length for this entry is [length]+1;
101 6) this entry is unused. mark it as such.
105 \} else the sparse flag is not set \{
107 7) [length] = read a five bit unsigned integer;
108 8) the codeword length for this entry is [length]+1;
115 If the \varname{[ordered]} flag is set, the codeword list for this
116 codebook is encoded in ascending length order. Rather than reading
117 a length for every codeword, the encoder reads the number of
118 codewords per length. That is, beginning at entry zero:
120 \begin{Verbatim}[commandchars=\\\{\}]
121 1) [current\_entry] = 0;
122 2) [current\_length] = read a five bit unsigned integer and add 1;
123 3) [number] = read \link{vorbis:spec:ilog}{ilog}([codebook\_entries] - [current\_entry]) bits as an unsigned integer
124 4) set the entries [current\_entry] through [current\_entry]+[number]-1, inclusive,
125 of the [codebook\_codeword\_lengths] array to [current\_length]
126 5) set [current\_entry] to [number] + [current\_entry]
127 6) increment [current\_length] by 1
128 7) if [current\_entry] is greater than [codebook\_entries] ERROR CONDITION;
129 the decoder will not be able to read this stream.
130 8) if [current\_entry] is less than [codebook\_entries], repeat process starting at 3)
136 After all codeword lengths have been decoded, the decoder reads the
137 vector lookup table. Vorbis I supports three lookup types:
142 Implicitly populated value mapping (lattice VQ)
144 Explicitly populated value mapping (tessellated or 'foam'
149 The lookup table type is read as a four bit unsigned integer:
150 \begin{Verbatim}[commandchars=\\\{\}]
151 1) [codebook\_lookup\_type] = read four bits as an unsigned integer
154 Codebook decode precedes according to \varname{[codebook\_lookup\_type]}:
157 Lookup type zero indicates no lookup to be read. Proceed past
160 Lookup types one and two are similar, differing only in the
161 number of lookup values to be read. Lookup type one reads a list of
162 values that are permuted in a set pattern to build a list of vectors,
163 each vector of order \varname{[codebook\_dimensions]} scalars. Lookup
164 type two builds the same vector list, but reads each scalar for each
165 vector explicitly, rather than building vectors from a smaller list of
166 possible scalar values. Lookup decode proceeds as follows:
168 \begin{Verbatim}[commandchars=\\\{\}]
169 1) [codebook\_minimum\_value] = \link{vorbis:spec:float32:unpack}{float32\_unpack}( read 32 bits as an unsigned integer)
170 2) [codebook\_delta\_value] = \link{vorbis:spec:float32:unpack}{float32\_unpack}( read 32 bits as an unsigned integer)
171 3) [codebook\_value\_bits] = read 4 bits as an unsigned integer and add 1
172 4) [codebook\_sequence\_p] = read 1 bit as a boolean flag
174 if ( [codebook\_lookup\_type] is 1 ) \{
176 5) [codebook\_lookup\_values] = \link{vorbis:spec:lookup1:values}{lookup1\_values}(\varname{[codebook\_entries]}, \varname{[codebook\_dimensions]} )
180 6) [codebook\_lookup\_values] = \varname{[codebook\_entries]} * \varname{[codebook\_dimensions]}
184 7) read a total of [codebook\_lookup\_values] unsigned integers of [codebook\_value\_bits] each;
185 store these in order in the array [codebook\_multiplicands]
188 A \varname{[codebook\_lookup\_type]} of greater than two is reserved
189 and indicates a stream that is not decodable by the specification in this
195 An 'end of packet' during any read operation in the above steps is
196 considered an error condition rendering the stream undecodable.
198 \paragraph{Huffman decision tree representation}
200 The \varname{[codebook\_codeword\_lengths]} array and
201 \varname{[codebook\_entries]} value uniquely define the Huffman decision
202 tree used for entropy decoding.
204 Briefly, each used codebook entry (recall that length-unordered
205 codebooks support unused codeword entries) is assigned, in order, the
206 lowest valued unused binary Huffman codeword possible. Assume the
207 following codeword length list:
209 \begin{Verbatim}[commandchars=\\\{\}]
220 Assigning codewords in order (lowest possible value of the appropriate
221 length to highest) results in the following codeword list:
223 \begin{Verbatim}[commandchars=\\\{\}]
224 entry 0: length 2 codeword 00
225 entry 1: length 4 codeword 0100
226 entry 2: length 4 codeword 0101
227 entry 3: length 4 codeword 0110
228 entry 4: length 4 codeword 0111
229 entry 5: length 2 codeword 10
230 entry 6: length 3 codeword 110
231 entry 7: length 3 codeword 111
236 Unlike most binary numerical values in this document, we
237 intend the above codewords to be read and used bit by bit from left to
238 right, thus the codeword '001' is the bit string 'zero, zero, one'.
239 When determining 'lowest possible value' in the assignment definition
240 above, the leftmost bit is the MSb.
243 It is clear that the codeword length list represents a Huffman
244 decision tree with the entry numbers equivalent to the leaves numbered
248 \includegraphics[width=10cm]{hufftree}
249 \captionof{figure}{huffman tree illustration}
253 As we assign codewords in order, we see that each choice constructs a
254 new leaf in the leftmost possible position.
256 Note that it's possible to underspecify or overspecify a Huffman tree
257 via the length list. In the above example, if codeword seven were
258 eliminated, it's clear that the tree is unfinished:
261 \includegraphics[width=10cm]{hufftree-under}
262 \captionof{figure}{underspecified huffman tree illustration}
266 Similarly, in the original codebook, it's clear that the tree is fully
267 populated and a ninth codeword is impossible. Both underspecified and
268 overspecified trees are an error condition rendering the stream
271 Codebook entries marked 'unused' are simply skipped in the assigning
272 process. They have no codeword and do not appear in the decision
273 tree, thus it's impossible for any bit pattern read from the stream to
274 decode to that entry number.
276 \paragraph{Errata 20150226: Single entry codebooks}
278 A 'single-entry codebook' is a codebook with one active codeword
279 entry. A single-entry codebook may be either a fully populated
280 codebook with only one declared entry, or a sparse codebook with only
281 one entry marked used. The Vorbis I spec provides no means to specify
282 a codeword length of zero, and as a result, a single-entry codebook is
283 inherently malformed because it is underpopulated. The original
284 specification did not address directly the matter of single-entry
285 codebooks; they were implicitly illegal as it was not possible to
286 write such a codebook with a valid tree structure.
288 In r14811 of the libvorbis reference implementation, Xiph added an
289 additional check to the codebook implementation to reject
290 underpopulated Huffman trees. This change led to the discovery of
291 single-entry books used 'in the wild' when the new, stricter checks
292 rejected a number of apparently working streams.
294 In order to minimize breakage of deployed (if technically erroneous)
295 streams, r16073 of the reference implementation explicitly
296 special-cased single-entry codebooks to tolerate the single-entry
297 case. Commit r16073 also added the following to the specification:
299 \blockquote{\sout{Take special care that a codebook with a single used
300 entry is handled properly; it consists of a single codework of
301 zero bits and ’reading’ a value out of such a codebook always
302 returns the single used value and sinks zero bits.
305 The intent was to clarify the spec and codify current practice.
306 However, this addition is erroneously at odds with the intent of preserving
307 usability of existing streams using single-entry codebooks, disagrees
308 with the code changes that reinstated decoding, and does not address how
309 single-entry codebooks should be encoded.
311 As such, the above addition made in r16037 is struck from the
312 specification and replaced by the following:
314 \blockquote{It is possible to declare a Vorbis codebook containing a
315 single codework entry. A single-entry codebook may be either a
316 fully populated codebook with \varname{[codebook\_entries]} set to
317 1, or a sparse codebook marking only one entry used. Note that it
318 is not possible to also encode a \varname{[codeword\_length]} of
319 zero for the single used codeword, as the unsigned value written to
320 the stream is \varname{[codeword\_length]-1}. Instead, encoder
321 implementations should indicate a \varname{[codeword\_length]} of 1
322 and 'write' the codeword to a stream during audio encoding by
323 writing a single zero bit.
325 Decoder implementations shall reject a codebook if it contains only
326 one used entry and the encoded \varname{[codeword\_length]} of that
327 entry is not 1. 'Reading' a value from single-entry codebook always
328 returns the single used codeword value and sinks one bit. Decoders
329 should tolerate that the bit read from the stream be '1' instead of
330 '0'; both values shall return the single used codeword.}
332 \paragraph{VQ lookup table vector representation}
334 Unpacking the VQ lookup table vectors relies on the following values:
335 \begin{programlisting}
336 the [codebook\_multiplicands] array
337 [codebook\_minimum\_value]
338 [codebook\_delta\_value]
339 [codebook\_sequence\_p]
340 [codebook\_lookup\_type]
342 [codebook\_dimensions]
343 [codebook\_lookup\_values]
348 Decoding (unpacking) a specific vector in the vector lookup table
349 proceeds according to \varname{[codebook\_lookup\_type]}. The unpacked
350 vector values are what a codebook would return during audio packet
351 decode in a VQ context.
353 \paragraph{Vector value decode: Lookup type 1}
355 Lookup type one specifies a lattice VQ lookup table built
356 algorithmically from a list of scalar values. Calculate (unpack) the
357 final values of a codebook entry vector from the entries in
358 \varname{[codebook\_multiplicands]} as follows (\varname{[value\_vector]}
359 is the output vector representing the vector of values for entry number
360 \varname{[lookup\_offset]} in this codebook):
362 \begin{Verbatim}[commandchars=\\\{\}]
364 2) [index\_divisor] = 1;
365 3) iterate [i] over the range 0 ... [codebook\_dimensions]-1 (once for each scalar value in the value vector) \{
367 4) [multiplicand\_offset] = ( [lookup\_offset] divided by [index\_divisor] using integer
368 division ) integer modulo [codebook\_lookup\_values]
370 5) vector [value\_vector] element [i] =
371 ( [codebook\_multiplicands] array element number [multiplicand\_offset] ) *
372 [codebook\_delta\_value] + [codebook\_minimum\_value] + [last];
374 6) if ( [codebook\_sequence\_p] is set ) then set [last] = vector [value\_vector] element [i]
376 7) [index\_divisor] = [index\_divisor] * [codebook\_lookup\_values]
380 8) vector calculation completed.
385 \paragraph{Vector value decode: Lookup type 2}
387 Lookup type two specifies a VQ lookup table in which each scalar in
388 each vector is explicitly set by the \varname{[codebook\_multiplicands]}
389 array in a one-to-one mapping. Calculate [unpack] the
390 final values of a codebook entry vector from the entries in
391 \varname{[codebook\_multiplicands]} as follows (\varname{[value\_vector]}
392 is the output vector representing the vector of values for entry number
393 \varname{[lookup\_offset]} in this codebook):
395 \begin{Verbatim}[commandchars=\\\{\}]
397 2) [multiplicand\_offset] = [lookup\_offset] * [codebook\_dimensions]
398 3) iterate [i] over the range 0 ... [codebook\_dimensions]-1 (once for each scalar value in the value vector) \{
400 4) vector [value\_vector] element [i] =
401 ( [codebook\_multiplicands] array element number [multiplicand\_offset] ) *
402 [codebook\_delta\_value] + [codebook\_minimum\_value] + [last];
404 5) if ( [codebook\_sequence\_p] is set ) then set [last] = vector [value\_vector] element [i]
406 6) increment [multiplicand\_offset]
410 7) vector calculation completed.
421 \subsection{Use of the codebook abstraction}
423 The decoder uses the codebook abstraction much as it does the
424 bit-unpacking convention; a specific codebook reads a
425 codeword from the bitstream, decoding it into an entry number, and then
426 returns that entry number to the decoder (when used in a scalar
427 entropy coding context), or uses that entry number as an offset into
428 the VQ lookup table, returning a vector of values (when used in a context
429 desiring a VQ value). Scalar or VQ context is always explicit; any call
430 to the codebook mechanism requests either a scalar entry number or a
433 Note that VQ lookup type zero indicates that there is no lookup table;
434 requesting decode using a codebook of lookup type 0 in any context
435 expecting a vector return value (even in a case where a vector of
436 dimension one) is forbidden. If decoder setup or decode requests such
437 an action, that is an error condition rendering the packet
440 Using a codebook to read from the packet bitstream consists first of
441 reading and decoding the next codeword in the bitstream. The decoder
442 reads bits until the accumulated bits match a codeword in the
443 codebook. This process can be though of as logically walking the
444 Huffman decode tree by reading one bit at a time from the bitstream,
445 and using the bit as a decision boolean to take the 0 branch (left in
446 the above examples) or the 1 branch (right in the above examples).
447 Walking the tree finishes when the decode process hits a leaf in the
448 decision tree; the result is the entry number corresponding to that
449 leaf. Reading past the end of a packet propagates the 'end-of-stream'
450 condition to the decoder.
452 When used in a scalar context, the resulting codeword entry is the
453 desired return value.
455 When used in a VQ context, the codeword entry number is used as an
456 offset into the VQ lookup table. The value returned to the decoder is
457 the vector of scalars corresponding to this offset.