#![forbid(unsafe_code)]
use alloc::vec::Vec;
use crate::frame_state::EncodeState;
use crate::strategy::{self, LevelParams};
use zrip_core::dict::Dictionary;
use zrip_core::error::CompressError;
pub use zrip_core::push::{Progress, Status};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EndOp {
Continue,
Flush,
End,
}
pub struct PushEncoder {
frame: EncodeState,
level: i32,
opts: Option<strategy::Options>,
pending: Vec<u8>,
pending_pos: usize,
header_written: bool,
frame_done: bool,
error: Option<CompressError>,
}
impl core::fmt::Debug for PushEncoder {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("PushEncoder")
.field("pending_output", &(self.pending.len() - self.pending_pos))
.field("error", &self.error)
.finish_non_exhaustive()
}
}
impl PushEncoder {
pub fn new(level: i32) -> Result<Self, CompressError> {
let params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
Ok(Self::from_params(level, None, params, None))
}
pub fn with_options(level: i32, opts: &strategy::Options) -> Result<Self, CompressError> {
let mut params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
strategy::apply_options(&mut params, opts);
Ok(Self::from_params(level, Some(opts.clone()), params, None))
}
pub fn with_dict(level: i32, dict: Dictionary) -> Result<Self, CompressError> {
let params = strategy::level_params(level).ok_or(CompressError::InvalidLevel(level))?;
Ok(Self::from_params(level, None, params, Some(dict)))
}
fn from_params(
level: i32,
opts: Option<strategy::Options>,
params: LevelParams,
dict: Option<Dictionary>,
) -> Self {
Self {
frame: EncodeState::new(params, dict),
level,
opts,
pending: Vec::new(),
pending_pos: 0,
header_written: false,
frame_done: false,
error: None,
}
}
pub fn encode(
&mut self,
input: &[u8],
output: &mut [u8],
op: EndOp,
) -> Result<Progress, CompressError> {
if let Some(e) = &self.error {
return Err(e.clone());
}
let mut consumed = 0;
let mut produced = 0;
let result = self.run(input, output, op, &mut consumed, &mut produced);
match result {
Ok(status) => Ok(Progress {
consumed,
produced,
status,
}),
Err(e) => {
self.error = Some(e.clone());
Err(e)
}
}
}
pub fn encode_to_vec(
&mut self,
input: &[u8],
output: &mut Vec<u8>,
op: EndOp,
) -> Result<(), CompressError> {
if let Some(e) = &self.error {
return Err(e.clone());
}
output.extend_from_slice(&self.pending[self.pending_pos..]);
self.pending.clear();
self.pending_pos = 0;
if self.frame_done {
self.end_frame();
if input.is_empty() {
return Ok(());
}
}
let mut consumed = 0;
loop {
if self.frame_done {
self.end_frame();
return Ok(());
}
match self.advance(input, &mut consumed, op, output) {
Ok(true) => {}
Ok(false) => return Ok(()),
Err(e) => {
self.error = Some(e.clone());
return Err(e);
}
}
}
}
pub fn has_pending_output(&self) -> bool {
self.pending_pos < self.pending.len()
}
pub fn reset(&mut self) {
self.frame.reset();
self.pending.clear();
self.pending_pos = 0;
self.header_written = false;
self.frame_done = false;
self.error = None;
}
fn run(
&mut self,
input: &[u8],
output: &mut [u8],
op: EndOp,
consumed: &mut usize,
produced: &mut usize,
) -> Result<Status, CompressError> {
loop {
if self.has_pending_output() {
let src = &self.pending[self.pending_pos..];
let n = src.len().min(output.len() - *produced);
output[*produced..*produced + n].copy_from_slice(&src[..n]);
*produced += n;
self.pending_pos += n;
if self.has_pending_output() {
return Ok(Status::NeedsOutput);
}
}
self.pending.clear();
self.pending_pos = 0;
if self.frame_done {
self.end_frame();
return Ok(Status::Finished);
}
let mut pending = core::mem::take(&mut self.pending);
let advanced = self.advance(input, consumed, op, &mut pending);
self.pending = pending;
if !advanced? {
return Ok(Status::NeedsInput);
}
}
}
fn advance(
&mut self,
input: &[u8],
consumed: &mut usize,
op: EndOp,
out: &mut Vec<u8>,
) -> Result<bool, CompressError> {
if op == EndOp::End && !self.header_written {
let rest = &input[*consumed..];
if self.frame.buffered() == 0 {
self.one_pass(Some(rest), out)?;
*consumed = input.len();
self.frame_done = true;
return Ok(true);
}
if self.frame.buffered() + rest.len() <= self.frame.block_size() {
*consumed += self.frame.take_input(rest);
self.one_pass(None, out)?;
self.frame_done = true;
return Ok(true);
}
}
*consumed += self.frame.take_input(&input[*consumed..]);
let more_input = *consumed < input.len();
let full = self.frame.buffered() == self.frame.block_size();
let last = !more_input && op == EndOp::End;
let due = (full && more_input)
|| last
|| (!more_input && op == EndOp::Flush && self.frame.buffered() > 0);
if !due {
return Ok(false);
}
if !self.header_written {
self.frame.write_header(out)?;
self.header_written = true;
}
self.frame.encode_block(last, out)?;
if last {
self.frame.write_checksum(out);
self.frame_done = true;
}
Ok(true)
}
fn one_pass(&mut self, input: Option<&[u8]>, out: &mut Vec<u8>) -> Result<(), CompressError> {
let len = input.map_or_else(|| self.frame.buffered(), <[u8]>::len);
let params = match (self.frame.dict(), &self.opts) {
(Some(dict), _) => {
strategy::level_params_with_prefix(self.level, dict.content().len(), len)
}
(None, Some(opts)) => Some(crate::params_with_options(self.level, len, opts)?),
(None, None) => strategy::level_params_for_size(self.level, len),
}
.ok_or(CompressError::InvalidLevel(self.level))?;
self.frame.encode_one_pass(input, ¶ms, out)
}
fn end_frame(&mut self) {
self.frame_done = false;
self.header_written = false;
self.frame.reset();
}
}