+pub fn reverse_bits(inval: u32) -> u32 {
+ const REV_TAB: [u8; 16] = [
+ 0b0000, 0b1000, 0b0100, 0b1100, 0b0010, 0b1010, 0b0110, 0b1110,
+ 0b0001, 0b1001, 0b0101, 0b1101, 0b0011, 0b1011, 0b0111, 0b1111,
+ ];
+
+ let mut ret = 0;
+ let mut val = inval;
+ for _ in 0..8 {
+ ret = (ret << 4) | (REV_TAB[(val & 0xF) as usize] as u32);
+ val = val >> 4;
+ }
+ ret
+}
+
+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) {
+ if !esc {
+ let fill_len = lut_bits - bits;
+ let fill_size = 1 << fill_len;
+ let fill_code = code << (lut_bits - bits);
+ let lut_value = (symidx << 8) | (bits as u32);
+ for j in 0..fill_size {
+ let idx = (fill_code + j) as usize;
+ table[idx + off] = lut_value;
+ }
+ } else {
+ let idx = (code as usize) + off;
+ table[idx] = (symidx << 8) | 0x80 | (bits as u32);
+ }
+}
+
+fn fill_lut_lsb(table: &mut Vec<u32>, off: usize,
+ code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) {
+ if !esc {
+ let fill_len = lut_bits - bits;
+ let fill_size = 1 << fill_len;
+ let fill_code = code;
+ let step = lut_bits - fill_len;
+ for j in 0..fill_size {
+ let idx = (fill_code + (j << step)) as usize;
+ table[idx + off] = (symidx << 8) | (bits as u32);
+ }
+ } else {
+ let idx = (code as usize) + off;
+ table[idx] = (symidx << 8) | 0x80 | (bits as u32);
+ }
+}
+
+fn fill_lut(table: &mut Vec<u32>, mode: CodebookMode,
+ off: usize, code: u32, bits: u8, lut_bits: u8, symidx: u32, esc: bool) -> 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),
+ };
+ bits > lut_bits
+}
+
+fn resize_table(table: &mut Vec<u32>, bits: u8) -> CodebookResult<u32> {
+ let add_size = (1 << bits) as usize;
+ table.reserve(add_size);
+ let cur_off = table.len() as u32;
+ let new_size = table.len() + add_size;
+ if table.capacity() < new_size { return Err(CodebookError::MemoryError); }
+ table.resize(new_size, TABLE_FILL_VALUE);
+ Ok(cur_off)
+}
+
+
+fn extract_lut_part(code: u32, bits: u8, lut_bits: u8, mode: CodebookMode) -> u32 {
+ match mode {
+ CodebookMode::MSB => code >> (bits - lut_bits),
+ CodebookMode::LSB => code & ((1 << lut_bits) - 1),
+ }
+}
+
+fn extract_esc_part(code: u32, bits: u8, lut_bits: u8, mode: CodebookMode) -> u32 {
+ match mode {
+ CodebookMode::MSB => code & ((1 << (bits - lut_bits)) - 1),
+ CodebookMode::LSB => code >> lut_bits,
+ }
+}
+
+#[derive(Clone,Copy)]
+struct Code {
+ code: u32,
+ bits: u8,
+ idx: usize,
+}
+
+struct CodeBucket {
+ maxlen: u8,
+ offset: usize,
+ codes: Vec<Code>,
+}
+
+impl CodeBucket {
+ fn new() -> Self {
+ CodeBucket { maxlen: 0, offset: 0, codes: Vec::new() }
+ }
+ fn add_code(&mut self, c: Code) {
+ if c.bits > self.maxlen { self.maxlen = c.bits; }
+ self.codes.push(c);
+ }
+}
+
+type EscapeCodes = HashMap<u32, CodeBucket>;
+
+fn add_esc_code(cc: &mut EscapeCodes, key: u32, code: u32, bits: u8, idx: usize) {
+ if !cc.contains_key(&key) { cc.insert(key, CodeBucket::new()); }
+ let b = cc.get_mut(&key);
+ if let Some(bucket) = b {
+ bucket.add_code(Code {code: code, bits: bits, idx: idx });
+ } else { panic!("no bucket when expected!"); }
+}
+
+fn build_esc_lut(table: &mut Vec<u32>,
+ mode: CodebookMode,
+ bucket: &CodeBucket) -> CodebookResult<()> {
+ let mut escape_list: EscapeCodes = HashMap::new();
+ let maxlen = if bucket.maxlen > MAX_LUT_BITS { MAX_LUT_BITS } else { bucket.maxlen };
+
+ for code in &bucket.codes {
+ 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);
+ } 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);
+ add_esc_code(&mut escape_list, ckey, cval, bits - MAX_LUT_BITS, code.idx);
+ }
+ }
+
+ let cur_offset = bucket.offset;
+ for (ckey, sec_bucket) in &mut escape_list {
+ let key = *ckey as u32;
+ 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);
+ sec_bucket.offset = new_off as usize;
+ }
+
+ for (_, sec_bucket) in &escape_list {
+ build_esc_lut(table, mode, sec_bucket)?;
+ }
+
+ Ok(())
+}
+