use crate::{workspace::checked_bytes, Error, Limits};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum Status {
NeedInput,
NeedOutput,
Done,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Progress {
pub consumed: usize,
pub written: usize,
pub status: Status,
}
pub struct IndexSequenceDecoder {
remaining: usize,
last: [u32; 2],
value: u32,
groups: u8,
header: bool,
padding: u8,
work_left: u64,
error: Option<Error>,
}
impl IndexSequenceDecoder {
pub fn new(index_count: usize, limits: Limits) -> Result<Self, Error> {
let bytes = checked_bytes(index_count, 4)?;
let work = u64::try_from(bytes).map_err(|_| Error::SizeOverflow)?;
let work_left = limits
.max_work
.checked_sub(work)
.ok_or(Error::LimitExceeded)?;
Ok(Self {
remaining: index_count,
last: [0; 2],
value: 0,
groups: 0,
header: false,
padding: 0,
work_left,
error: None,
})
}
#[inline]
pub fn push(&mut self, input: &[u8], output: &mut [u32]) -> Result<Progress, Error> {
self.push_generic::<u32>(input, output)
}
pub fn push_generic<I: crate::Index>(
&mut self,
input: &[u8],
output: &mut [I],
) -> Result<Progress, Error> {
if let Some(error) = self.error {
return Err(error);
}
let result = self.push_inner(input, output);
if let Err(error) = result {
self.error = Some(error);
}
result
}
fn push_inner<I: crate::Index>(
&mut self,
input: &[u8],
output: &mut [I],
) -> Result<Progress, Error> {
let mut consumed = 0;
let mut written = 0;
let status = loop {
if self.header && self.remaining == 0 && self.padding == 4 {
if consumed != input.len() {
return Err(Error::InvalidStream);
}
break Status::Done;
}
if self.header && self.remaining != 0 && written == output.len() {
break Status::NeedOutput;
}
let Some(&byte) = input.get(consumed) else {
break Status::NeedInput;
};
self.work_left = self.work_left.checked_sub(1).ok_or(Error::LimitExceeded)?;
consumed += 1;
if !self.header {
if byte & 0xf0 != 0xd0 {
return Err(Error::InvalidStream);
}
if byte & 0x0f > 1 {
return Err(Error::UnsupportedVersion);
}
self.header = true;
} else if self.remaining != 0 {
self.value |= u32::from(byte & 127) << (self.groups * 7);
self.groups += 1;
if byte < 128 || self.groups == 5 {
let baseline = (self.value & 1) as usize;
let value = self.value >> 1;
let delta = (value >> 1) ^ 0u32.wrapping_sub(value & 1);
let index = self.last[baseline].wrapping_add(delta);
self.last[baseline] = index;
output[written] = I::from_u32(index)?;
written += 1;
self.remaining -= 1;
self.value = 0;
self.groups = 0;
}
} else {
self.padding += 1;
}
};
Ok(Progress {
consumed,
written,
status,
})
}
pub fn finish(self) -> Result<(), Error> {
if let Some(error) = self.error {
Err(error)
} else if self.header && self.remaining == 0 && self.padding == 4 {
Ok(())
} else {
Err(Error::InvalidStream)
}
}
}