zexc 0.1.0

zex native lossless compressor — CLI zexc, library zexc, files *.zex
Documentation
//! Hybrid backend: try LZ4 (fast) and Zstd-style (ratio), keep the smaller block.
//!
//! Heuristics (inspired by adaptive compressors / zstd's strategy switching):
//! - Very small blocks → raw or LZ4 only
//! - High-entropy-looking data → prefer LZ4 (or raw if expands)
//! - Low level (1–2) → LZ4 only
//! - High level (≥ 12) → Zstd-style only
//! - Mid levels → race both, pick winner by compressed size

use crate::algorithms::{lz4, zstd_backend};
use crate::format::block::BlockType;
use crate::Result;

/// Compress one block using hybrid selection.
pub fn compress_block(src: &[u8], level: u8) -> Result<(BlockType, Vec<u8>)> {
    if src.is_empty() {
        return Ok((BlockType::Raw, Vec::new()));
    }

    // Tiny: store raw (LZ4/Zstd overhead not worth it)
    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))
            }
        }
        _ => {
            // Race both backends
            let lz = lz4::compress(src, level)?;
            let zs = zstd_backend::compress(src, level)?;

            // Prefer the smaller; tie-break toward LZ4 (faster decode)
            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))
            }
        }
    }
}

/// Decompress a hybrid-selected block by type.
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());
        }
    }
}