mod codes;
mod fast;
mod matcher;
mod medium;
mod options;
mod output;
mod plain;
mod quick;
mod rows;
mod slow;
mod stored;
mod trees;
mod window;
pub use options::{InvalidMemoryLevel, MemoryLevel, Options, Strategy};
pub(crate) use output::Output;
pub(crate) use rows::{RowSource, Rows, rows};
use pltrs_core::alloc::OutOfMemory;
use self::options::{Config, Method};
use self::trees::{Symbols, Trees};
use self::window::Window;
use crate::checksum::Adler32;
use crate::deflate::CompressionLevel;
const MIN_MATCH: u32 = 3;
const MAX_MATCH: u32 = 258;
const WANT_MIN_MATCH: u32 = 4;
const MIN_LOOKAHEAD: u32 = MAX_MATCH + MIN_MATCH + 1;
const W_SIZE: u32 = 1 << 15;
const W_MASK: u32 = W_SIZE - 1;
const MAX_DIST: u32 = W_SIZE - MIN_LOOKAHEAD;
const WINDOW_SIZE: u32 = 2 * W_SIZE;
const MAX_STORED: u32 = 65_535;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Wrap {
Raw,
Zlib,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Flush {
None,
Finish,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum BlockState {
NeedMore,
FinishStarted,
FinishDone,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Status {
Init,
Busy,
Finished,
}
#[derive(Debug)]
pub(crate) struct Deflater {
level: u8,
strategy: Strategy,
config: Config,
wrap: Wrap,
status: Status,
trailer_written: bool,
win: Window,
strstart: u32,
block_start: i64,
lookahead: u32,
match_start: u32,
prev_length: u32,
prev_match: u32,
match_available: bool,
ins_h: u32,
syms: Symbols,
trees: Trees,
block_open: u8,
pending_buf_size: usize,
adler: Adler32,
}
impl Deflater {
pub(crate) fn new(options: Options, wrap: Wrap) -> Result<Self, OutOfMemory> {
let syms = Symbols::new(options.memory_level.symbol_buffer())?;
Ok(Self::with_tables(
options,
wrap,
Window::new()?,
syms,
Trees::new(),
))
}
pub(crate) fn restart(
self,
options: Options,
wrap: Wrap,
len: usize,
) -> Result<Self, OutOfMemory> {
let Self {
mut win,
syms,
trees,
..
} = self;
win.restart(len);
let symbol_buffer = options.memory_level.symbol_buffer();
let syms = if syms.capacity() == symbol_buffer {
syms.cleared()
} else {
Symbols::new(symbol_buffer)?
};
Ok(Self::with_tables(options, wrap, win, syms, trees.cleared()))
}
fn with_tables(options: Options, wrap: Wrap, win: Window, syms: Symbols, trees: Trees) -> Self {
let symbol_buffer = syms.capacity();
Self {
level: options.level.get(),
strategy: options.strategy,
config: Config::of(options.level),
wrap,
status: Status::Init,
trailer_written: false,
win,
strstart: 0,
block_start: 0,
lookahead: 0,
match_start: 0,
prev_length: 0,
prev_match: 0,
match_available: false,
ins_h: 0,
syms,
trees,
block_open: 0,
pending_buf_size: 4 * symbol_buffer,
adler: Adler32::new(),
}
}
pub(crate) fn deflate(
&mut self,
input: &mut &[u8],
out: &mut Output<'_>,
flush: Flush,
) -> bool {
debug_assert!(out.room() > 0 && (!input.is_empty() || flush == Flush::Finish));
if out.pending() != 0 {
out.flush_pending();
if out.room() == 0 {
return false;
}
}
if self.status == Status::Init {
self.status = Status::Busy;
if self.wrap == Wrap::Zlib {
out.put_bytes(&self.header());
out.flush_pending();
if out.pending() != 0 {
return false;
}
}
}
let finishing = flush == Flush::Finish && self.status != Status::Finished;
if !input.is_empty() || self.lookahead != 0 || finishing {
let state = self.parse(input, out, flush);
if state != BlockState::NeedMore {
self.status = Status::Finished;
}
if state != BlockState::FinishDone {
return false;
}
}
if flush != Flush::Finish {
return false;
}
if self.wrap == Wrap::Zlib && !self.trailer_written {
out.put_bytes(&self.adler.finish().to_be_bytes());
}
self.trailer_written = true;
out.flush_pending();
out.pending() == 0
}
fn parse(&mut self, input: &mut &[u8], out: &mut Output<'_>, flush: Flush) -> BlockState {
match (self.config.method, self.strategy) {
(Method::Stored, _) => self.deflate_stored(input, out, flush),
(_, Strategy::HuffmanOnly) => self.deflate_huff(input, out, flush),
(_, Strategy::Rle) => self.deflate_rle(input, out, flush),
(Method::Quick, _) => self.deflate_quick(input, out, flush),
(Method::Fast, _) => self.deflate_fast(input, out, flush),
(Method::Medium, _) => self.deflate_medium(input, out, flush),
(Method::Slow, _) => self.deflate_slow(input, out, flush),
}
}
fn header(&self) -> [u8; 2] {
let level_flags: u16 = if self.strategy.is_fastest_kind() || self.level < 2 {
0
} else if self.level < 6 {
1
} else if self.level == 6 {
2
} else {
3
};
let mut header = (8 + (7 << 4)) << 8 | level_flags << 6;
header += 31 - header % 31;
header.to_be_bytes()
}
fn read_buf(&mut self, input: &mut &[u8], at: u32, room: u32) -> u32 {
let count = input.len().min(room as usize);
let (taken, rest) = input.split_at(count);
self.adler.update(taken);
self.win.bytes[at as usize..at as usize + count].copy_from_slice(taken);
*input = rest;
count as u32
}
fn flush_block_only(&mut self, out: &mut Output<'_>, last: bool) {
let stored = usize::try_from(self.block_start)
.ok()
.map(|start| &self.win.bytes[start..self.strstart as usize]);
self.trees.flush_block(
&mut self.syms,
out,
stored,
last,
self.strategy == Strategy::Fixed,
);
self.block_start = i64::from(self.strstart);
out.flush_pending();
}
fn flush_block(&mut self, out: &mut Output<'_>, last: bool) -> Option<BlockState> {
self.flush_block_only(out, last);
(out.room() == 0).then_some(if last {
BlockState::FinishStarted
} else {
BlockState::NeedMore
})
}
fn finish_blocks(&mut self, out: &mut Output<'_>, flush: Flush) -> BlockState {
debug_assert_eq!(flush, Flush::Finish, "parsers stop early otherwise");
self.flush_block(out, true)
.unwrap_or(BlockState::FinishDone)
}
}
pub(crate) fn one_shot(
data: &[u8],
options: Options,
wrap: Wrap,
tables: &mut Option<Deflater>,
out: &mut Vec<u8>,
) -> Result<(), OutOfMemory> {
let mut deflater = match tables.take() {
Some(used) => used.restart(options, wrap, data.len())?,
None => Deflater::new(options, wrap)?,
};
reserve_usual(out, data.len(), options);
let mut output = Output::new(out);
let mut input = data;
while !deflater.deflate(&mut input, &mut output, Flush::Finish) {}
*tables = Some(deflater);
output.finish()
}
fn reserve_usual(out: &mut Vec<u8>, len: usize, options: Options) {
let _ = out.try_reserve(if options.level == CompressionLevel::NONE {
len + 5 * (len / 65_535 + 1) + 6
} else {
len / 4 + 64
});
}