#![forbid(unsafe_code)]
use alloc::vec::Vec;
use crate::block_encoder::{self, BlockEncodeWorkspace};
use crate::context;
use crate::dfast;
use crate::fast;
#[cfg(feature = "ldm")]
use crate::ldm::LdmState;
use crate::rebase::reduce_hash_table;
use crate::strategy::{self, LevelParams, Strategy};
use crate::table::MatchTable;
use crate::write_frame_header_without_content_size;
use zrip_core::Sequence;
use zrip_core::dict::Dictionary;
use zrip_core::error::CompressError;
use zrip_core::frame::MAX_BLOCK_SIZE;
use zrip_core::huffman::encode::HuffmanEncodeTable;
use zrip_core::xxhash::Xxh64State;
const GROW_STEP: usize = 8 << 20;
const SLOT_CLEAR_RATIO: usize = 24;
pub(crate) fn slot_clear_pays(window: usize, tables: usize, entries: usize) -> bool {
window.saturating_mul(tables * SLOT_CLEAR_RATIO) <= entries
}
pub(crate) struct EncodeState {
params: LevelParams,
rep_offsets: [u32; 3],
hasher: Xxh64State,
workspace: BlockEncodeWorkspace,
dict: Option<Dictionary>,
first_block: bool,
hash_table: MatchTable,
hash_long: MatchTable,
sequences: Vec<Sequence>,
window_buf: Vec<u8>,
block_start: usize,
tables_ready: bool,
stale_window: Vec<u8>,
dict_hash: MatchTable,
combined: Vec<u8>,
#[cfg(feature = "ldm")]
ldm_state: Option<LdmState>,
}
impl EncodeState {
pub(crate) fn new(params: LevelParams, dict: Option<Dictionary>) -> Self {
let (rep_offsets, first_block) = match &dict {
Some(d) => (*d.rep_offsets(), true),
None => ([1, 4, 8], false),
};
let mut window_buf = Vec::new();
if let Some(ref d) = dict {
window_buf.extend_from_slice(d.content());
}
let block_start = window_buf.len();
#[cfg(feature = "ldm")]
let ldm_state = params.ldm_params.as_ref().map(LdmState::new);
Self {
params,
rep_offsets,
hasher: Xxh64State::new(0),
workspace: BlockEncodeWorkspace::new(),
dict,
first_block,
hash_table: MatchTable::new(),
hash_long: MatchTable::new(),
sequences: Vec::new(),
window_buf,
block_start,
tables_ready: false,
stale_window: Vec::new(),
dict_hash: MatchTable::new(),
combined: Vec::new(),
#[cfg(feature = "ldm")]
ldm_state,
}
}
pub(crate) fn encode_one_pass(
&mut self,
input: Option<&[u8]>,
params: &LevelParams,
out: &mut Vec<u8>,
) -> Result<(), CompressError> {
let src = match input {
Some(input) => input,
None => &self.window_buf[self.block_start..],
};
#[cfg(feature = "ldm")]
if params.ldm_params.is_some() {
return crate::compress_frame(src, params, out);
}
self.stale_window.clear();
let (dict_id, prefix, rep_offsets) = match &self.dict {
Some(d) => {
self.workspace.prev_ll = d
.ll_table()
.map(|(dt, al)| block_encoder::FseEncodeTable::from_decode_table(dt, al, 35));
self.workspace.prev_of = d
.of_table()
.map(|(dt, al)| block_encoder::FseEncodeTable::from_decode_table(dt, al, 31));
self.workspace.prev_ml = d
.ml_table()
.map(|(dt, al)| block_encoder::FseEncodeTable::from_decode_table(dt, al, 52));
self.workspace.set_prev_huffman(
d.huf_table()
.and_then(|(dt, tl)| HuffmanEncodeTable::from_decode_table(dt, tl)),
);
(Some(d.id()), d.content(), *d.rep_offsets())
}
None => (None, &[][..], [1, 4, 8]),
};
context::compress_core(
src,
*params,
dict_id,
prefix,
rep_offsets,
&mut self.hash_table,
&mut self.hash_long,
&mut self.dict_hash,
&mut self.sequences,
out,
&mut self.workspace,
&mut self.combined,
true,
)
}
pub(crate) fn reset(&mut self) {
if self.tables_ready {
self.stale_window.clear();
if self.slot_clear_pays() {
self.stale_window.extend_from_slice(&self.window_buf);
}
self.tables_ready = false;
}
self.first_block = self.dict.is_some();
self.rep_offsets = match &self.dict {
Some(d) => *d.rep_offsets(),
None => [1, 4, 8],
};
self.hasher = Xxh64State::new(0);
self.workspace.set_prev_huffman(None);
self.window_buf.clear();
if let Some(ref d) = self.dict {
self.window_buf.extend_from_slice(d.content());
}
self.block_start = self.window_buf.len();
#[cfg(feature = "ldm")]
if let Some(ref mut ldm) = self.ldm_state {
ldm.reset();
}
}
fn slot_clear_pays(&self) -> bool {
#[cfg(feature = "ldm")]
if self.ldm_state.is_some() {
return false;
}
let tables = if self.hash_long.is_empty() { 1 } else { 2 };
slot_clear_pays(
self.window_buf.len(),
tables,
self.hash_table.len() + self.hash_long.len(),
)
}
fn ready_tables(&mut self) {
let p = &self.params;
if !self.stale_window.is_empty() {
let window = &self.stale_window;
match p.strategy {
Strategy::Fast => self
.hash_table
.clear_slots(|t| fast::zero_position_slots(window, p.hash_log, p.min_match, t)),
Strategy::DFast => {
self.hash_table.clear_slots(|t| {
dfast::zero_short_slots(window, p.chain_log, p.min_match, t)
});
self.hash_long
.clear_slots(|t| dfast::zero_long_slots(window, p.hash_log, t));
}
}
self.stale_window.clear();
}
match p.strategy {
Strategy::Fast => self.hash_table.clear(1usize << p.hash_log),
Strategy::DFast => {
self.hash_table.clear(1usize << p.chain_log);
self.hash_long.clear(1usize << p.hash_log);
}
}
self.tables_ready = true;
}
pub(crate) fn block_size(&self) -> usize {
MAX_BLOCK_SIZE.min(1usize << self.params.window_log)
}
pub(crate) fn buffered(&self) -> usize {
self.window_buf.len() - self.block_start
}
pub(crate) fn dict(&self) -> Option<&Dictionary> {
self.dict.as_ref()
}
pub(crate) fn take_input(&mut self, input: &[u8]) -> usize {
let n = (self.block_size() - self.buffered()).min(input.len());
let needed = self.window_buf.len() + n;
if needed > self.window_buf.capacity() {
let window = 1usize << self.params.window_log;
let dict_len = self.dict.as_ref().map_or(0, |d| d.content().len());
let most = (2 * window).max(dict_len + window) + self.block_size();
let first = dict_len + self.block_size();
let target = if needed <= first {
(2 * self.window_buf.capacity()).min(first)
} else {
(2 * self.window_buf.capacity()).max(GROW_STEP).min(most)
}
.max(needed);
self.window_buf
.reserve_exact(target - self.window_buf.len());
}
self.window_buf.extend_from_slice(&input[..n]);
self.hasher.update(&input[..n]);
n
}
pub(crate) fn write_header(&self, out: &mut Vec<u8>) -> Result<(), CompressError> {
write_frame_header_without_content_size(
out,
self.dict.as_ref().map(Dictionary::id),
self.params.window_log,
)
}
pub(crate) fn write_checksum(&self, out: &mut Vec<u8>) {
let checksum = (self.hasher.finish() & 0xFFFF_FFFF) as u32;
out.extend_from_slice(&checksum.to_le_bytes());
}
pub(crate) fn encode_block(
&mut self,
last: bool,
out: &mut Vec<u8>,
) -> Result<(), CompressError> {
if self.buffered() == 0 {
if last {
block_encoder::encode_raw_block(&[], true, out)?;
}
return Ok(());
}
let seed_dict = self.first_block && self.dict.is_some();
let plen = self.block_start;
out.reserve(self.buffered() + 32);
let raw = {
let chunk = &self.window_buf[plen..];
crate::skip_match_search(&self.params, chunk.len(), chunk)
};
if !raw && !self.tables_ready {
self.ready_tables();
}
let chunk = &self.window_buf[plen..];
if raw {
block_encoder::encode_raw_block(chunk, last, out)?;
} else {
if seed_dict {
match self.params.strategy {
Strategy::Fast => {
fast::prefill_hash_table(
&self.window_buf,
plen,
self.params.hash_log,
self.params.min_match,
&mut self.hash_table,
);
}
Strategy::DFast => {
dfast::prefill_hash_tables(
&self.window_buf,
plen,
self.params.hash_log,
self.params.chain_log,
self.params.min_match,
&mut self.hash_table,
&mut self.hash_long,
);
}
}
}
#[cfg(feature = "ldm")]
let used_ldm = if let Some(ref mut ldm) = self.ldm_state {
ldm.compress_block(
&self.window_buf,
plen,
self.window_buf.len(),
1usize << self.params.window_log,
&self.params,
&self.rep_offsets,
&mut self.hash_table,
&mut self.hash_long,
&mut self.sequences,
);
true
} else {
false
};
#[cfg(not(feature = "ldm"))]
let used_ldm = false;
if !used_ldm {
match self.params.strategy {
Strategy::Fast => {
fast::compress_fast_block(
&self.window_buf,
plen,
self.window_buf.len(),
&self.params,
&self.rep_offsets,
&mut self.hash_table,
&mut self.sequences,
);
}
Strategy::DFast => {
dfast::compress_dfast_block(
&self.window_buf,
plen,
self.window_buf.len(),
&self.params,
&self.rep_offsets,
&mut self.hash_table,
&mut self.hash_long,
&mut self.sequences,
);
}
}
}
if self.params.force_raw_literals {
block_encoder::encode_compressed_block_raw(
chunk,
&self.sequences,
&mut self.rep_offsets,
last,
out,
&mut self.workspace,
)?;
} else {
block_encoder::encode_compressed_block(
chunk,
&self.sequences,
&mut self.rep_offsets,
last,
out,
&mut self.workspace,
strategy::block_policy(&self.params, chunk.len()),
)?;
}
}
let window_size = 1usize << self.params.window_log;
if self.window_buf.len() > window_size * 2 {
let shift = self.window_buf.len() - window_size;
reduce_hash_table(&mut self.hash_table, shift as u32);
if !self.hash_long.is_empty() {
reduce_hash_table(&mut self.hash_long, shift as u32);
}
#[cfg(feature = "ldm")]
if let Some(ref mut ldm) = self.ldm_state {
ldm.reduce_positions(shift as u32);
}
self.window_buf.copy_within(shift.., 0);
self.window_buf.truncate(window_size);
}
self.block_start = self.window_buf.len();
self.first_block = false;
Ok(())
}
}