1#![forbid(unsafe_code)]
4
5use alloc::vec::Vec;
6
7use crate::frame_state::EncodeState;
8use crate::strategy::{self, LevelParams};
9use zrip_core::dict::Dictionary;
10use zrip_core::error::CompressError;
11pub use zrip_core::push::{Progress, Status};
12
13#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15pub enum EndOp {
16 Continue,
18 Flush,
20 End,
22}
23
24pub struct PushEncoder {
65 frame: EncodeState,
66 level: i32,
68 opts: Option<strategy::Options>,
69 pending: Vec<u8>,
71 pending_pos: usize,
72 header_written: bool,
73 frame_done: bool,
76 error: Option<CompressError>,
77}
78
79impl core::fmt::Debug for PushEncoder {
80 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
81 f.debug_struct("PushEncoder")
82 .field("pending_output", &(self.pending.len() - self.pending_pos))
83 .field("error", &self.error)
84 .finish_non_exhaustive()
85 }
86}
87
88impl PushEncoder {
89 pub fn new(level: i32) -> Result<Self, CompressError> {
91 let params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
92 Ok(Self::from_params(level, None, params, None))
93 }
94
95 pub fn with_options(level: i32, opts: &strategy::Options) -> Result<Self, CompressError> {
98 let mut params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
99 strategy::apply_options(&mut params, opts);
100 Ok(Self::from_params(level, Some(opts.clone()), params, None))
101 }
102
103 pub fn with_dict(level: i32, dict: Dictionary) -> Result<Self, CompressError> {
105 let params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
106 Ok(Self::from_params(level, None, params, Some(dict)))
107 }
108
109 fn from_params(
110 level: i32,
111 opts: Option<strategy::Options>,
112 params: LevelParams,
113 dict: Option<Dictionary>,
114 ) -> Self {
115 Self {
116 frame: EncodeState::new(params, dict),
117 level,
118 opts,
119 pending: Vec::new(),
120 pending_pos: 0,
121 header_written: false,
122 frame_done: false,
123 error: None,
124 }
125 }
126
127 pub fn encode(
140 &mut self,
141 input: &[u8],
142 output: &mut [u8],
143 op: EndOp,
144 ) -> Result<Progress, CompressError> {
145 if let Some(e) = &self.error {
146 return Err(e.clone());
147 }
148 let mut consumed = 0;
149 let mut produced = 0;
150 let result = self.run(input, output, op, &mut consumed, &mut produced);
151 match result {
152 Ok(status) => Ok(Progress {
153 consumed,
154 produced,
155 status,
156 }),
157 Err(e) => {
158 self.error = Some(e.clone());
159 Err(e)
160 }
161 }
162 }
163
164 pub fn encode_to_vec(
170 &mut self,
171 input: &[u8],
172 output: &mut Vec<u8>,
173 op: EndOp,
174 ) -> Result<(), CompressError> {
175 if let Some(e) = &self.error {
176 return Err(e.clone());
177 }
178 output.extend_from_slice(&self.pending[self.pending_pos..]);
179 self.pending.clear();
180 self.pending_pos = 0;
181 if self.frame_done {
182 self.end_frame();
183 if input.is_empty() {
185 return Ok(());
186 }
187 }
188 let mut consumed = 0;
189 loop {
190 if self.frame_done {
191 self.end_frame();
192 return Ok(());
193 }
194 match self.advance(input, &mut consumed, op, output) {
195 Ok(true) => {}
196 Ok(false) => return Ok(()),
197 Err(e) => {
198 self.error = Some(e.clone());
199 return Err(e);
200 }
201 }
202 }
203 }
204
205 pub fn has_pending_output(&self) -> bool {
207 self.pending_pos < self.pending.len()
208 }
209
210 pub fn reset(&mut self) {
213 self.frame.reset();
214 self.pending.clear();
215 self.pending_pos = 0;
216 self.header_written = false;
217 self.frame_done = false;
218 self.error = None;
219 }
220
221 fn run(
222 &mut self,
223 input: &[u8],
224 output: &mut [u8],
225 op: EndOp,
226 consumed: &mut usize,
227 produced: &mut usize,
228 ) -> Result<Status, CompressError> {
229 loop {
230 if self.has_pending_output() {
231 let src = &self.pending[self.pending_pos..];
232 let n = src.len().min(output.len() - *produced);
233 output[*produced..*produced + n].copy_from_slice(&src[..n]);
234 *produced += n;
235 self.pending_pos += n;
236 if self.has_pending_output() {
237 return Ok(Status::NeedsOutput);
238 }
239 }
240 self.pending.clear();
241 self.pending_pos = 0;
242
243 if self.frame_done {
244 self.end_frame();
245 return Ok(Status::Finished);
246 }
247
248 let mut pending = core::mem::take(&mut self.pending);
249 let advanced = self.advance(input, consumed, op, &mut pending);
250 self.pending = pending;
251 if !advanced? {
252 return Ok(Status::NeedsInput);
253 }
254 }
255 }
256
257 fn advance(
261 &mut self,
262 input: &[u8],
263 consumed: &mut usize,
264 op: EndOp,
265 out: &mut Vec<u8>,
266 ) -> Result<bool, CompressError> {
267 if op == EndOp::End && !self.header_written {
271 let rest = &input[*consumed..];
272 if self.frame.buffered() == 0 {
273 self.one_pass(Some(rest), out)?;
274 *consumed = input.len();
275 self.frame_done = true;
276 return Ok(true);
277 }
278 if self.frame.buffered() + rest.len() <= self.frame.block_size() {
279 *consumed += self.frame.take_input(rest);
280 self.one_pass(None, out)?;
281 self.frame_done = true;
282 return Ok(true);
283 }
284 }
285
286 *consumed += self.frame.take_input(&input[*consumed..]);
287 let more_input = *consumed < input.len();
288 let full = self.frame.buffered() == self.frame.block_size();
289
290 let last = !more_input && op == EndOp::End;
293 let due = (full && more_input)
294 || last
295 || (!more_input && op == EndOp::Flush && self.frame.buffered() > 0);
296 if !due {
297 return Ok(false);
298 }
299
300 if !self.header_written {
301 self.frame.write_header(out)?;
302 self.header_written = true;
303 }
304 self.frame.encode_block(last, out)?;
305 if last {
306 self.frame.write_checksum(out);
307 self.frame_done = true;
308 }
309 Ok(true)
310 }
311
312 fn one_pass(&mut self, input: Option<&[u8]>, out: &mut Vec<u8>) -> Result<(), CompressError> {
315 let len = input.map_or_else(|| self.frame.buffered(), <[u8]>::len);
316 let params = match (self.frame.dict(), &self.opts) {
317 (Some(dict), _) => {
318 strategy::level_params_with_prefix(self.level, dict.content().len(), len)
319 }
320 (None, Some(opts)) => Some(crate::params_with_options(self.level, len, opts)?),
321 (None, None) => strategy::level_params_for_size(self.level, len),
322 }
323 .ok_or(CompressError::InvalidLevel(self.level))?;
324 self.frame.encode_one_pass(input, ¶ms, out)
325 }
326
327 fn end_frame(&mut self) {
328 self.frame_done = false;
329 self.header_written = false;
330 self.frame.reset();
331 }
332}