use crate::error::Error;
pub struct BitReader<'a> {
data: &'a [u8],
byte_pos: usize,
bits_left: u32,
accum: u64,
}
impl<'a> BitReader<'a> {
pub fn new(data: &'a [u8]) -> Self {
let mut reader = Self {
data,
byte_pos: 0,
bits_left: 0,
accum: 0,
};
reader.refill();
reader
}
#[inline]
fn refill(&mut self) {
while self.bits_left <= 56 && self.byte_pos < self.data.len() {
self.accum |= (self.data[self.byte_pos] as u64) << (56 - self.bits_left);
self.byte_pos += 1;
self.bits_left += 8;
}
}
#[inline]
pub fn read_bits(&mut self, n: u32) -> Result<u32, Error> {
debug_assert!(n <= 32);
if n == 0 {
return Ok(0);
}
if self.bits_left < n {
self.refill();
if self.bits_left < n {
return Err(Error::UnexpectedEof);
}
}
let val = (self.accum >> (64 - n)) as u32;
self.accum <<= n;
self.bits_left -= n;
Ok(val)
}
#[inline]
pub fn read_bit(&mut self) -> Result<u8, Error> {
Ok(self.read_bits(1)? as u8)
}
#[inline]
pub fn read_bool(&mut self) -> Result<bool, Error> {
Ok(self.read_bits(1)? != 0)
}
#[inline]
pub fn read_u8(&mut self) -> Result<u8, Error> {
Ok(self.read_bits(8)? as u8)
}
#[inline]
pub fn read_u16(&mut self) -> Result<u16, Error> {
Ok(self.read_bits(16)? as u16)
}
#[inline]
pub fn read_u32(&mut self) -> Result<u32, Error> {
self.read_bits(32)
}
pub fn bits_consumed(&self) -> usize {
self.byte_pos * 8 - self.bits_left as usize
}
pub fn is_empty(&self) -> bool {
self.bits_left == 0 && self.byte_pos >= self.data.len()
}
}
pub struct BitWriter<'a> {
data: &'a mut [u8],
byte_pos: usize,
accum: u8,
bits_used: u32,
}
impl<'a> BitWriter<'a> {
pub fn new(data: &'a mut [u8]) -> Self {
Self {
data,
byte_pos: 0,
accum: 0,
bits_used: 0,
}
}
#[inline]
fn flush_byte(&mut self) -> Result<(), Error> {
if self.byte_pos >= self.data.len() {
return Err(Error::OutputOverflow);
}
self.data[self.byte_pos] = self.accum;
self.byte_pos += 1;
self.accum = 0;
self.bits_used = 0;
Ok(())
}
pub fn write_bits(&mut self, n: u32, val: u32) -> Result<(), Error> {
debug_assert!(n <= 32);
if n == 0 {
return Ok(());
}
let mut remaining = n;
let mut value = val;
while remaining > 0 {
let space = 8 - self.bits_used;
let chunk = if remaining < space { remaining } else { space };
let shift = remaining - chunk;
let bits = ((value >> shift) & ((1 << chunk) - 1)) as u8;
value &= (1u32 << shift).wrapping_sub(1);
self.accum |= bits << (space - chunk);
self.bits_used += chunk;
remaining -= chunk;
if self.bits_used == 8 {
self.flush_byte()?;
}
}
Ok(())
}
#[inline]
pub fn write_bit(&mut self, bit: u8) -> Result<(), Error> {
self.write_bits(1, bit as u32)
}
#[inline]
pub fn write_bool(&mut self, val: bool) -> Result<(), Error> {
self.write_bits(1, val as u32)
}
#[inline]
pub fn write_u8(&mut self, val: u8) -> Result<(), Error> {
self.write_bits(8, val as u32)
}
#[inline]
pub fn write_u16(&mut self, val: u16) -> Result<(), Error> {
self.write_bits(16, val as u32)
}
#[inline]
pub fn write_u32(&mut self, val: u32) -> Result<(), Error> {
self.write_bits(32, val)
}
pub fn finish(mut self) -> Result<usize, Error> {
if self.bits_used > 0 {
self.flush_byte()?;
}
Ok(self.byte_pos)
}
pub fn bytes_written(&self) -> usize {
self.byte_pos
}
pub fn bits_written(&self) -> usize {
self.byte_pos * 8 + self.bits_used as usize
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn roundtrip_bits() {
let mut buf = [0u8; 16];
{
let mut w = BitWriter::new(&mut buf);
w.write_bits(3, 0b101).unwrap();
w.write_bits(5, 0b01100).unwrap();
w.write_bits(8, 0xFF).unwrap();
w.write_bits(1, 1).unwrap();
w.finish().unwrap();
}
let mut r = BitReader::new(&buf);
assert_eq!(r.read_bits(3).unwrap(), 0b101);
assert_eq!(r.read_bits(5).unwrap(), 0b01100);
assert_eq!(r.read_bits(8).unwrap(), 0xFF);
assert_eq!(r.read_bits(1).unwrap(), 1);
}
#[test]
fn roundtrip_32bit() {
let mut buf = [0u8; 8];
{
let mut w = BitWriter::new(&mut buf);
w.write_u32(0xDEADBEEF).unwrap();
w.finish().unwrap();
}
let mut r = BitReader::new(&buf);
assert_eq!(r.read_u32().unwrap(), 0xDEADBEEF);
}
}