1#![forbid(unsafe_code)]
4
5use alloc::vec::Vec;
6use core::mem::MaybeUninit;
7
8use crate::frame_state::EncodeState;
9use crate::strategy::{self, LevelParams};
10use zrip_core::dict::Dictionary;
11use zrip_core::error::CompressError;
12pub use zrip_core::push::{Progress, Status};
13
14trait Output {
16 fn put(&mut self, pos: usize, data: &[u8]) -> usize;
18}
19
20impl Output for [u8] {
21 fn put(&mut self, pos: usize, data: &[u8]) -> usize {
22 let n = data.len().min(self.len() - pos);
23 self[pos..pos + n].copy_from_slice(&data[..n]);
24 n
25 }
26}
27
28impl Output for [MaybeUninit<u8>] {
29 fn put(&mut self, pos: usize, data: &[u8]) -> usize {
30 let n = data.len().min(self.len() - pos);
31 for (dst, &src) in self[pos..pos + n].iter_mut().zip(data) {
33 dst.write(src);
34 }
35 n
36 }
37}
38
39#[derive(Debug, Clone, Copy, PartialEq, Eq)]
41pub enum EndOp {
42 Continue,
44 Flush,
46 End,
48}
49
50pub struct PushEncoder {
91 frame: EncodeState,
92 level: i32,
94 opts: Option<strategy::Options>,
95 pending: Vec<u8>,
97 pending_pos: usize,
98 header_written: bool,
99 frame_done: bool,
102 error: Option<CompressError>,
103}
104
105impl core::fmt::Debug for PushEncoder {
106 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
107 f.debug_struct("PushEncoder")
108 .field("pending_output", &(self.pending.len() - self.pending_pos))
109 .field("error", &self.error)
110 .finish_non_exhaustive()
111 }
112}
113
114impl PushEncoder {
115 pub fn new(level: i32) -> Result<Self, CompressError> {
117 let params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
118 Ok(Self::from_params(level, None, params, None))
119 }
120
121 pub fn with_options(level: i32, opts: &strategy::Options) -> Result<Self, CompressError> {
124 let mut params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
125 strategy::apply_options(&mut params, opts);
126 Ok(Self::from_params(level, Some(opts.clone()), params, None))
127 }
128
129 pub fn with_dict(level: i32, dict: Dictionary) -> Result<Self, CompressError> {
131 let params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
132 Ok(Self::from_params(level, None, params, Some(dict)))
133 }
134
135 fn from_params(
136 level: i32,
137 opts: Option<strategy::Options>,
138 params: LevelParams,
139 dict: Option<Dictionary>,
140 ) -> Self {
141 Self {
142 frame: EncodeState::new(params, dict),
143 level,
144 opts,
145 pending: Vec::new(),
146 pending_pos: 0,
147 header_written: false,
148 frame_done: false,
149 error: None,
150 }
151 }
152
153 pub fn encode(
166 &mut self,
167 input: &[u8],
168 output: &mut [u8],
169 op: EndOp,
170 ) -> Result<Progress, CompressError> {
171 self.encode_with(input, output, op)
172 }
173
174 pub fn encode_uninit(
180 &mut self,
181 input: &[u8],
182 output: &mut [MaybeUninit<u8>],
183 op: EndOp,
184 ) -> Result<Progress, CompressError> {
185 self.encode_with(input, output, op)
186 }
187
188 fn encode_with<O: Output + ?Sized>(
189 &mut self,
190 input: &[u8],
191 output: &mut O,
192 op: EndOp,
193 ) -> Result<Progress, CompressError> {
194 if let Some(e) = &self.error {
195 return Err(e.clone());
196 }
197 let mut consumed = 0;
198 let mut produced = 0;
199 let result = self.run(input, output, op, &mut consumed, &mut produced);
200 match result {
201 Ok(status) => Ok(Progress {
202 consumed,
203 produced,
204 status,
205 }),
206 Err(e) => {
207 self.error = Some(e.clone());
208 Err(e)
209 }
210 }
211 }
212
213 pub fn encode_to_vec(
219 &mut self,
220 input: &[u8],
221 output: &mut Vec<u8>,
222 op: EndOp,
223 ) -> Result<(), CompressError> {
224 if let Some(e) = &self.error {
225 return Err(e.clone());
226 }
227 output.extend_from_slice(&self.pending[self.pending_pos..]);
228 self.pending.clear();
229 self.pending_pos = 0;
230 if self.frame_done {
231 self.end_frame();
232 if input.is_empty() {
234 return Ok(());
235 }
236 }
237 let mut consumed = 0;
238 loop {
239 if self.frame_done {
240 self.end_frame();
241 return Ok(());
242 }
243 match self.advance(input, &mut consumed, op, output) {
244 Ok(true) => {}
245 Ok(false) => return Ok(()),
246 Err(e) => {
247 self.error = Some(e.clone());
248 return Err(e);
249 }
250 }
251 }
252 }
253
254 pub fn has_pending_output(&self) -> bool {
256 self.pending_pos < self.pending.len()
257 }
258
259 pub fn reset(&mut self) {
262 self.frame.reset();
263 self.pending.clear();
264 self.pending_pos = 0;
265 self.header_written = false;
266 self.frame_done = false;
267 self.error = None;
268 }
269
270 fn run<O: Output + ?Sized>(
271 &mut self,
272 input: &[u8],
273 output: &mut O,
274 op: EndOp,
275 consumed: &mut usize,
276 produced: &mut usize,
277 ) -> Result<Status, CompressError> {
278 loop {
279 if self.has_pending_output() {
280 let src = &self.pending[self.pending_pos..];
281 let n = output.put(*produced, src);
282 *produced += n;
283 self.pending_pos += n;
284 if self.has_pending_output() {
285 return Ok(Status::NeedsOutput);
286 }
287 }
288 self.pending.clear();
289 self.pending_pos = 0;
290
291 if self.frame_done {
292 self.end_frame();
293 return Ok(Status::Finished);
294 }
295
296 let mut pending = core::mem::take(&mut self.pending);
297 let advanced = self.advance(input, consumed, op, &mut pending);
298 self.pending = pending;
299 if !advanced? {
300 return Ok(Status::NeedsInput);
301 }
302 }
303 }
304
305 fn advance(
309 &mut self,
310 input: &[u8],
311 consumed: &mut usize,
312 op: EndOp,
313 out: &mut Vec<u8>,
314 ) -> Result<bool, CompressError> {
315 if op == EndOp::End && !self.header_written {
319 let rest = &input[*consumed..];
320 if self.frame.buffered() == 0 {
321 self.one_pass(Some(rest), out)?;
322 *consumed = input.len();
323 self.frame_done = true;
324 return Ok(true);
325 }
326 if self.frame.buffered() + rest.len() <= self.frame.block_size() {
327 *consumed += self.frame.take_input(rest);
328 self.one_pass(None, out)?;
329 self.frame_done = true;
330 return Ok(true);
331 }
332 }
333
334 *consumed += self.frame.take_input(&input[*consumed..]);
335 let more_input = *consumed < input.len();
336 let full = self.frame.buffered() == self.frame.block_size();
337
338 let last = !more_input && op == EndOp::End;
341 let due = (full && more_input)
342 || last
343 || (!more_input && op == EndOp::Flush && self.frame.buffered() > 0);
344 if !due {
345 return Ok(false);
346 }
347
348 if !self.header_written {
349 self.frame.write_header(out)?;
350 self.header_written = true;
351 }
352 self.frame.encode_block(last, out)?;
353 if last {
354 self.frame.write_checksum(out);
355 self.frame_done = true;
356 }
357 Ok(true)
358 }
359
360 fn one_pass(&mut self, input: Option<&[u8]>, out: &mut Vec<u8>) -> Result<(), CompressError> {
363 let len = input.map_or_else(|| self.frame.buffered(), <[u8]>::len);
364 let params = match (self.frame.dict(), &self.opts) {
365 (Some(dict), _) => {
366 strategy::level_params_with_prefix(self.level, dict.content().len(), len)
367 }
368 (None, Some(opts)) => Some(crate::params_with_options(self.level, len, opts)?),
369 (None, None) => strategy::level_params_for_size(self.level, len),
370 }
371 .ok_or(CompressError::InvalidLevel(self.level))?;
372 self.frame.encode_one_pass(input, ¶ms, out)
373 }
374
375 fn end_frame(&mut self) {
376 self.frame_done = false;
377 self.header_written = false;
378 self.frame.reset();
379 }
380}