Move bitwriter/reader into common module and consolidate/cleanup constants

Author: zleyyij

src/decoding/bit_reader.rs src/bit_io/bit_reader.rssrc/decoding/bit_reader.rs renamed to src/bit_io/bit_reader.rs

@@ -1,41 +1,10 @@
-use super::errors::GetBitsError;
-
-/// Interact with a provided source at a bit level.
+/// Wraps a slice and enables reading arbitrary amounts of bits
+/// from that slice.
 pub struct BitReader<'s> {
     idx: usize, //index counts bits already read
     source: &'s [u8],
 }
 
-#[cfg(feature = "std")]
-impl std::error::Error for GetBitsError {}
-
-impl core::fmt::Display for GetBitsError {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self {
-            GetBitsError::TooManyBits {
-                num_requested_bits,
-                limit,
-            } => {
-                write!(
-                    f,
-                    "Cant serve this request. The reader is limited to {} bits, requested {} bits",
-                    limit, num_requested_bits,
-                )
-            }
-            GetBitsError::NotEnoughRemainingBits {
-                requested,
-                remaining,
-            } => {
-                write!(
-                    f,
-                    "Can\'t read {} bits, only have {} bits left",
-                    requested, remaining,
-                )
-            }
-        }
-    }
-}
-
 impl<'s> BitReader<'s> {
     pub fn new(source: &'s [u8]) -> BitReader<'s> {
         BitReader { idx: 0, source }
@@ -121,3 +90,46 @@ impl<'s> BitReader<'s> {
         Ok(value)
     }
 }
+
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum GetBitsError {
+    TooManyBits {
+        num_requested_bits: usize,
+        limit: u8,
+    },
+    NotEnoughRemainingBits {
+        requested: usize,
+        remaining: usize,
+    },
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for GetBitsError {}
+
+impl core::fmt::Display for GetBitsError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            GetBitsError::TooManyBits {
+                num_requested_bits,
+                limit,
+            } => {
+                write!(
+                    f,
+                    "Cant serve this request. The reader is limited to {} bits, requested {} bits",
+                    limit, num_requested_bits,
+                )
+            }
+            GetBitsError::NotEnoughRemainingBits {
+                requested,
+                remaining,
+            } => {
+                write!(
+                    f,
+                    "Can\'t read {} bits, only have {} bits left",
+                    requested, remaining,
+                )
+            }
+        }
+    }
+}

src/decoding/bit_reader_reverse.rs src/bit_io/bit_reader_reverse.rssrc/decoding/bit_reader_reverse.rs renamed to src/bit_io/bit_reader_reverse.rs

@@ -0,0 +1,9 @@
+//! Encoding agnostic ways to read and write binary data
+
+mod bit_reader;
+mod bit_reader_reverse;
+mod bit_writer;
+
+pub(crate) use bit_reader::*;
+pub(crate) use bit_reader_reverse::*;
+pub(crate) use bit_writer::*;

src/encoding/bit_writer.rs src/bit_io/bit_writer.rssrc/encoding/bit_writer.rs renamed to src/bit_io/bit_writer.rs

@@ -1,6 +1,6 @@
 //! Utilities and representations for the first half of a block, the literals section.
 //! It contains data that is then copied from by the sequences section.
-use crate::decoding::bit_reader::BitReader;
+use crate::bit_io::BitReader;
 use crate::decoding::errors::LiteralsSectionParseError;
 
 /// A compressed block consists of two sections, a literals section, and a sequences section.

src/bit_io/mod.rs

@@ -0,0 +1,21 @@
+//! Values and interfaces shared between the encoding side
+//! and the decoding side.
+
+// --- FRAMES ---
+/// This magic number is included at the start of a single Zstandard frame
+pub const MAGIC_NUM: u32 = 0xFD2F_B528;
+/// Window size refers to the minimum amount of memory needed to decode any given frame.
+///
+/// The minimum window size is defined as 1 KB
+pub const MIN_WINDOW_SIZE: u64 = 1024;
+/// Window size refers to the minimum amount of memory needed to decode any given frame.
+///
+/// The maximum window size allowed by the spec is 3.75TB
+pub const MAX_WINDOW_SIZE: u64 = (1 << 41) + 7 * (1 << 38);
+
+// --- BLOCKS ---
+/// While the spec limits block size to 128KB, the implementation uses
+/// 128kibibytes
+///
+/// <https://github.com/facebook/zstd/blob/eca205fc7849a61ab287492931a04960ac58e031/doc/educational_decoder/zstd_decompress.c#L28-L29>
+pub const MAX_BLOCK_SIZE: u32 = 128 * 1024;

src/blocks/literals_section.rs

@@ -5,6 +5,7 @@ use super::super::blocks::literals_section::LiteralsSectionType;
 use super::super::blocks::sequence_section::SequencesHeader;
 use super::literals_section_decoder::decode_literals;
 use super::sequence_section_decoder::decode_sequences;
+use crate::common::MAX_BLOCK_SIZE;
 use crate::decoding::errors::DecodeSequenceError;
 use crate::decoding::errors::{
     BlockHeaderReadError, BlockSizeError, BlockTypeError, DecodeBlockContentError,
@@ -34,8 +35,6 @@ pub fn new() -> BlockDecoder {
     }
 }
 
-pub(crate) const ABSOLUTE_MAXIMUM_BLOCK_SIZE: u32 = 128 * 1024;
-
 impl BlockDecoder {
     pub fn decode_block_content(
         &mut self,
@@ -296,7 +295,7 @@ impl BlockDecoder {
 
     fn block_content_size(&self) -> Result<u32, BlockSizeError> {
         let val = self.block_content_size_unchecked();
-        if val > ABSOLUTE_MAXIMUM_BLOCK_SIZE {
+        if val > MAX_BLOCK_SIZE {
             Err(BlockSizeError::BlockSizeTooLarge { size: val })
         } else {
             Ok(val)

src/common/mod.rs

@@ -1,5 +1,6 @@
 //! Errors that might occur while decoding zstd formatted data
 
+use crate::bit_io::GetBitsError;
 use crate::blocks::block::BlockType;
 use crate::blocks::literals_section::LiteralsSectionType;
 use crate::io::Error;
@@ -8,19 +9,6 @@ use core::fmt;
 #[cfg(feature = "std")]
 use std::error::Error as StdError;
 
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum GetBitsError {
-    TooManyBits {
-        num_requested_bits: usize,
-        limit: u8,
-    },
-    NotEnoughRemainingBits {
-        requested: usize,
-        remaining: usize,
-    },
-}
-
 #[derive(Debug)]
 #[non_exhaustive]
 pub enum FrameDescriptorError {
@@ -61,13 +49,13 @@ impl fmt::Display for FrameHeaderError {
                 f,
                 "window_size bigger than allowed maximum. Is: {}, Should be lower than: {}",
                 got,
-                crate::decoding::frame::MAX_WINDOW_SIZE
+                crate::common::MAX_WINDOW_SIZE
             ),
             Self::WindowTooSmall { got } => write!(
                 f,
                 "window_size smaller than allowed minimum. Is: {}, Should be greater than: {}",
                 got,
-                crate::decoding::frame::MIN_WINDOW_SIZE
+                crate::common::MIN_WINDOW_SIZE
             ),
             Self::FrameDescriptorError(e) => write!(f, "{:?}", e),
             Self::DictIdTooSmall { got, expected } => write!(
@@ -261,7 +249,7 @@ impl core::fmt::Display for BlockSizeError {
                 write!(
                     f,
                     "Blocksize was bigger than the absolute maximum {} (128kb). Is: {}",
-                    crate::decoding::block_decoder::ABSOLUTE_MAXIMUM_BLOCK_SIZE,
+                    crate::common::MAX_BLOCK_SIZE,
                     size,
                 )
             }
@@ -532,7 +520,7 @@ impl core::fmt::Display for FrameDecoderError {
                     f,
                     "Specified window_size is too big; Requested: {}, Max: {}",
                     requested,
-                    crate::decoding::frame::MAX_WINDOW_SIZE,
+                    crate::common::MAX_WINDOW_SIZE,
                 )
             }
             FrameDecoderError::DictionaryDecodeError(e) => {