1#![forbid(unsafe_code)]
2
3use std::io::{self, Write};
4
5use crate::block_encoder::{self, BlockEncodeWorkspace};
6use crate::dfast;
7use crate::fast;
8#[cfg(feature = "ldm")]
9use crate::ldm::LdmState;
10use crate::strategy::{self, LevelParams, Strategy};
11use crate::write_frame_header_without_content_size;
12use zrip_core::Sequence;
13use zrip_core::dict::Dictionary;
14use zrip_core::error::CompressError;
15use zrip_core::frame::MAX_BLOCK_SIZE;
16use zrip_core::xxhash::Xxh64State;
17
18#[derive(Clone, Copy)]
19enum EncoderState {
20 Ready,
21 Finished,
22 Failed,
23}
24
25pub struct FrameEncoder<W: Write> {
50 inner: W,
51 params: LevelParams,
52 buffer: Vec<u8>,
53 rep_offsets: [u32; 3],
54 hasher: Xxh64State,
55 header_written: bool,
56 state: EncoderState,
57 workspace: BlockEncodeWorkspace,
58 dict: Option<Dictionary>,
59 first_block: bool,
60 hash_table: Vec<u32>,
61 hash_long: Vec<u32>,
62 sequences: Vec<Sequence>,
63 block_out: Vec<u8>,
64 window_buf: Vec<u8>,
65 #[cfg(feature = "ldm")]
66 ldm_state: Option<LdmState>,
67}
68
69impl<W: Write> FrameEncoder<W> {
70 pub fn new(writer: W, level: i32) -> Result<Self, CompressError> {
72 let params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
73 Self::from_params(writer, params, None)
74 }
75
76 pub fn with_options(
79 writer: W,
80 level: i32,
81 opts: &strategy::Options,
82 ) -> Result<Self, CompressError> {
83 let mut params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
84 strategy::apply_options(&mut params, opts);
85 Self::from_params(writer, params, None)
86 }
87
88 pub fn with_dict(writer: W, level: i32, dict: Dictionary) -> Result<Self, CompressError> {
90 let params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
91 Self::from_params(writer, params, Some(dict))
92 }
93
94 #[allow(clippy::unnecessary_wraps)]
95 fn from_params(
96 writer: W,
97 params: LevelParams,
98 dict: Option<Dictionary>,
99 ) -> Result<Self, CompressError> {
100 let (hash_table, hash_long) = alloc_hash_tables(¶ms);
101 let (rep_offsets, first_block) = match &dict {
102 Some(d) => (*d.rep_offsets(), true),
103 None => ([1, 4, 8], false),
104 };
105 let mut window_buf = Vec::new();
106 if let Some(ref d) = dict {
107 window_buf.extend_from_slice(d.content());
108 }
109 #[cfg(feature = "ldm")]
110 let ldm_state = params.ldm_params.as_ref().map(LdmState::new);
111 Ok(Self {
112 inner: writer,
113 params,
114 buffer: Vec::new(),
115 rep_offsets,
116 hasher: Xxh64State::new(0),
117 header_written: false,
118 state: EncoderState::Ready,
119 workspace: BlockEncodeWorkspace::new(),
120 dict,
121 first_block,
122 hash_table,
123 hash_long,
124 sequences: Vec::new(),
125 block_out: Vec::new(),
126 window_buf,
127 #[cfg(feature = "ldm")]
128 ldm_state,
129 })
130 }
131
132 pub fn finish(mut self) -> Result<W, io::Error> {
134 self.finish_frame()?;
135 Ok(self.inner)
136 }
137
138 pub fn reset(&mut self, new_writer: W) -> Result<W, io::Error> {
144 self.finish_frame()?;
145 let old = core::mem::replace(&mut self.inner, new_writer);
146 self.header_written = false;
147 self.state = EncoderState::Ready;
148 self.first_block = self.dict.is_some();
149 self.rep_offsets = match &self.dict {
150 Some(d) => *d.rep_offsets(),
151 None => [1, 4, 8],
152 };
153 self.hasher = Xxh64State::new(0);
154 self.workspace.prev_huffman = None;
155 self.window_buf.clear();
156 if let Some(ref d) = self.dict {
157 self.window_buf.extend_from_slice(d.content());
158 }
159 #[cfg(feature = "ldm")]
160 if let Some(ref mut ldm) = self.ldm_state {
161 ldm.reset();
162 }
163 Ok(old)
164 }
165
166 fn finish_frame(&mut self) -> io::Result<()> {
167 if matches!(self.state, EncoderState::Failed) {
168 return Err(io::Error::other("encoder cannot be reused after an error"));
169 }
170 if matches!(self.state, EncoderState::Finished) {
171 return Ok(());
172 }
173 self.state = EncoderState::Failed;
174
175 if !self.header_written {
176 self.write_header()?;
177 }
178
179 self.flush_block(true)?;
180
181 let hash = self.hasher.finish();
182 let checksum = (hash & 0xFFFF_FFFF) as u32;
183 self.inner.write_all(&checksum.to_le_bytes())?;
184 self.state = EncoderState::Finished;
185 Ok(())
186 }
187
188 fn write_header(&mut self) -> io::Result<()> {
189 self.block_out.clear();
190 write_frame_header_without_content_size(
191 &mut self.block_out,
192 self.dict.as_ref().map(Dictionary::id),
193 self.params.window_log,
194 )
195 .map_err(io::Error::other)?;
196 self.inner.write_all(&self.block_out)?;
197 self.header_written = true;
198 Ok(())
199 }
200
201 fn flush_block(&mut self, last: bool) -> io::Result<()> {
202 if self.buffer.is_empty() && last {
203 self.block_out.clear();
204 block_encoder::encode_raw_block(&[], true, &mut self.block_out)
205 .map_err(io::Error::other)?;
206 self.inner.write_all(&self.block_out)?;
207 return Ok(());
208 }
209
210 if self.buffer.is_empty() {
211 return Ok(());
212 }
213
214 let chunk = core::mem::take(&mut self.buffer);
215 let seed_dict = self.first_block && self.dict.is_some();
216
217 let plen = self.window_buf.len();
218 self.window_buf.extend_from_slice(&chunk);
219
220 self.block_out.clear();
221 self.block_out.reserve(chunk.len() + 32);
222 if crate::skip_match_search(&self.params, chunk.len(), &chunk) {
223 block_encoder::encode_raw_block(&chunk, last, &mut self.block_out)
224 .map_err(io::Error::other)?;
225 } else {
226 if seed_dict {
227 match self.params.strategy {
228 Strategy::Fast => {
229 fast::prefill_hash_table(
230 &self.window_buf,
231 plen,
232 self.params.hash_log,
233 self.params.min_match,
234 &mut self.hash_table,
235 );
236 }
237 Strategy::DFast => {
238 dfast::prefill_hash_tables(
239 &self.window_buf,
240 plen,
241 self.params.hash_log,
242 self.params.chain_log,
243 self.params.min_match,
244 &mut self.hash_table,
245 &mut self.hash_long,
246 );
247 }
248 }
249 } else if plen == 0 {
250 self.hash_table.fill(0);
251 if !self.hash_long.is_empty() {
252 self.hash_long.fill(0);
253 }
254 }
255
256 #[cfg(feature = "ldm")]
257 let used_ldm = if let Some(ref mut ldm) = self.ldm_state {
258 ldm.compress_block(
259 &self.window_buf,
260 plen,
261 self.window_buf.len(),
262 1usize << self.params.window_log,
263 &self.params,
264 &self.rep_offsets,
265 &mut self.hash_table,
266 &mut self.hash_long,
267 &mut self.sequences,
268 );
269 true
270 } else {
271 false
272 };
273 #[cfg(not(feature = "ldm"))]
274 let used_ldm = false;
275
276 if !used_ldm {
277 match self.params.strategy {
278 Strategy::Fast => {
279 fast::compress_fast_block(
280 &self.window_buf,
281 plen,
282 self.window_buf.len(),
283 &self.params,
284 &self.rep_offsets,
285 &mut self.hash_table,
286 &mut self.sequences,
287 );
288 }
289 Strategy::DFast => {
290 dfast::compress_dfast_block(
291 &self.window_buf,
292 plen,
293 self.window_buf.len(),
294 &self.params,
295 &self.rep_offsets,
296 &mut self.hash_table,
297 &mut self.hash_long,
298 &mut self.sequences,
299 );
300 }
301 }
302 }
303
304 if self.params.force_raw_literals {
305 block_encoder::encode_compressed_block_raw(
306 &chunk,
307 &self.sequences,
308 &mut self.rep_offsets,
309 last,
310 &mut self.block_out,
311 &mut self.workspace,
312 )
313 .map_err(io::Error::other)?;
314 } else {
315 block_encoder::encode_compressed_block(
316 &chunk,
317 &self.sequences,
318 &mut self.rep_offsets,
319 last,
320 &mut self.block_out,
321 &mut self.workspace,
322 strategy::block_policy(&self.params, chunk.len()),
323 )
324 .map_err(io::Error::other)?;
325 }
326 }
327
328 let window_size = 1usize << self.params.window_log;
329 if self.window_buf.len() > window_size * 2 {
330 let shift = self.window_buf.len() - window_size;
331 reduce_hash_table(&mut self.hash_table, shift as u32);
332 if !self.hash_long.is_empty() {
333 reduce_hash_table(&mut self.hash_long, shift as u32);
334 }
335 #[cfg(feature = "ldm")]
336 if let Some(ref mut ldm) = self.ldm_state {
337 ldm.reduce_positions(shift as u32);
338 }
339 self.window_buf.copy_within(shift.., 0);
340 self.window_buf.truncate(window_size);
341 }
342
343 self.first_block = false;
344 self.inner.write_all(&self.block_out)?;
345 Ok(())
346 }
347}
348
349fn alloc_hash_tables(params: &LevelParams) -> (Vec<u32>, Vec<u32>) {
350 match params.strategy {
351 Strategy::Fast => (vec![0u32; 1usize << params.hash_log], Vec::new()),
352 Strategy::DFast => (
353 vec![0u32; 1usize << params.chain_log],
354 vec![0u32; 1usize << params.hash_log],
355 ),
356 }
357}
358
359fn reduce_hash_table(table: &mut [u32], shift: u32) {
360 for entry in table.iter_mut() {
361 if *entry < shift {
362 *entry = 0;
363 } else {
364 *entry -= shift;
365 }
366 }
367}
368
369impl<W: Write> Write for FrameEncoder<W> {
370 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
371 if matches!(self.state, EncoderState::Failed) {
372 return Err(io::Error::other("encoder cannot be reused after an error"));
373 }
374 if matches!(self.state, EncoderState::Finished) {
375 return Err(io::Error::other("encoder already finished"));
376 }
377 self.state = EncoderState::Failed;
379
380 if !self.header_written {
381 self.write_header()?;
382 }
383
384 self.hasher.update(buf);
385
386 let block_size = MAX_BLOCK_SIZE.min(1usize << self.params.window_log);
387 let mut consumed = 0;
388 while consumed < buf.len() {
389 let space = block_size - self.buffer.len();
390 let n = space.min(buf.len() - consumed);
391 self.buffer.extend_from_slice(&buf[consumed..consumed + n]);
392 consumed += n;
393
394 if self.buffer.len() >= block_size {
395 self.flush_block(false)?;
396 }
397 }
398
399 self.state = EncoderState::Ready;
400 Ok(consumed)
401 }
402
403 fn flush(&mut self) -> io::Result<()> {
404 if matches!(self.state, EncoderState::Failed) {
405 return Err(io::Error::other("encoder cannot be reused after an error"));
406 }
407 let state = self.state;
408 self.state = EncoderState::Failed;
409 if !self.buffer.is_empty() {
410 self.flush_block(false)?;
411 }
412 self.inner.flush()?;
413 self.state = state;
414 Ok(())
415 }
416}