nihav-core/src/io/codebook.rs

   1 //! Codebook support for bitstream reader.
   2 //!
   3 //! Codebook is a set of unique bit strings and values assigned to them.
   4 //! Since there are many ways to define codebook, this implementation employs [`CodebookDescReader`] trait to provide codebook generator with the codes.
   5 //! Please also pay attention to the codebook creation mode: if bitstream reader reads bits starting from most significant bit first then you should use [`MSB`] mode and [`LSB`] mode otherwise.
   6 //!
   7 //! # Examples
   8 //!
   9 //! Create a codebook from arrays with codeword descriptions:
  10 //! ```
  11 //! use nihav_core::io::codebook::{ShortCodebookDesc, ShortCodebookDescReader, Codebook, CodebookMode};
  12 //!
  13 //! let cb_desc: Vec<ShortCodebookDesc> = vec!(
  14 //!             ShortCodebookDesc { code: 0b00,   bits: 2 },
  15 //!             ShortCodebookDesc { code: 0,      bits: 0 },
  16 //!             ShortCodebookDesc { code: 0b01,   bits: 2 },
  17 //!             ShortCodebookDesc { code: 0b1,    bits: 1 });
  18 //! let mut cr = ShortCodebookDescReader::new(cb_desc);
  19 //! let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
  20 //! ```
  21 //!
  22 //! Create a codebook using more flexible [`TableCodebookDescReader`] approach.
  23 //! This will create a codebook for the following set: `1` -> -2, `01` -> -1, `001` -> 0, `0001` -> 1, `00001` -> 2.
  24 //! ```
  25 //! use nihav_core::io::codebook::{TableCodebookDescReader, Codebook, CodebookMode};
  26 //!
  27 //! fn map_cb_index(index: usize) -> i16 { (index as i16) - 2 }
  28 //! const CB_BITS:  [u8; 5] = [ 1, 2, 3, 4, 5 ];
  29 //! const CB_CODES: [u8; 5] = [ 1, 1, 1, 1, 1 ];
  30 //!
  31 //! let mut tcr = TableCodebookDescReader::new(&CB_CODES, &CB_BITS, map_cb_index);
  32 //! let cb = Codebook::new(&mut tcr, CodebookMode::MSB).unwrap();
  33 //! ```
  34 //!
  35 //! Read value using a codebook:
  36 //! ```no_run
  37 //! use nihav_core::io::bitreader::BitReader;
  38 //! use nihav_core::io::codebook::{Codebook, CodebookReader, CodebookMode};
  39 //! # use nihav_core::io::codebook::{ShortCodebookDesc, ShortCodebookDescReader, CodebookDescReader, CodebookResult};
  40 //!
  41 //! # fn foo(br: &mut BitReader) -> CodebookResult<()> {
  42 //! # let mut cr = ShortCodebookDescReader::new(vec![ShortCodebookDesc { code: 0b00,   bits: 2 }]);
  43 //! let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
  44 //! let value = br.read_cb(&cb)?;
  45 //! # Ok(())
  46 //! # }
  47 //! ```
  48 //!
  49 //! [`MSB`]: ./enum.CodebookMode.html#variant.MSB
  50 //! [`LSB`]: ./enum.CodebookMode.html#variant.LSB
  51 //! [`CodebookDescReader`]: ./trait.CodebookDescReader.html
  52 //! [`TableCodebookDescReader`]: ./struct.TableCodebookDescReader.html
  53
  54 use std::collections::HashMap;
  55 use std::cmp::{max, min};
  56 use super::bitreader::BitReader;
  57
  58 /// A list specifying general codebook operations errors.
  59 #[derive(Debug)]
  60 pub enum CodebookError {
  61     /// Codebook description contains errors.
  62     InvalidCodebook,
  63     /// Could not allocate memory for codebook.
  64     MemoryError,
  65     /// Bitstream contains a sequence not present in codebook.
  66     InvalidCode,
  67 }
  68
  69 /// Codebook operation modes.
  70 #[derive(Debug, Copy, Clone)]
  71 pub enum CodebookMode {
  72     /// Codes in the codebook should be read most significant bit first.
  73     MSB,
  74     /// Codes in the codebook should be read least significant bit first.
  75     LSB,
  76 }
  77
  78 /// A specialised `Result` type for codebook operations.
  79 pub type CodebookResult<T> = Result<T, CodebookError>;
  80
  81 /// Codebook description for `(code bits, code length, code value)` triplet.
  82 ///
  83 /// This should be used to create a list of codeword definitions for [`FullCodebookDescReader`].
  84 ///
  85 /// [`FullCodebookDescReader`]: ./struct.FullCodebookDescReader.html
  86 #[derive(Clone,Copy)]
  87 pub struct FullCodebookDesc<S> {
  88     /// Codeword bits.
  89     pub code: u32,
  90     /// Codeword length.
  91     pub bits: u8,
  92     /// Codeword value (symbol).
  93     pub sym:  S,
  94 }
  95
  96 /// Codebook description for `(code bits, code length)` pair with array index being used as codeword value.
  97 ///
  98 /// This should be used to create a list of codeword definitions for [`ShortCodebookDescReader`].
  99 ///
 100 /// [`ShortCodebookDescReader`]: ./struct.ShortCodebookDescReader.html
 101 #[derive(Clone,Copy)]
 102 pub struct ShortCodebookDesc {
 103     /// Codeword bits.
 104     pub code: u32,
 105     /// Codeword length.
 106     pub bits: u8,
 107 }
 108
 109 /// The interface for providing a list of codeword definitions to the codebook creator.
 110 ///
 111 /// The structure implementing this trait should be able to provide the total number of defined codewords and their bits and values. [`ShortCodebookDescReader`] or [`TableCodebookDescReader`] are some examples of such implementation.
 112 /// Codeword definitions with zero length are ignored (those may be used to create sparse codebook definitions though).
 113 ///
 114 /// [`ShortCodebookDescReader`]: ./struct.ShortCodebookDescReader.html
 115 /// [`TableCodebookDescReader`]: ./struct.TableCodebookDescReader.html
 116 #[allow(clippy::len_without_is_empty)]
 117 pub trait CodebookDescReader<S> {
 118     /// Returns the codeword length for the provided index.
 119     fn bits(&mut self, idx: usize) -> u8;
 120     /// Returns the codeword bits for the provided index.
 121     fn code(&mut self, idx: usize) -> u32;
 122     /// Returns the codeword value (aka codeword symbol) for the provided index.
 123     fn sym (&mut self, idx: usize) -> S;
 124     /// Returns the total number of defined codewords.
 125     fn len (&mut self)             -> usize;
 126 }
 127
 128 /// The codebook structure for code reading.
 129 #[allow(dead_code)]
 130 pub struct Codebook<S> {
 131     pub table: Vec<u32>,
 132     pub syms:  Vec<S>,
 133     pub lut_bits: u8,
 134 }
 135
 136 /// Trait allowing bitreader to use codebook for decoding bit sequences.
 137 pub trait CodebookReader<S> {
 138     /// Reads the codeword from the bitstream and returns its value (or [`InvalidCode`] on error).
 139     ///
 140     /// [`InvalidCode`]: ./enum.CodebookError.html#variant.InvalidCode
 141     fn read_cb(&mut self, cb: &Codebook<S>) -> CodebookResult<S>;
 142 }
 143
 144 pub const TABLE_FILL_VALUE: u32 = 0x7F;
 145 const MAX_LUT_BITS: u8 = 10;
 146
 147 fn fill_lut_msb(table: &mut Vec<u32>, off: usize,
 148                 code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) -> CodebookResult<()> {
 149     if !esc {
 150         let fill_len  = lut_bits - bits;
 151         let fill_size = 1 << fill_len;
 152         let fill_code = code << (lut_bits - bits);
 153         let lut_value = (symidx << 8) | u32::from(bits);
 154         for j in 0..fill_size {
 155             let idx = (fill_code + j) as usize;
 156             if table[idx + off] != TABLE_FILL_VALUE { return Err(CodebookError::InvalidCodebook); }
 157             table[idx + off] = lut_value;
 158         }
 159     } else {
 160         let idx = (code as usize) + off;
 161         if table[idx] != TABLE_FILL_VALUE { return Err(CodebookError::InvalidCodebook); }
 162         table[idx] = (symidx << 8) | 0x80 | u32::from(bits);
 163     }
 164     Ok(())
 165 }
 166
 167 fn fill_lut_lsb(table: &mut Vec<u32>, off: usize,
 168                 code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) -> CodebookResult<()> {
 169     if !esc {
 170         let fill_len  = lut_bits - bits;
 171         let fill_size = 1 << fill_len;
 172         let fill_code = code;
 173         let step = lut_bits - fill_len;
 174         for j in 0..fill_size {
 175             let idx = (fill_code + (j << step)) as usize;
 176             if table[idx + off] != TABLE_FILL_VALUE { return Err(CodebookError::InvalidCodebook); }
 177             table[idx + off] = (symidx << 8) | u32::from(bits);
 178         }
 179     } else {
 180         let idx = (code as usize) + off;
 181         if table[idx] != TABLE_FILL_VALUE { return Err(CodebookError::InvalidCodebook); }
 182         table[idx] = (symidx << 8) | 0x80 | u32::from(bits);
 183     }
 184     Ok(())
 185 }
 186
 187 fn fill_lut(table: &mut Vec<u32>, mode: CodebookMode,
 188             off: usize, code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) -> CodebookResult<bool> {
 189     match mode {
 190         CodebookMode::MSB => fill_lut_msb(table, off, code, bits, lut_bits, symidx, esc)?,
 191         CodebookMode::LSB => fill_lut_lsb(table, off, code, bits, lut_bits, symidx, esc)?,
 192     };
 193     Ok(bits > lut_bits)
 194 }
 195
 196 fn resize_table(table: &mut Vec<u32>, bits: u8) -> CodebookResult<u32> {
 197     let add_size = (1 << bits) as usize;
 198     table.reserve(add_size);
 199     let cur_off = table.len() as u32;
 200     let new_size = table.len() + add_size;
 201     if table.capacity() < new_size { return Err(CodebookError::MemoryError); }
 202     table.resize(new_size, TABLE_FILL_VALUE);
 203     Ok(cur_off)
 204 }
 205
 206
 207 fn extract_lut_part(code: u32, bits: u8, lut_bits: u8, mode: CodebookMode) -> u32 {
 208     match mode {
 209         CodebookMode::MSB => code >> (bits - lut_bits),
 210         CodebookMode::LSB => code & ((1 << lut_bits) - 1),
 211     }
 212 }
 213
 214 fn extract_esc_part(code: u32, bits: u8, lut_bits: u8, mode: CodebookMode) -> u32 {
 215     match mode {
 216         CodebookMode::MSB => code & ((1 << (bits - lut_bits)) - 1),
 217         CodebookMode::LSB => code >> lut_bits,
 218     }
 219 }
 220
 221 #[derive(Clone,Copy)]
 222 struct Code {
 223     code: u32,
 224     bits: u8,
 225     idx:  usize,
 226 }
 227
 228 struct CodeBucket {
 229     maxlen: u8,
 230     offset: usize,
 231     codes:  Vec<Code>,
 232 }
 233
 234 impl CodeBucket {
 235     fn new() -> Self {
 236         CodeBucket { maxlen: 0, offset: 0, codes: Vec::new() }
 237     }
 238     fn add_code(&mut self, c: Code) {
 239         if c.bits > self.maxlen { self.maxlen = c.bits; }
 240         self.codes.push(c);
 241     }
 242 }
 243
 244 type EscapeCodes = HashMap<u32, CodeBucket>;
 245
 246 fn add_esc_code(cc: &mut EscapeCodes, key: u32, code: u32, bits: u8, idx: usize) {
 247     cc.entry(key).or_insert_with(CodeBucket::new);
 248     let b = cc.get_mut(&key);
 249     if let Some(bucket) = b {
 250         bucket.add_code(Code {code, bits, idx });
 251     } else { panic!("no bucket when expected!"); }
 252 }
 253
 254 fn build_esc_lut(table: &mut Vec<u32>,
 255                  mode: CodebookMode,
 256                  bucket: &CodeBucket) -> CodebookResult<()> {
 257     let mut escape_list: EscapeCodes = HashMap::new();
 258     let maxlen = if bucket.maxlen > MAX_LUT_BITS { MAX_LUT_BITS } else { bucket.maxlen };
 259
 260     for code in &bucket.codes {
 261         let bits = code.bits;
 262         if code.bits <= MAX_LUT_BITS {
 263             fill_lut(table, mode, bucket.offset, code.code, bits,
 264                      maxlen, code.idx as u32, false)?;
 265         } else {
 266             let ckey = extract_lut_part(code.code, bits, MAX_LUT_BITS, mode);
 267             let cval = extract_esc_part(code.code, bits, MAX_LUT_BITS, mode);
 268             add_esc_code(&mut escape_list, ckey, cval, bits - MAX_LUT_BITS, code.idx);
 269         }
 270     }
 271
 272     let cur_offset = bucket.offset;
 273     for (ckey, sec_bucket) in &mut escape_list {
 274         let key = *ckey as u32;
 275         let maxlen = min(sec_bucket.maxlen, MAX_LUT_BITS);
 276         let new_off = resize_table(table, maxlen)?;
 277         fill_lut(table, mode, cur_offset, key, maxlen,
 278                  MAX_LUT_BITS, new_off, true)?;
 279         sec_bucket.offset = new_off as usize;
 280     }
 281
 282     for sec_bucket in escape_list.values() {
 283         build_esc_lut(table, mode, sec_bucket)?;
 284     }
 285
 286     Ok(())
 287 }
 288
 289 impl<S: Copy> Codebook<S> {
 290
 291     /// Constructs a new `Codebook` instance using provided codebook description and mode.
 292     pub fn new(cb: &mut dyn CodebookDescReader<S>, mode: CodebookMode) -> CodebookResult<Self> {
 293         let mut maxbits = 0;
 294         let mut nnz = 0;
 295         let mut escape_list: EscapeCodes = HashMap::new();
 296
 297         let mut symidx: usize = 0;
 298         for i in 0..cb.len() {
 299             let bits = cb.bits(i);
 300             if bits > 0 {
 301                 nnz += 1;
 302                 if cb.code(i) >= (1 << bits) {
 303                     return Err(CodebookError::InvalidCodebook);
 304                 }
 305             }
 306             maxbits = max(bits, maxbits);
 307             if bits > MAX_LUT_BITS {
 308                 let code = cb.code(i);
 309                 let ckey = extract_lut_part(code, bits, MAX_LUT_BITS, mode);
 310                 let cval = extract_esc_part(code, bits, MAX_LUT_BITS, mode);
 311                 add_esc_code(&mut escape_list, ckey, cval, bits - MAX_LUT_BITS, symidx);
 312             }
 313             if bits > 0 { symidx += 1; }
 314         }
 315         if maxbits == 0 { return Err(CodebookError::InvalidCodebook); }
 316
 317         if maxbits > MAX_LUT_BITS { maxbits = MAX_LUT_BITS; }
 318
 319         let tab_len = 1 << maxbits;
 320         let mut table: Vec<u32> = Vec::with_capacity(tab_len);
 321         let mut syms:  Vec<S>   = Vec::with_capacity(nnz);
 322         if table.capacity() < tab_len { return Err(CodebookError::MemoryError); }
 323         if syms.capacity()  < nnz     { return Err(CodebookError::MemoryError); }
 324         table.resize(tab_len, TABLE_FILL_VALUE);
 325
 326         let mut symidx: u32 = 0;
 327         for i in 0..cb.len() {
 328             let bits = cb.bits(i);
 329             let code = cb.code(i);
 330             if bits == 0 { continue; }
 331             if bits <= MAX_LUT_BITS {
 332                 fill_lut(&mut table, mode, 0, code, bits, maxbits, symidx, false)?;
 333             } else {
 334                 let ckey = extract_lut_part(code, bits, MAX_LUT_BITS, mode) as usize;
 335                 if table[ckey] == TABLE_FILL_VALUE {
 336                     let key = ckey as u32;
 337                     if let Some(bucket) = escape_list.get_mut(&key) {
 338                         let maxlen = min(bucket.maxlen, MAX_LUT_BITS);
 339                         let new_off = resize_table(&mut table, maxlen)?;
 340                         fill_lut(&mut table, mode, 0, key, maxlen, MAX_LUT_BITS, new_off, true)?;
 341                         bucket.offset = new_off as usize;
 342                     }
 343                 }
 344             }
 345             symidx += 1;
 346         }
 347
 348         for bucket in escape_list.values() {
 349             build_esc_lut(&mut table, mode, &bucket)?;
 350         }
 351
 352         for i in 0..cb.len() {
 353             if cb.bits(i) > 0 {
 354                 syms.push(cb.sym(i));
 355             }
 356         }
 357
 358         Ok(Codebook { table, syms, lut_bits: maxbits })
 359     }
 360 }
 361
 362 impl<'a, S: Copy> CodebookReader<S> for BitReader<'a> {
 363     #[allow(unused_variables)]
 364     fn read_cb(&mut self, cb: &Codebook<S>) -> CodebookResult<S> {
 365         let mut esc = true;
 366         let mut idx = 0;
 367         let mut lut_bits = cb.lut_bits;
 368         while esc {
 369             let lut_idx = (self.peek(lut_bits) as usize) + (idx as usize);
 370             if cb.table[lut_idx] == TABLE_FILL_VALUE { return Err(CodebookError::InvalidCode); }
 371             let bits = cb.table[lut_idx] & 0x7F;
 372             esc  = (cb.table[lut_idx] & 0x80) != 0;
 373             idx  = (cb.table[lut_idx] >> 8) as usize;
 374             let skip_bits = if esc { u32::from(lut_bits) } else { bits };
 375             if (skip_bits as isize) > self.left() {
 376                 return Err(CodebookError::InvalidCode);
 377             }
 378             self.skip(skip_bits as u32).unwrap();
 379             lut_bits = bits as u8;
 380         }
 381         Ok(cb.syms[idx])
 382     }
 383 }
 384
 385 /// Codebook description that stores a list of codewords and their values.
 386 pub struct FullCodebookDescReader<S> {
 387     data: Vec<FullCodebookDesc<S>>,
 388 }
 389
 390 impl<S> FullCodebookDescReader<S> {
 391     /// Constructs a new `FullCodebookDescReader` instance.
 392     pub fn new(data: Vec<FullCodebookDesc<S>>) -> Self {
 393         FullCodebookDescReader { data }
 394     }
 395 }
 396
 397 impl<S: Copy> CodebookDescReader<S> for FullCodebookDescReader<S> {
 398     fn bits(&mut self, idx: usize) -> u8  { self.data[idx].bits }
 399     fn code(&mut self, idx: usize) -> u32 { self.data[idx].code }
 400     fn sym (&mut self, idx: usize) -> S   { self.data[idx].sym  }
 401     fn len(&mut self) -> usize { self.data.len() }
 402 }
 403
 404 /// Codebook description that stores a list of codewords and their value is equal to the index.
 405 pub struct ShortCodebookDescReader {
 406     data: Vec<ShortCodebookDesc>,
 407 }
 408
 409 impl ShortCodebookDescReader {
 410     /// Constructs a new `ShortCodebookDescReader` instance.
 411     pub fn new(data: Vec<ShortCodebookDesc<>>) -> Self {
 412         ShortCodebookDescReader { data }
 413     }
 414 }
 415
 416 impl CodebookDescReader<u32> for ShortCodebookDescReader {
 417     fn bits(&mut self, idx: usize) -> u8  { self.data[idx].bits }
 418     fn code(&mut self, idx: usize) -> u32 { self.data[idx].code }
 419     fn sym (&mut self, idx: usize) -> u32 { idx as u32 }
 420     fn len(&mut self) -> usize { self.data.len() }
 421 }
 422
 423 /// Flexible codebook description that uses two separate arrays for codeword bits and lengths and a function that maps codeword index into its symbol.
 424 pub struct TableCodebookDescReader<'a, CodeType:'static, IndexType:'static> {
 425     bits:       &'a [u8],
 426     codes:      &'a [CodeType],
 427     idx_map:    fn(usize) -> IndexType,
 428 }
 429
 430 impl<'a, CodeType, IndexType> TableCodebookDescReader<'a, CodeType, IndexType> {
 431     /// Constructs a new `TableCodebookDescReader` instance.
 432     pub fn new(codes: &'a [CodeType], bits: &'a [u8], idx_map: fn(usize) -> IndexType) -> Self {
 433         Self { bits, codes, idx_map }
 434     }
 435 }
 436 impl<'a, CodeType: Copy+Into<u32>, IndexType> CodebookDescReader<IndexType> for TableCodebookDescReader<'a, CodeType, IndexType>
 437 {
 438     fn bits(&mut self, idx: usize) -> u8  { self.bits[idx] }
 439     fn code(&mut self, idx: usize) -> u32 { self.codes[idx].into() }
 440     fn sym (&mut self, idx: usize) -> IndexType { (self.idx_map)(idx) }
 441     fn len(&mut self) -> usize { self.bits.len() }
 442 }
 443
 444 #[cfg(test)]
 445 mod test {
 446     use super::*;
 447     use crate::io::bitreader::*;
 448
 449     #[test]
 450     fn test_cb() {
 451         const BITS: [u8; 2] = [0b01011011, 0b10111100];
 452         let cb_desc: Vec<FullCodebookDesc<i8>> = vec!(
 453             FullCodebookDesc { code: 0b0,    bits: 1, sym:  16 },
 454             FullCodebookDesc { code: 0b10,   bits: 2, sym:  -3 },
 455             FullCodebookDesc { code: 0b110,  bits: 3, sym:  42 },
 456             FullCodebookDesc { code: 0b1110, bits: 4, sym: -42 }
 457         );
 458         let buf = &BITS;
 459         let mut br = BitReader::new(buf, BitReaderMode::BE);
 460         let mut cfr = FullCodebookDescReader::new(cb_desc);
 461         let cb = Codebook::new(&mut cfr, CodebookMode::MSB).unwrap();
 462         assert_eq!(br.read_cb(&cb).unwrap(),  16);
 463         assert_eq!(br.read_cb(&cb).unwrap(),  -3);
 464         assert_eq!(br.read_cb(&cb).unwrap(),  42);
 465         assert_eq!(br.read_cb(&cb).unwrap(), -42);
 466         let ret = br.read_cb(&cb);
 467         if let Err(e) = ret {
 468             assert_eq!(e as i32, CodebookError::InvalidCode as i32);
 469         } else {
 470             assert_eq!(0, 1);
 471         }
 472
 473         let scb_desc: Vec<ShortCodebookDesc> = vec!(
 474             ShortCodebookDesc { code: 0b0,    bits: 1 },
 475             ShortCodebookDesc { code: 0,      bits: 0 },
 476             ShortCodebookDesc { code: 0b10,   bits: 2 },
 477             ShortCodebookDesc { code: 0,      bits: 0 },
 478             ShortCodebookDesc { code: 0,      bits: 0 },
 479             ShortCodebookDesc { code: 0b110,  bits: 3 },
 480             ShortCodebookDesc { code: 0,      bits: 0 },
 481             ShortCodebookDesc { code: 0b11100, bits: 5 },
 482             ShortCodebookDesc { code: 0b11101, bits: 5 },
 483             ShortCodebookDesc { code: 0b1111010, bits: 7 },
 484             ShortCodebookDesc { code: 0b1111011, bits: 7 },
 485             ShortCodebookDesc { code: 0b1111110, bits: 7 },
 486             ShortCodebookDesc { code: 0b11111111, bits: 8 }
 487         );
 488         let mut br2 = BitReader::new(buf, BitReaderMode::BE);
 489         let mut cfr = ShortCodebookDescReader::new(scb_desc);
 490         let cb = Codebook::new(&mut cfr, CodebookMode::MSB).unwrap();
 491         assert_eq!(br2.read_cb(&cb).unwrap(), 0);
 492         assert_eq!(br2.read_cb(&cb).unwrap(), 2);
 493         assert_eq!(br2.read_cb(&cb).unwrap(), 5);
 494         assert_eq!(br2.read_cb(&cb).unwrap(), 8);
 495
 496         assert_eq!(reverse_bits(0b0000_0101_1011_1011_1101_1111_0111_1111, 32),
 497                                 0b1111_1110_1111_1011_1101_1101_1010_0000);
 498
 499         const BITS_LE: [u8; 3] = [0b11101111, 0b01110010, 0b01];
 500         let buf = &BITS_LE;
 501         let scble_desc: Vec<ShortCodebookDesc> = vec!(
 502             ShortCodebookDesc { code: 0b00,   bits: 2 },
 503             ShortCodebookDesc { code: 0,      bits: 0 },
 504             ShortCodebookDesc { code: 0b01,   bits: 2 },
 505             ShortCodebookDesc { code: 0,      bits: 0 },
 506             ShortCodebookDesc { code: 0,      bits: 0 },
 507             ShortCodebookDesc { code: 0b011,  bits: 3 },
 508             ShortCodebookDesc { code: 0,      bits: 0 },
 509             ShortCodebookDesc { code: 0b10111, bits: 5 },
 510             ShortCodebookDesc { code: 0b00111, bits: 5 },
 511             ShortCodebookDesc { code: 0b0101111, bits: 7 },
 512             ShortCodebookDesc { code: 0b0111111, bits: 7 },
 513             ShortCodebookDesc { code: 0b1011101111, bits: 10 }
 514         );
 515         let mut brl = BitReader::new(buf, BitReaderMode::LE);
 516         let mut cfr = ShortCodebookDescReader::new(scble_desc);
 517         let cb = Codebook::new(&mut cfr, CodebookMode::LSB).unwrap();
 518         assert_eq!(brl.read_cb(&cb).unwrap(), 11);
 519         assert_eq!(brl.read_cb(&cb).unwrap(), 0);
 520         assert_eq!(brl.read_cb(&cb).unwrap(), 7);
 521         assert_eq!(brl.read_cb(&cb).unwrap(), 0);
 522     }
 523 }