const DELTA4: [i16; 16] = [-9, -8, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 8];
pub fn decompress(chunk: &[u8]) -> Vec<u8> {
let mut samples = Vec::new();
decompress_into(chunk, &mut samples);
samples
}
pub fn decompress_into(chunk: &[u8], out: &mut Vec<u8>) {
let Some((header, mut src)) = chunk.split_first_chunk::<4>() else {
return;
};
let out_size = usize::from(u16::from_le_bytes([header[0], header[1]]));
let in_size = usize::from(u16::from_le_bytes([header[2], header[3]]));
if in_size == out_size {
out.extend_from_slice(&src[..out_size.min(src.len())]);
return;
}
out.reserve(out_size);
let end = out.len() + out_size;
let mut sample: u8 = 0x80;
while out.len() < end {
let Some((&command, rest)) = src.split_first() else {
break;
};
src = rest;
let count = usize::from(command & 0x3f);
match command >> 6 {
0 => {
let Some(bytes) = src.get(..count + 1) else {
break;
};
src = &src[count + 1..];
for &byte in bytes {
for shift in [0, 2, 4, 6] {
sample = saturating(sample, i16::from(byte >> shift & 3) - 2);
out.push(sample);
}
}
}
1 => {
let Some(bytes) = src.get(..count + 1) else {
break;
};
src = &src[count + 1..];
for &byte in bytes {
for nibble in [byte & 0xf, byte >> 4] {
sample = saturating(sample, DELTA4[usize::from(nibble)]);
out.push(sample);
}
}
}
2 if count & 0x20 != 0 => {
sample = sample.wrapping_add_signed((command << 3) as i8 >> 3);
out.push(sample);
}
2 => {
let Some(raw) = src.get(..count + 1) else {
break;
};
src = &src[count + 1..];
out.extend_from_slice(raw);
sample = raw[count];
}
_ => out.resize(out.len() + count + 1, sample),
}
}
out.truncate(end);
}
fn saturating(sample: u8, delta: i16) -> u8 {
(i16::from(sample) + delta).clamp(0, 255) as u8
}
#[cfg(test)]
mod tests {
use super::*;
fn chunk(out_size: u16, in_size: u16, data: &[u8]) -> Vec<u8> {
let mut chunk = out_size.to_le_bytes().to_vec();
chunk.extend(in_size.to_le_bytes());
chunk.extend(data);
chunk
}
#[test]
fn equal_sizes_mean_raw_samples() {
assert_eq!(decompress(&chunk(3, 3, &[1, 2, 250])), [1, 2, 250]);
}
#[test]
fn two_bit_deltas_come_low_bits_first() {
let samples = decompress(&chunk(4, 2, &[0x00, 0b11_10_01_00]));
assert_eq!(samples, [0x7e, 0x7d, 0x7d, 0x7e]);
}
#[test]
fn four_bit_deltas_come_low_nibble_first() {
let samples = decompress(&chunk(4, 3, &[0x41, 0xf0, 0x87]));
assert_eq!(samples, [0x77, 0x7f, 0x7e, 0x7e]);
}
#[test]
fn big_deltas_are_five_bit_signed() {
let samples = decompress(&chunk(2, 2 + 1, &[0xaf, 0xb0]));
assert_eq!(samples, [0x8f, 0x7f]);
}
#[test]
fn big_deltas_wrap_around() {
let samples = decompress(&chunk(4, 5, &[0x80, 250, 0xaf, 0x80, 5, 0xb0]));
assert_eq!(samples, [250, 9, 5, 245]);
}
#[test]
fn raw_runs_set_the_prediction() {
let samples = decompress(&chunk(4, 5, &[0x82, 10, 20, 30, 0xa1]));
assert_eq!(samples, [10, 20, 30, 31]);
}
#[test]
fn repeats_copy_the_current_sample() {
assert_eq!(decompress(&chunk(4, 2, &[0xa3, 0xc2])), [0x83; 4]);
}
#[test]
fn deltas_saturate_at_0_and_255() {
let samples = decompress(&chunk(6, 8, &[0x80, 250, 0x40, 0xff, 0x80, 5, 0x40, 0x00]));
assert_eq!(samples, [250, 255, 255, 5, 0, 0]);
}
#[test]
fn decompress_into_appends_and_cuts_off_relative_to_its_start() {
let mut samples = vec![9, 9];
decompress_into(&chunk(3, 2, &[0x00, 0xff]), &mut samples);
assert_eq!(samples, [9, 9, 0x81, 0x82, 0x83]);
decompress_into(&chunk(2, 2, &[7, 8]), &mut samples);
assert_eq!(samples, [9, 9, 0x81, 0x82, 0x83, 7, 8]);
}
#[test]
fn every_command_missing_its_data_ends_the_chunk() {
assert_eq!(decompress(&chunk(5, 3, &[0xa1, 0x01, 0xff])), [0x81]);
assert_eq!(decompress(&chunk(5, 3, &[0xa1, 0x41, 0x12])), [0x81]);
assert_eq!(decompress(&chunk(5, 3, &[0xa1, 0x82, 1, 2])), [0x81]);
}
#[test]
fn cuts_off_at_the_output_size_and_stops_at_the_end_of_the_data() {
assert_eq!(decompress(&chunk(3, 2, &[0x00, 0xff])), [0x81, 0x82, 0x83]);
assert_eq!(decompress(&chunk(3, 2, &[0xa1, 0xc5])), [0x81; 3]);
assert_eq!(decompress(&chunk(2, 1, &[0x40])), []);
assert_eq!(decompress(&[0, 0, 0]), []);
}
}