use alloc::vec::Vec;
#[derive(Debug, Default)]
pub struct BitWriter {
buf: Vec<u8>,
acc: u64,
nbits: u32,
}
impl BitWriter {
pub fn new() -> Self {
Self::default()
}
pub fn with_capacity(cap: usize) -> Self {
Self {
buf: Vec::with_capacity(cap),
acc: 0,
nbits: 0,
}
}
#[inline]
pub fn write_bits(&mut self, value: u32, n: u32) {
debug_assert!(n <= 32);
if n == 0 {
return;
}
let mask = if n == 32 { u32::MAX } else { (1u32 << n) - 1 };
self.acc |= u64::from(value & mask) << self.nbits;
self.nbits += n;
while self.nbits >= 8 {
self.buf.push(self.acc as u8);
self.acc >>= 8;
self.nbits -= 8;
}
}
#[inline]
pub fn write_bit(&mut self, bit: bool) {
self.write_bits(u32::from(bit), 1);
}
pub fn align_byte(&mut self) {
if self.nbits > 0 {
self.buf.push(self.acc as u8);
self.acc = 0;
self.nbits = 0;
}
}
pub fn finish(mut self) -> Vec<u8> {
self.align_byte();
self.buf
}
pub fn len(&self) -> usize {
self.buf.len()
}
pub fn is_empty(&self) -> bool {
self.buf.is_empty() && self.nbits == 0
}
pub fn as_bytes(&self) -> &[u8] {
&self.buf
}
}
#[derive(Debug, Clone)]
pub struct BitReader<'a> {
data: &'a [u8],
pos: usize,
acc: u64,
nbits: u32,
}
impl<'a> BitReader<'a> {
pub fn new(data: &'a [u8]) -> Self {
Self {
data,
pos: 0,
acc: 0,
nbits: 0,
}
}
#[inline]
fn refill(&mut self) {
while self.nbits <= 56 && self.pos < self.data.len() {
self.acc |= u64::from(self.data[self.pos]) << self.nbits;
self.nbits += 8;
self.pos += 1;
}
}
#[inline]
pub fn read_bits(&mut self, n: u32) -> Option<u32> {
debug_assert!(n <= 32);
if n == 0 {
return Some(0);
}
self.refill();
if self.nbits < n {
return None;
}
let mask = if n == 32 { u32::MAX } else { (1u32 << n) - 1 };
let v = (self.acc as u32) & mask;
self.acc >>= n;
self.nbits -= n;
Some(v)
}
#[inline]
pub fn peek_bits(&mut self, n: u32) -> Option<u32> {
debug_assert!(n <= 32);
if n == 0 {
return Some(0);
}
self.refill();
if self.nbits < n {
return None;
}
let mask = if n == 32 { u32::MAX } else { (1u32 << n) - 1 };
Some((self.acc as u32) & mask)
}
#[inline]
pub fn peek_bits_padded(&mut self, n: u32) -> Option<u32> {
debug_assert!(n <= 32);
if n == 0 {
return Some(0);
}
self.refill();
if self.nbits == 0 && self.pos >= self.data.len() {
return None;
}
let mask = if n == 32 { u32::MAX } else { (1u32 << n) - 1 };
Some((self.acc as u32) & mask)
}
#[inline]
pub fn ensure_bits(&mut self) {
self.refill();
}
pub fn bits_available(&self) -> u32 {
self.nbits
}
#[inline]
pub fn read_bit(&mut self) -> Option<bool> {
self.read_bits(1).map(|b| b != 0)
}
pub fn align_byte(&mut self) {
let rem = self.nbits % 8;
if rem != 0 {
self.acc >>= rem;
self.nbits -= rem;
}
}
pub fn remaining_bytes(&self) -> usize {
self.data.len().saturating_sub(self.pos)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bit_roundtrip() {
let mut w = BitWriter::new();
w.write_bits(0b1011, 4);
w.write_bits(0xAB, 8);
w.write_bits(0x1234, 16);
w.write_bit(true);
let bytes = w.finish();
let mut r = BitReader::new(&bytes);
assert_eq!(r.read_bits(4).unwrap(), 0b1011);
assert_eq!(r.read_bits(8).unwrap(), 0xAB);
assert_eq!(r.read_bits(16).unwrap(), 0x1234);
assert!(r.read_bit().unwrap());
}
}