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 &self.params,
263 &self.rep_offsets,
264 &mut self.hash_table,
265 &mut self.hash_long,
266 &mut self.sequences,
267 );
268 true
269 } else {
270 false
271 };
272 #[cfg(not(feature = "ldm"))]
273 let used_ldm = false;
274
275 if !used_ldm {
276 match self.params.strategy {
277 Strategy::Fast => {
278 fast::compress_fast_block(
279 &self.window_buf,
280 plen,
281 self.window_buf.len(),
282 &self.params,
283 &self.rep_offsets,
284 &mut self.hash_table,
285 &mut self.sequences,
286 );
287 }
288 Strategy::DFast => {
289 dfast::compress_dfast_block(
290 &self.window_buf,
291 plen,
292 self.window_buf.len(),
293 &self.params,
294 &self.rep_offsets,
295 &mut self.hash_table,
296 &mut self.hash_long,
297 &mut self.sequences,
298 );
299 }
300 }
301 }
302
303 if self.params.force_raw_literals {
304 block_encoder::encode_compressed_block_raw(
305 &chunk,
306 &self.sequences,
307 &mut self.rep_offsets,
308 last,
309 &mut self.block_out,
310 &mut self.workspace,
311 )
312 .map_err(io::Error::other)?;
313 } else {
314 block_encoder::encode_compressed_block(
315 &chunk,
316 &self.sequences,
317 &mut self.rep_offsets,
318 last,
319 &mut self.block_out,
320 &mut self.workspace,
321 strategy::block_policy(&self.params, chunk.len()),
322 )
323 .map_err(io::Error::other)?;
324 }
325 }
326
327 let window_size = 1usize << self.params.window_log;
328 if self.window_buf.len() > window_size * 2 {
329 let shift = self.window_buf.len() - window_size;
330 reduce_hash_table(&mut self.hash_table, shift as u32);
331 if !self.hash_long.is_empty() {
332 reduce_hash_table(&mut self.hash_long, shift as u32);
333 }
334 #[cfg(feature = "ldm")]
335 if let Some(ref mut ldm) = self.ldm_state {
336 ldm.reduce_positions(shift as u32);
337 }
338 self.window_buf.copy_within(shift.., 0);
339 self.window_buf.truncate(window_size);
340 }
341
342 self.first_block = false;
343 self.inner.write_all(&self.block_out)?;
344 Ok(())
345 }
346}
347
348fn alloc_hash_tables(params: &LevelParams) -> (Vec<u32>, Vec<u32>) {
349 match params.strategy {
350 Strategy::Fast => (vec![0u32; 1usize << params.hash_log], Vec::new()),
351 Strategy::DFast => (
352 vec![0u32; 1usize << params.chain_log],
353 vec![0u32; 1usize << params.hash_log],
354 ),
355 }
356}
357
358fn reduce_hash_table(table: &mut [u32], shift: u32) {
359 for entry in table.iter_mut() {
360 if *entry < shift {
361 *entry = 0;
362 } else {
363 *entry -= shift;
364 }
365 }
366}
367
368impl<W: Write> Write for FrameEncoder<W> {
369 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
370 if matches!(self.state, EncoderState::Failed) {
371 return Err(io::Error::other("encoder cannot be reused after an error"));
372 }
373 if matches!(self.state, EncoderState::Finished) {
374 return Err(io::Error::other("encoder already finished"));
375 }
376 self.state = EncoderState::Failed;
378
379 if !self.header_written {
380 self.write_header()?;
381 }
382
383 self.hasher.update(buf);
384
385 let mut consumed = 0;
386 while consumed < buf.len() {
387 let space = MAX_BLOCK_SIZE - self.buffer.len();
388 let n = space.min(buf.len() - consumed);
389 self.buffer.extend_from_slice(&buf[consumed..consumed + n]);
390 consumed += n;
391
392 if self.buffer.len() >= MAX_BLOCK_SIZE {
393 self.flush_block(false)?;
394 }
395 }
396
397 self.state = EncoderState::Ready;
398 Ok(consumed)
399 }
400
401 fn flush(&mut self) -> io::Result<()> {
402 if matches!(self.state, EncoderState::Failed) {
403 return Err(io::Error::other("encoder cannot be reused after an error"));
404 }
405 let state = self.state;
406 self.state = EncoderState::Failed;
407 if !self.buffer.is_empty() {
408 self.flush_block(false)?;
409 }
410 self.inner.flush()?;
411 self.state = state;
412 Ok(())
413 }
414}