Skip to main content

compression_codecs/zrip/
encoder.rs

1use crate::{
2    zrip::params::{options, CParameter},
3    EncodeV2,
4};
5use compression_core::util::{PartialBuffer, WriteBuffer};
6use std::io;
7use zrip::push::{EndOp, PushEncoder, Status};
8
9#[derive(Debug)]
10pub struct ZripEncoder {
11    encoder: PushEncoder,
12}
13
14impl ZripEncoder {
15    /// # Panics
16    ///
17    /// Panics if `level` is outside -7..=4; [`CParameter::quality`] clamps to that range.
18    pub fn new(level: i32) -> Self {
19        Self::new_with_params(level, &[])
20    }
21
22    /// # Panics
23    ///
24    /// Panics if `level` is outside -7..=4; [`CParameter::quality`] clamps to that range.
25    pub fn new_with_params(level: i32, params: &[CParameter]) -> Self {
26        Self {
27            encoder: PushEncoder::with_options(level, &options(params)).unwrap(),
28        }
29    }
30
31    pub fn new_with_dict(level: i32, dictionary: &[u8]) -> io::Result<Self> {
32        let dict = zrip::Dictionary::from_bytes(dictionary)
33            .map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?;
34        let encoder = PushEncoder::with_dict(level, dict)
35            .map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?;
36        Ok(Self { encoder })
37    }
38
39    fn process(
40        &mut self,
41        input: &[u8],
42        output: &mut WriteBuffer<'_>,
43        op: EndOp,
44    ) -> io::Result<(usize, Status)> {
45        // SAFETY: `encode_uninit` never de-initializes bytes of `output`.
46        let progress = self
47            .encoder
48            .encode_uninit(input, unsafe { output.unwritten_mut() }, op)
49            .map_err(io::Error::other)?;
50        // SAFETY: `encode_uninit` initializes exactly `produced` leading bytes of `output`.
51        unsafe { output.assume_init_and_advance(progress.produced) };
52        Ok((progress.consumed, progress.status))
53    }
54}
55
56impl EncodeV2 for ZripEncoder {
57    fn encode(
58        &mut self,
59        input: &mut PartialBuffer<&[u8]>,
60        output: &mut WriteBuffer<'_>,
61    ) -> io::Result<()> {
62        let (consumed, _) = self.process(input.unwritten(), output, EndOp::Continue)?;
63        input.advance(consumed);
64        Ok(())
65    }
66
67    fn flush(&mut self, output: &mut WriteBuffer<'_>) -> io::Result<bool> {
68        let (_, status) = self.process(&[], output, EndOp::Flush)?;
69        Ok(status != Status::NeedsOutput)
70    }
71
72    fn finish(&mut self, output: &mut WriteBuffer<'_>) -> io::Result<bool> {
73        let (_, status) = self.process(&[], output, EndOp::End)?;
74        Ok(status == Status::Finished)
75    }
76}