#[derive(Debug)]
pub(super) struct BitReader<'a> {
data: &'a [u8],
pos: usize,
buffer: u64,
count: u32,
overrun: bool,
}
impl<'a> BitReader<'a> {
pub(super) fn new(data: &'a [u8]) -> Self {
Self {
data,
pos: 0,
buffer: 0,
count: 0,
overrun: false,
}
}
fn refill(&mut self) {
while self.count <= 56 {
let Some(&byte) = self.data.get(self.pos) else {
break;
};
self.buffer |= u64::from(byte) << self.count;
self.pos += 1;
self.count += 8;
}
}
pub(super) fn peek(&mut self, count: u32) -> u32 {
debug_assert!(count <= 32);
if self.count < count {
self.refill();
}
(self.buffer & ((1u64 << count) - 1)) as u32
}
pub(super) fn consume(&mut self, count: u32) {
if count > self.count {
self.refill();
}
if count > self.count {
self.overrun = true;
self.buffer = 0;
self.count = 0;
} else {
self.buffer >>= count;
self.count -= count;
}
}
pub(super) fn read(&mut self, count: u32) -> u32 {
let value = self.peek(count);
self.consume(count);
value
}
pub(super) fn read_usize(&mut self, count: u32) -> usize {
self.read(count) as usize
}
pub(super) fn flag(&mut self) -> bool {
self.read(1) == 1
}
pub(super) fn is_overrun(&self) -> bool {
self.overrun
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bits_come_least_significant_first() {
let mut reader = BitReader::new(&[0b1010_1101, 0xFF]);
assert_eq!(reader.read(1), 1);
assert_eq!(reader.read(3), 0b110);
assert_eq!(reader.peek(8), 0b1111_1010);
assert_eq!(reader.read(12), 0xFFA);
assert!(!reader.is_overrun());
}
#[test]
fn reading_past_the_end_reads_zeros_and_is_noticed() {
let mut reader = BitReader::new(&[0xFF]);
assert_eq!(reader.read(4), 0xF);
assert_eq!(reader.peek(8), 0xF);
assert!(!reader.is_overrun());
assert_eq!(reader.read(8), 0xF);
assert!(reader.is_overrun());
assert_eq!(reader.read(3), 0);
}
}