feat: allow reading uncompressed size (#396)

* feat: add `DecodedSize` trait

Adds a new trait that to retrieve the size of the data when uncompressed. The
implementation of this trait on a format indicates that a format may support
retrieving the uncompressed size, however it's not guaranteed.

* feat(xz2): implement `uncompressed_size` method

* feat(xz): support reading uncompressed size

* feat(lzma): implement reading uncompressed size

* feat(zstd): support reading uncompressed size

* refactor(zstd): return named error

* feat: use explicit 64-bit unsigned int for decoded size

* refactor(zstd): use `FileTooLarge` when failing to convert usize to u64

Author: FineFindus

crates/compression-codecs/src/lib.rs

@@ -97,3 +97,8 @@ pub trait Decode {
         output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
     ) -> Result<bool>;
 }
+
+pub trait DecodedSize {
+    /// Returns the size of the input when uncompressed.
+    fn decoded_size(input: &[u8]) -> Result<u64>;
+}

crates/compression-codecs/src/lzma/decoder.rs

@@ -1,4 +1,4 @@
-use crate::{Decode, Xz2Decoder};
+use crate::{Decode, DecodedSize, Xz2Decoder};
 use compression_core::util::PartialBuffer;
 use std::{convert::TryInto, io::Result};
 
@@ -61,3 +61,9 @@ impl Decode for LzmaDecoder {
         self.inner.finish(output)
     }
 }
+
+impl DecodedSize for LzmaDecoder {
+    fn decoded_size(input: &[u8]) -> Result<u64> {
+        Xz2Decoder::decoded_size(input)
+    }
+}

crates/compression-codecs/src/xz/decoder.rs

@@ -1,4 +1,4 @@
-use crate::{Decode, Xz2Decoder};
+use crate::{Decode, DecodedSize, Xz2Decoder};
 use compression_core::util::PartialBuffer;
 use std::{
     convert::TryInto,
@@ -97,3 +97,9 @@ impl Decode for XzDecoder {
         self.inner.finish(output)
     }
 }
+
+impl DecodedSize for XzDecoder {
+    fn decoded_size(input: &[u8]) -> Result<u64> {
+        Xz2Decoder::decoded_size(input)
+    }
+}

crates/compression-codecs/src/xz2/decoder.rs

@@ -1,7 +1,11 @@
-use crate::{lzma::params::LzmaDecoderParams, Decode};
+use crate::{lzma::params::LzmaDecoderParams, Decode, DecodedSize};
 use compression_core::util::PartialBuffer;
 use liblzma::stream::{Action, Status, Stream};
-use std::{convert::TryFrom, fmt, io};
+use std::{
+    convert::TryFrom,
+    fmt,
+    io::{self, Cursor},
+};
 
 /// Xz2 decoding stream
 pub struct Xz2Decoder {
@@ -108,6 +112,13 @@ impl Decode for Xz2Decoder {
     }
 }
 
+impl DecodedSize for Xz2Decoder {
+    fn decoded_size(input: &[u8]) -> io::Result<u64> {
+        let cursor = Cursor::new(input);
+        liblzma::uncompressed_size(cursor)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::convert::TryFrom;

crates/compression-codecs/src/zstd/decoder.rs

@@ -1,10 +1,12 @@
 use crate::zstd::params::DParameter;
-use crate::Decode;
+use crate::{Decode, DecodedSize};
 use compression_core::unshared::Unshared;
 use compression_core::util::PartialBuffer;
 use libzstd::stream::raw::{Decoder, Operation};
+use std::convert::TryInto;
 use std::io;
 use std::io::Result;
+use zstd_safe::get_error_name;
 
 #[derive(Debug)]
 pub struct ZstdDecoder {
@@ -84,3 +86,14 @@ impl Decode for ZstdDecoder {
         Ok(bytes_left == 0)
     }
 }
+
+impl DecodedSize for ZstdDecoder {
+    fn decoded_size(input: &[u8]) -> Result<u64> {
+        zstd_safe::find_frame_compressed_size(input)
+            .map_err(|error_code| io::Error::other(get_error_name(error_code)))
+            .and_then(|size| {
+                size.try_into()
+                    .map_err(|_| io::Error::from(io::ErrorKind::FileTooLarge))
+            })
+    }
+}