use bytes::Bytes;
use super::{BlockCodec, Codec, Decoded};
use crate::budget::DecodeBuf;
use crate::error::Error;
#[derive(Clone, Copy, Debug, Default)]
pub struct Lz4;
const _: () = crate::send_sync::<Lz4>();
impl BlockCodec for Lz4 {
fn decode(
&self,
input: &Bytes,
uncompressed: u32,
out: &mut DecodeBuf,
) -> Result<Decoded, Error> {
let fail = |detail: String| Error::Decompress {
codec: Codec::Lz4,
detail: detail.into(),
};
let Ok(capacity) = i32::try_from(uncompressed) else {
return Err(fail(
"OverflowError: signed integer is greater than maximum".to_owned(),
));
};
if i32::try_from(input.len()).is_err() {
return Err(fail(
"OverflowError: Input too large for LZ4 API".to_owned(),
));
}
let capacity = usize::try_from(capacity).unwrap_or(0);
let lz4_error = |at: usize| {
fail(format!(
"LZ4BlockError: Decompression failed: corrupt input or insufficient space in \
destination buffer. Error code: {}",
at.saturating_add(1)
))
};
let n = lz4_run(input, capacity, None).map_err(lz4_error)?;
let dst = out.grow_zeroed(n)?;
lz4_run(input, capacity, Some(dst)).map_err(lz4_error)?;
Ok(Decoded::Written)
}
}
const MINMATCH: usize = 4;
const LASTLITERALS: usize = 5;
const MFLIMIT: usize = 12;
const FASTLOOP_SAFE_DISTANCE: usize = 64;
const ML_MASK: usize = 15;
const RUN_MASK: usize = 15;
fn read_variable_length(
src: &[u8],
ip: &mut usize,
limit: isize,
initial_check: bool,
) -> Option<usize> {
let past = |ip: usize| isize::try_from(ip).map_or(true, |i| i > limit);
if initial_check && isize::try_from(*ip).map_or(true, |i| i >= limit) {
return None;
}
let mut length = 0usize;
loop {
let s = *src.get(*ip)?;
*ip += 1;
length = length.saturating_add(usize::from(s));
if past(*ip) {
return None;
}
if s != 255 {
return Some(length);
}
}
}
fn copy_match(dst: &mut [u8], op: usize, offset: usize, length: usize) {
let end = op.saturating_add(length).min(dst.len());
if offset == 0 {
if let Some(d) = dst.get_mut(op..end) {
d.fill(0);
}
return;
}
let Some(src) = op.checked_sub(offset) else {
return;
};
let mut at = op;
while at < end {
let step = (at - src).min(end - at);
dst.copy_within(src..src + step, at);
at += step;
}
}
struct Lz4State<'a, 'o> {
src: &'a [u8],
dst: Option<&'o mut [u8]>,
ip: usize,
op: usize,
iend: isize,
oend: isize,
}
enum Lz4Entry {
Top,
Literals(usize, usize),
Match(usize, usize),
}
fn signed(n: usize) -> isize {
isize::try_from(n).unwrap_or(isize::MAX)
}
impl Lz4State<'_, '_> {
fn token(&mut self) -> Result<usize, usize> {
let t = self.src.get(self.ip).copied().ok_or(self.ip)?;
self.ip += 1;
Ok(usize::from(t))
}
fn le16(&mut self) -> Result<usize, usize> {
let b = self
.src
.get(self.ip..self.ip.saturating_add(2))
.and_then(|b| <[u8; 2]>::try_from(b).ok())
.ok_or(self.ip)?;
self.ip += 2;
Ok(usize::from(u16::from_le_bytes(b)))
}
fn varlen(&mut self, limit: isize, initial_check: bool) -> Result<usize, usize> {
read_variable_length(self.src, &mut self.ip, limit, initial_check).ok_or(self.ip)
}
fn literals(&mut self, n: usize) {
if let (Some(d), Some(from)) = (
self.dst.as_deref_mut(),
self.src.get(self.ip..self.ip.saturating_add(n)),
) && let Some(to) = d.get_mut(self.op..self.op.saturating_add(n))
{
to.copy_from_slice(from);
}
self.ip = self.ip.saturating_add(n);
self.op = self.op.saturating_add(n);
}
fn copy(&mut self, offset: usize, n: usize) {
if let Some(d) = self.dst.as_deref_mut() {
copy_match(d, self.op, offset, n);
}
self.op = self.op.saturating_add(n);
}
fn match_length(&mut self, mlen: usize) -> Result<usize, usize> {
let mut length = mlen;
if length == ML_MASK {
length += self.varlen(self.iend - signed(LASTLITERALS) + 1, false)?;
}
Ok(length + MINMATCH)
}
fn safe_literals(
&mut self,
token: usize,
length: usize,
) -> Result<Option<(usize, usize)>, usize> {
let cpy = signed(self.op).saturating_add(signed(length));
let lit_end = signed(self.ip).saturating_add(signed(length));
if cpy > self.oend - signed(MFLIMIT) || lit_end > self.iend - signed(2 + 1 + LASTLITERALS) {
if lit_end != self.iend || cpy > self.oend {
return Err(self.ip);
}
self.literals(length);
return Ok(None);
}
self.literals(length);
let offset = self.le16()?;
let length = self.match_length(token & ML_MASK)?;
Ok(Some((offset, length)))
}
fn fast_loop(&mut self) -> Result<Lz4Entry, usize> {
loop {
let token = self.token()?;
let mut length = token >> 4;
if length == RUN_MASK {
length += self.varlen(self.iend - signed(RUN_MASK), true)?;
if signed(self.op).saturating_add(signed(length)) > self.oend - 32
|| signed(self.ip).saturating_add(signed(length)) > self.iend - 32
{
return Ok(Lz4Entry::Literals(token, length));
}
} else if signed(self.ip) > self.iend - (16 + 1) {
return Ok(Lz4Entry::Literals(token, length));
}
self.literals(length);
let offset = self.le16()?;
let mut length = token & ML_MASK;
if length == ML_MASK {
length += self.varlen(self.iend - signed(LASTLITERALS) + 1, false)? + MINMATCH;
if offset > self.op {
return Err(self.ip);
}
} else {
length += MINMATCH;
}
if signed(self.op).saturating_add(signed(length))
>= self.oend - signed(FASTLOOP_SAFE_DISTANCE)
{
return Ok(Lz4Entry::Match(offset, length));
}
if offset > self.op {
return Err(self.ip);
}
self.copy(offset, length);
}
}
fn safe_loop(&mut self, mut entry: Lz4Entry) -> Result<usize, usize> {
let short_in = self.iend - 14 - 2;
let short_out = self.oend - 14 - 18;
loop {
let (offset, length) = match std::mem::replace(&mut entry, Lz4Entry::Top) {
Lz4Entry::Match(offset, length) => (offset, length),
Lz4Entry::Literals(token, length) => match self.safe_literals(token, length)? {
Some(m) => m,
None => return Ok(self.op),
},
Lz4Entry::Top => {
let token = self.token()?;
let mut length = token >> 4;
if length != RUN_MASK
&& signed(self.ip) < short_in
&& signed(self.op) <= short_out
{
self.literals(length);
let mlen = token & ML_MASK;
let offset = self.le16()?;
if mlen != ML_MASK && offset >= 8 && offset <= self.op {
self.copy(offset, mlen + MINMATCH);
continue;
}
(offset, self.match_length(mlen)?)
} else {
if length == RUN_MASK {
length += self.varlen(self.iend - signed(RUN_MASK), true)?;
}
match self.safe_literals(token, length)? {
Some(m) => m,
None => return Ok(self.op),
}
}
}
};
if offset > self.op {
return Err(self.ip);
}
if signed(self.op).saturating_add(signed(length)) > self.oend - signed(LASTLITERALS) {
return Err(self.ip);
}
self.copy(offset, length);
}
}
}
fn lz4_run(src: &[u8], output_size: usize, dst: Option<&mut [u8]>) -> Result<usize, usize> {
if output_size == 0 {
return if src == [0] { Ok(0) } else { Err(0) };
}
if src.is_empty() {
return Err(0);
}
let mut st = Lz4State {
src,
dst,
ip: 0,
op: 0,
iend: signed(src.len()),
oend: signed(output_size),
};
let entry = if st.oend >= signed(FASTLOOP_SAFE_DISTANCE) {
st.fast_loop()?
} else {
Lz4Entry::Top
};
st.safe_loop(entry)
}