use crate::algorithms::{lz4, zstd_backend};
use crate::format::block::BlockType;
use crate::Result;
pub fn compress_block(src: &[u8], level: u8) -> Result<(BlockType, Vec<u8>)> {
if src.is_empty() {
return Ok((BlockType::Raw, Vec::new()));
}
if src.len() < 32 {
return Ok((BlockType::Raw, src.to_vec()));
}
let level = level.clamp(1, 22);
match level {
1..=2 => {
let c = lz4::compress(src, level)?;
if c.len() >= src.len() {
Ok((BlockType::Raw, src.to_vec()))
} else {
Ok((BlockType::Lz4, c))
}
}
12..=22 => {
let c = zstd_backend::compress(src, level)?;
if c.len() >= src.len() {
Ok((BlockType::Raw, src.to_vec()))
} else {
Ok((BlockType::Zstd, c))
}
}
_ => {
let lz = lz4::compress(src, level)?;
let zs = zstd_backend::compress(src, level)?;
let (ty, c) = if zs.len() + 1 < lz.len() {
(BlockType::Zstd, zs)
} else {
(BlockType::Lz4, lz)
};
if c.len() >= src.len() {
Ok((BlockType::Raw, src.to_vec()))
} else {
Ok((ty, c))
}
}
}
}
pub fn decompress_block(
block_type: BlockType,
src: &[u8],
uncompressed_size: usize,
) -> Result<Vec<u8>> {
match block_type {
BlockType::Raw => {
if src.len() != uncompressed_size {
return Err(crate::Error::SizeMismatch {
expected: uncompressed_size as u64,
actual: src.len() as u64,
});
}
Ok(src.to_vec())
}
BlockType::Lz4 => lz4::decompress(src, uncompressed_size),
BlockType::Zstd => zstd_backend::decompress(src, uncompressed_size),
BlockType::End => Err(crate::Error::CorruptBlock("end block has no payload".into())),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hybrid_roundtrip() {
let src = b"hybrid hybrid hybrid selection test data 0123456789".repeat(20);
for level in [1u8, 3, 9, 15] {
let (ty, c) = compress_block(&src, level).unwrap();
assert_ne!(ty, BlockType::End);
let d = decompress_block(ty, &c, src.len()).unwrap();
assert_eq!(d, src.as_slice());
}
}
}