extern crate alloc;
use alloc::vec::Vec;
use embark_format::Error;
use super::model::{LzmaModel, MATCH_MIN_LEN};
use super::rangecoder::RangeDecoder;
pub(crate) fn decode(
lc: u32,
lp: u32,
pb: u32,
stream: &[u8],
orig_len: usize,
) -> Result<Vec<u8>, Error> {
let mut rc = RangeDecoder::new(stream).ok_or(Error::Corrupt)?;
let mut model = LzmaModel::new(lc, lp, pb).ok_or(Error::Corrupt)?;
const EAGER: usize = 64 * 1024;
let mut out: Vec<u8> = Vec::new();
out.try_reserve(orig_len.min(EAGER))
.map_err(|_| Error::Corrupt)?;
let mut state = 0usize;
let (mut rep0, mut rep1, mut rep2, mut rep3) = (0u32, 0u32, 0u32, 0u32);
while out.len() < orig_len {
if rc.read_past > 0 {
return Err(Error::Truncated);
}
let pos_state = model.pos_state(out.len());
if model.decode_is_match(&mut rc, state, pos_state) == 0 {
let prev = out.last().copied().unwrap_or(0);
let match_byte = if state >= 7 {
let idx = out
.len()
.checked_sub(rep0 as usize + 1)
.ok_or(Error::Corrupt)?;
out[idx]
} else {
0
};
let byte = model.decode_literal(&mut rc, out.len(), prev, state, match_byte);
out.push(byte);
state = if state < 4 {
0
} else if state < 10 {
state - 3
} else {
state - 6
};
continue;
}
let len;
if model.decode_is_rep(&mut rc, state) != 0 {
if model.decode_is_rep_g0(&mut rc, state) == 0 {
if model.decode_is_rep0_long(&mut rc, state, pos_state) == 0 {
state = if state < 7 { 9 } else { 11 };
let idx = out
.len()
.checked_sub(rep0 as usize + 1)
.ok_or(Error::Corrupt)?;
let b = out[idx];
out.push(b);
continue;
}
} else {
let dist;
if model.decode_is_rep_g1(&mut rc, state) == 0 {
dist = rep1;
} else {
if model.decode_is_rep_g2(&mut rc, state) == 0 {
dist = rep2;
} else {
dist = rep3;
rep3 = rep2;
}
rep2 = rep1;
}
rep1 = rep0;
rep0 = dist;
}
len = model.decode_rep_len(&mut rc, pos_state) + MATCH_MIN_LEN;
state = if state < 7 { 8 } else { 11 };
} else {
rep3 = rep2;
rep2 = rep1;
rep1 = rep0;
let len_sym = model.decode_new_len(&mut rc, pos_state);
state = if state < 7 { 7 } else { 10 };
rep0 = model.decode_distance(&mut rc, len_sym);
if rep0 == 0xFFFF_FFFF {
return Err(Error::Corrupt);
}
len = len_sym + MATCH_MIN_LEN;
}
copy_match(&mut out, rep0, len, orig_len)?;
}
if rc.read_past > 0 {
return Err(Error::Truncated);
}
Ok(out)
}
fn copy_match(out: &mut Vec<u8>, rep0: u32, len: usize, orig_len: usize) -> Result<(), Error> {
let dist = rep0 as usize + 1;
if dist > out.len() {
return Err(Error::Corrupt);
}
if out.len() + len > orig_len {
return Err(Error::Corrupt);
}
let start = out.len() - dist;
for k in 0..len {
let b = out[start + k];
out.push(b);
}
Ok(())
}