use std::{
cell::Cell,
io::{self, Read, Write},
rc::Rc,
thread,
};
use crate::{Bzip2Encoder, Error, Result, decode::DEFAULT_MEMORY_LIMIT, gzip, lz4};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EncodeFormat {
Bzip2,
Gzip,
Lz4,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct EncodeReport {
pub format: EncodeFormat,
pub input_len: u64,
pub output_len: u64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct EncodeProgress {
pub input_bytes: u64,
pub output_bytes: u64,
}
#[derive(Clone, Copy, Debug)]
pub struct EncodeOptions {
pub threads: usize,
pub memory_limit: usize,
pub level: Option<u8>,
}
impl Default for EncodeOptions {
fn default() -> Self {
Self { threads: 0, memory_limit: DEFAULT_MEMORY_LIMIT, level: None }
}
}
impl EncodeOptions {
pub fn resolved_threads(self) -> usize {
if self.threads != 0 { self.threads } else { thread::available_parallelism().map(usize::from).unwrap_or(1) }
}
pub(crate) fn validate(self) -> Result<Self> {
if self.level.is_some_and(|level| !(1..=9).contains(&level)) {
return Err(Error::InvalidConfiguration("compression level must be between 1 and 9".into()));
}
if self.memory_limit == 0 {
return Err(Error::InvalidConfiguration("compression memory limit must be greater than zero".into()));
}
Ok(self)
}
pub(crate) fn level_or(self, default: u8) -> u8 {
self.level.unwrap_or(default)
}
}
pub enum Encoder<W: Write> {
Bzip2(Bzip2Encoder<W>),
Gzip(gzip::Encoder<W>),
Lz4(lz4::Encoder<W>),
}
impl<W: Write> Encoder<W> {
pub fn new(output: W, format: EncodeFormat, options: EncodeOptions) -> Result<Self> {
match format {
EncodeFormat::Bzip2 => Bzip2Encoder::new(output, options).map(Self::Bzip2),
EncodeFormat::Gzip => gzip::Encoder::new(output, options).map(Self::Gzip),
EncodeFormat::Lz4 => lz4::Encoder::new(output, options).map(Self::Lz4),
}
}
pub fn finish(self) -> Result<(W, EncodeReport)> {
match self {
Self::Bzip2(encoder) => encoder
.finish()
.map(|(output, report)| (output, EncodeReport { format: EncodeFormat::Bzip2, input_len: report.input_len, output_len: report.output_len })),
Self::Gzip(encoder) => encoder
.finish()
.map(|(output, report)| (output, EncodeReport { format: EncodeFormat::Gzip, input_len: report.input_len, output_len: report.output_len })),
Self::Lz4(encoder) => encoder
.finish()
.map(|(output, report)| (output, EncodeReport { format: EncodeFormat::Lz4, input_len: report.input_len, output_len: report.output_len })),
}
}
}
impl<W: Write> Write for Encoder<W> {
fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
match self {
Self::Bzip2(encoder) => encoder.write(bytes),
Self::Gzip(encoder) => encoder.write(bytes),
Self::Lz4(encoder) => encoder.write(bytes),
}
}
fn flush(&mut self) -> io::Result<()> {
match self {
Self::Bzip2(encoder) => encoder.flush(),
Self::Gzip(encoder) => encoder.flush(),
Self::Lz4(encoder) => encoder.flush(),
}
}
}
pub fn compress(data: &[u8], format: EncodeFormat, options: EncodeOptions) -> Result<Vec<u8>> {
let mut output = Vec::new();
compress_to_writer(&mut io::Cursor::new(data), &mut output, format, options)?;
Ok(output)
}
pub fn compress_to_writer(input: &mut impl Read, output: &mut impl Write, format: EncodeFormat, options: EncodeOptions) -> Result<EncodeReport> {
compress_to_writer_with_progress(input, output, format, options, |_| {})
}
struct CountingWriter<'a, W> {
inner: &'a mut W,
written: Rc<Cell<u64>>,
}
impl<W: Write> Write for CountingWriter<'_, W> {
fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
let written = self.inner.write(bytes)?;
self.written.set(self.written.get() + written as u64);
Ok(written)
}
fn flush(&mut self) -> io::Result<()> {
self.inner.flush()
}
}
pub fn compress_to_writer_with_progress(
input: &mut impl Read,
output: &mut impl Write,
format: EncodeFormat,
options: EncodeOptions,
mut progress: impl FnMut(EncodeProgress),
) -> Result<EncodeReport> {
let written = Rc::new(Cell::new(0));
let mut counted = CountingWriter { inner: output, written: Rc::clone(&written) };
let mut encoder = Encoder::new(&mut counted, format, options)?;
let mut buffer = vec![0_u8; 128 * 1024];
let mut input_bytes = 0_u64;
loop {
let read = input.read(&mut buffer)?;
if read == 0 {
break;
}
encoder.write_all(&buffer[..read])?;
input_bytes += read as u64;
progress(EncodeProgress { input_bytes, output_bytes: written.get() });
}
let (_, report) = encoder.finish()?;
progress(EncodeProgress { input_bytes: report.input_len, output_bytes: report.output_len });
Ok(report)
}