//! ShortCodebookDesc { code: 0b01, bits: 2 },
//! ShortCodebookDesc { code: 0b1, bits: 1 });
//! let mut cr = ShortCodebookDescReader::new(cb_desc);
-//! let cb = Codebook::new(&mut cr, CodebookMode::LSB).unwrap();
+//! let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
//! ```
//!
//! Create a codebook using more flexible [`TableCodebookDescReader`] approach.
///
/// [`ShortCodebookDescReader`]: ./struct.ShortCodebookDescReader.html
/// [`TableCodebookDescReader`]: ./struct.TableCodebookDescReader.html
+#[allow(clippy::len_without_is_empty)]
pub trait CodebookDescReader<S> {
/// Returns the codeword length for the provided index.
fn bits(&mut self, idx: usize) -> u8;
/// The codebook structure for code reading.
#[allow(dead_code)]
pub struct Codebook<S> {
- table: Vec<u32>,
- syms: Vec<S>,
- lut_bits: u8,
+ pub table: Vec<u32>,
+ pub syms: Vec<S>,
+ pub lut_bits: u8,
}
/// Trait allowing bitreader to use codebook for decoding bit sequences.
fn read_cb(&mut self, cb: &Codebook<S>) -> CodebookResult<S>;
}
-const TABLE_FILL_VALUE: u32 = 0x7F;
+pub const TABLE_FILL_VALUE: u32 = 0x7F;
const MAX_LUT_BITS: u8 = 10;
-fn fill_lut_msb(table: &mut Vec<u32>, off: usize,
- code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) {
+fn fill_lut_msb(table: &mut [u32], off: usize,
+ code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) -> CodebookResult<()> {
if !esc {
let fill_len = lut_bits - bits;
let fill_size = 1 << fill_len;
let lut_value = (symidx << 8) | u32::from(bits);
for j in 0..fill_size {
let idx = (fill_code + j) as usize;
+ if table[idx + off] != TABLE_FILL_VALUE { return Err(CodebookError::InvalidCodebook); }
table[idx + off] = lut_value;
}
} else {
let idx = (code as usize) + off;
+ if table[idx] != TABLE_FILL_VALUE { return Err(CodebookError::InvalidCodebook); }
table[idx] = (symidx << 8) | 0x80 | u32::from(bits);
}
+ Ok(())
}
-fn fill_lut_lsb(table: &mut Vec<u32>, off: usize,
- code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) {
+fn fill_lut_lsb(table: &mut [u32], off: usize,
+ code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) -> CodebookResult<()> {
if !esc {
let fill_len = lut_bits - bits;
let fill_size = 1 << fill_len;
let step = lut_bits - fill_len;
for j in 0..fill_size {
let idx = (fill_code + (j << step)) as usize;
+ if table[idx + off] != TABLE_FILL_VALUE { return Err(CodebookError::InvalidCodebook); }
table[idx + off] = (symidx << 8) | u32::from(bits);
}
} else {
let idx = (code as usize) + off;
+ if table[idx] != TABLE_FILL_VALUE { return Err(CodebookError::InvalidCodebook); }
table[idx] = (symidx << 8) | 0x80 | u32::from(bits);
}
+ Ok(())
}
-fn fill_lut(table: &mut Vec<u32>, mode: CodebookMode,
- off: usize, code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) -> bool {
+fn fill_lut(table: &mut [u32], mode: CodebookMode,
+ off: usize, code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) -> CodebookResult<bool> {
match mode {
- CodebookMode::MSB => fill_lut_msb(table, off, code, bits, lut_bits, symidx, esc),
- CodebookMode::LSB => fill_lut_lsb(table, off, code, bits, lut_bits, symidx, esc),
+ CodebookMode::MSB => fill_lut_msb(table, off, code, bits, lut_bits, symidx, esc)?,
+ CodebookMode::LSB => fill_lut_lsb(table, off, code, bits, lut_bits, symidx, esc)?,
};
- bits > lut_bits
+ Ok(bits > lut_bits)
}
fn resize_table(table: &mut Vec<u32>, bits: u8) -> CodebookResult<u32> {
let bits = code.bits;
if code.bits <= MAX_LUT_BITS {
fill_lut(table, mode, bucket.offset, code.code, bits,
- maxlen, code.idx as u32, false);
+ maxlen, code.idx as u32, false)?;
} else {
let ckey = extract_lut_part(code.code, bits, MAX_LUT_BITS, mode);
let cval = extract_esc_part(code.code, bits, MAX_LUT_BITS, mode);
let cur_offset = bucket.offset;
for (ckey, sec_bucket) in &mut escape_list {
- let key = *ckey as u32;
+ let key = *ckey;
let maxlen = min(sec_bucket.maxlen, MAX_LUT_BITS);
let new_off = resize_table(table, maxlen)?;
fill_lut(table, mode, cur_offset, key, maxlen,
- MAX_LUT_BITS, new_off, true);
+ MAX_LUT_BITS, new_off, true)?;
sec_bucket.offset = new_off as usize;
}
impl<S: Copy> Codebook<S> {
/// Constructs a new `Codebook` instance using provided codebook description and mode.
- pub fn new(cb: &mut CodebookDescReader<S>, mode: CodebookMode) -> CodebookResult<Self> {
+ pub fn new(cb: &mut dyn CodebookDescReader<S>, mode: CodebookMode) -> CodebookResult<Self> {
let mut maxbits = 0;
let mut nnz = 0;
let mut escape_list: EscapeCodes = HashMap::new();
let code = cb.code(i);
if bits == 0 { continue; }
if bits <= MAX_LUT_BITS {
- fill_lut(&mut table, mode, 0, code, bits, maxbits, symidx, false);
+ fill_lut(&mut table, mode, 0, code, bits, maxbits, symidx, false)?;
} else {
let ckey = extract_lut_part(code, bits, MAX_LUT_BITS, mode) as usize;
if table[ckey] == TABLE_FILL_VALUE {
if let Some(bucket) = escape_list.get_mut(&key) {
let maxlen = min(bucket.maxlen, MAX_LUT_BITS);
let new_off = resize_table(&mut table, maxlen)?;
- fill_lut(&mut table, mode, 0, key, maxlen, MAX_LUT_BITS, new_off, true);
+ fill_lut(&mut table, mode, 0, key, maxlen, MAX_LUT_BITS, new_off, true)?;
bucket.offset = new_off as usize;
}
}
}
for bucket in escape_list.values() {
- build_esc_lut(&mut table, mode, &bucket)?;
+ build_esc_lut(&mut table, mode, bucket)?;
}
for i in 0..cb.len() {
let mut idx = 0;
let mut lut_bits = cb.lut_bits;
while esc {
- let lut_idx = (self.peek(lut_bits) as usize) + (idx as usize);
+ let lut_idx = (self.peek(lut_bits) as usize) + idx;
if cb.table[lut_idx] == TABLE_FILL_VALUE { return Err(CodebookError::InvalidCode); }
let bits = cb.table[lut_idx] & 0x7F;
esc = (cb.table[lut_idx] & 0x80) != 0;
idx = (cb.table[lut_idx] >> 8) as usize;
- if (bits as isize) > self.left() {
+ let skip_bits = if esc { u32::from(lut_bits) } else { bits };
+ if (skip_bits as isize) > self.left() {
return Err(CodebookError::InvalidCode);
}
- let skip_bits = if esc { u32::from(lut_bits) } else { bits };
- self.skip(skip_bits as u32).unwrap();
+ self.skip(skip_bits).unwrap();
lut_bits = bits as u8;
}
Ok(cb.syms[idx])