100 lines
2.5 KiB
Rust
100 lines
2.5 KiB
Rust
use crate::{DecodeV2, DecodedSize, Xz2Decoder};
|
|
use compression_core::util::{PartialBuffer, WriteBuffer};
|
|
use std::{
|
|
convert::TryInto,
|
|
io::{Error, ErrorKind, Result},
|
|
};
|
|
|
|
/// Xz decoding stream
|
|
#[derive(Debug)]
|
|
pub struct XzDecoder {
|
|
inner: Xz2Decoder,
|
|
skip_padding: Option<u8>,
|
|
}
|
|
|
|
impl Default for XzDecoder {
|
|
fn default() -> Self {
|
|
Self {
|
|
inner: Xz2Decoder::new(usize::MAX.try_into().unwrap()),
|
|
skip_padding: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl XzDecoder {
|
|
pub fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
|
|
pub fn with_memlimit(memlimit: u64) -> Self {
|
|
Self {
|
|
inner: Xz2Decoder::new(memlimit),
|
|
skip_padding: None,
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "xz-parallel")]
|
|
pub fn parallel(threads: std::num::NonZeroU32, memlimit: u64) -> Self {
|
|
Self {
|
|
inner: Xz2Decoder::parallel(threads, memlimit),
|
|
skip_padding: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl DecodeV2 for XzDecoder {
|
|
fn reinit(&mut self) -> Result<()> {
|
|
self.skip_padding = Some(4);
|
|
self.inner.reinit()
|
|
}
|
|
|
|
fn decode(
|
|
&mut self,
|
|
input: &mut PartialBuffer<&[u8]>,
|
|
output: &mut WriteBuffer<'_>,
|
|
) -> Result<bool> {
|
|
if let Some(ref mut count) = self.skip_padding {
|
|
while input.unwritten().first() == Some(&0) {
|
|
input.advance(1);
|
|
*count -= 1;
|
|
if *count == 0 {
|
|
*count = 4;
|
|
}
|
|
}
|
|
if input.unwritten().is_empty() {
|
|
return Ok(true);
|
|
}
|
|
// If this is non-padding then it cannot start with null bytes, so it must be invalid
|
|
// padding
|
|
if *count != 4 {
|
|
return Err(Error::new(
|
|
ErrorKind::InvalidData,
|
|
"stream padding was not a multiple of 4 bytes",
|
|
));
|
|
}
|
|
self.skip_padding = None;
|
|
}
|
|
self.inner.decode(input, output)
|
|
}
|
|
|
|
fn flush(&mut self, output: &mut WriteBuffer<'_>) -> Result<bool> {
|
|
if self.skip_padding.is_some() {
|
|
return Ok(true);
|
|
}
|
|
self.inner.flush(output)
|
|
}
|
|
|
|
fn finish(&mut self, output: &mut WriteBuffer<'_>) -> Result<bool> {
|
|
if self.skip_padding.is_some() {
|
|
return Ok(true);
|
|
}
|
|
self.inner.finish(output)
|
|
}
|
|
}
|
|
|
|
impl DecodedSize for XzDecoder {
|
|
fn decoded_size(input: &[u8]) -> Result<u64> {
|
|
Xz2Decoder::decoded_size(input)
|
|
}
|
|
}
|