use crate::bitio::BitWriter;
use crate::bwt;
use crate::constants::*;
use crate::crc::{self, Crc32};
use crate::error::Error;
use crate::huffman::{self, HuffTables};
use crate::mtf;
use crate::rle1;
use crate::rle2;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CompressStatus {
Ok,
BlockFull,
Finished,
}
pub struct Compressor {
block_size_100k: u8,
max_block_size: usize,
}
impl Compressor {
pub fn new(block_size_100k: u8) -> Self {
Self {
block_size_100k,
max_block_size: block_size_100k as usize * BLOCK_SIZE_UNIT,
}
}
pub fn compress_block(&mut self, input: &[u8], output: &mut [u8]) -> Result<usize, Error> {
let mut writer = BitWriter::new(output);
writer.write_u8(STREAM_MAGIC[0])?;
writer.write_u8(STREAM_MAGIC[1])?;
writer.write_u8(STREAM_VERSION)?;
writer.write_u8(BLOCK_SIZE_CHAR_BASE + self.block_size_100k)?;
let mut stream_crc = 0u32;
let mut pos = 0;
while pos < input.len() {
let end = (pos + self.max_block_size).min(input.len());
let block_data = &input[pos..end];
let block_crc = self.write_block(block_data, &mut writer)?;
stream_crc = crc::combine_crcs(stream_crc, block_crc);
pos = end;
}
writer.write_bits(24, (EOS_MAGIC >> 24) as u32)?;
writer.write_bits(24, (EOS_MAGIC & 0xFF_FFFF) as u32)?;
writer.write_u32(stream_crc)?;
writer.finish()
}
fn write_block(&self, data: &[u8], writer: &mut BitWriter) -> Result<u32, Error> {
let n = data.len();
if n == 0 {
return Ok(0);
}
let mut crc = Crc32::new();
crc.update(data);
let block_crc = crc.finish();
const MAX_STACK_BLOCK: usize = 32_768;
const MAX_RLE1_BUF: usize = MAX_STACK_BLOCK * RLE1_OVERHEAD_NUM / RLE1_OVERHEAD_DEN;
if n > MAX_STACK_BLOCK {
return self.write_block_inner(data, n, block_crc, writer);
}
let mut rle1_buf = [0u8; MAX_RLE1_BUF];
let rle1_len = rle1::encode(data, &mut rle1_buf)?;
self.write_block_inner(&rle1_buf[..rle1_len], rle1_len, block_crc, writer)
}
fn write_block_inner(
&self,
rle1_data: &[u8],
rle1_len: usize,
block_crc: u32,
writer: &mut BitWriter,
) -> Result<u32, Error> {
writer.write_bits(24, (BLOCK_MAGIC >> 24) as u32)?;
writer.write_bits(24, (BLOCK_MAGIC & 0xFF_FFFF) as u32)?;
writer.write_u32(block_crc)?;
writer.write_bit(0)?;
const MAX_BWT_BLOCK: usize = 32_768;
if rle1_len > MAX_BWT_BLOCK {
return Err(Error::BlockFull);
}
let mut bwt_output = [0u8; MAX_BWT_BLOCK];
let mut indices = [0u32; MAX_BWT_BLOCK];
let primary_index = bwt::forward(
&rle1_data[..rle1_len],
&mut bwt_output,
&mut indices,
)?;
writer.write_bits(24, primary_index)?;
let mut in_use = [false; ALPHABET_SIZE];
for &b in &bwt_output[..rle1_len] {
in_use[b as usize] = true;
}
let mut group_mask = 0u16;
for g in 0..16 {
for i in 0..16 {
if in_use[g * 16 + i] {
group_mask |= 1 << (15 - g);
break;
}
}
}
writer.write_u16(group_mask)?;
for g in 0..16 {
if group_mask & (1 << (15 - g)) != 0 {
let mut sym_mask = 0u16;
for i in 0..16 {
if in_use[g * 16 + i] {
sym_mask |= 1 << (15 - i);
}
}
writer.write_u16(sym_mask)?;
}
}
let n_in_use = in_use.iter().filter(|&&b| b).count();
let mut mtf_output = [0u8; MAX_BWT_BLOCK];
mtf::encode(&bwt_output[..rle1_len], &mut mtf_output, &in_use);
let mut symbols = [0u16; MAX_BWT_BLOCK + 256];
let n_symbols_total = n_in_use + 2; let sym_count = rle2::encode(
&mtf_output[..rle1_len],
&mut symbols,
n_in_use,
);
let mut freq = [0u32; MAX_SYMBOLS];
for i in 0..sym_count {
freq[symbols[i] as usize] += 1;
}
let mut huff_tables = HuffTables::new();
huffman::generate_tables(&freq, n_symbols_total, &mut huff_tables);
let n_groups = huff_tables.n_groups;
let n_selectors = (sym_count + GROUP_SIZE - 1) / GROUP_SIZE;
writer.write_bits(3, n_groups as u32)?;
writer.write_bits(15, n_selectors as u32)?;
let selectors = [0u8; 8192];
huffman::write_selectors(writer, &selectors, n_selectors, n_groups)?;
huffman::write_tables(writer, &huff_tables)?;
let table = &huff_tables.tables[0];
for i in 0..sym_count {
let sym = symbols[i] as usize;
let code = table.codes[sym];
let len = table.lengths[sym] as u32;
writer.write_bits(len, code)?;
}
Ok(block_crc)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn compress_small() {
let input = b"hello world";
let mut output = [0u8; 256];
let mut comp = Compressor::new(1);
let n = comp.compress_block(input, &mut output).unwrap();
assert!(n > 0);
assert_eq!(output[0], b'B');
assert_eq!(output[1], b'Z');
assert_eq!(output[2], b'h');
assert_eq!(output[3], b'1'); }
}