Address API reviews

Author: antoyo

src/stream/raw.rs

@@ -179,23 +179,17 @@ impl<'a> Decoder<'a> {
     // TODO: remove self?
     /// Read a skippable frame.
     pub fn read_skippable_frame(&self, dest: &mut Vec<u8>, input: &[u8]) -> io::Result<(usize, MagicVariant)> {
-        use zstd_safe::DCtx;
-
         let mut magic_variant = 0;
-        DCtx::read_skippable_frame(&mut OutBuffer::around(dest), &mut magic_variant, input)
+        zstd_safe::read_skippable_frame(dest, &mut magic_variant, input)
             .map(|written| (written, MagicVariant(magic_variant as u8)))
             .map_err(map_error_code)
     }
 
     #[cfg(feature = "experimental")]
     // TODO: remove self?
     /// Check if a frame is skippable.
-    pub fn is_skippable_frame(&self, input: &[u8]) -> io::Result<bool> {
-        use zstd_safe::DCtx;
-
-        DCtx::is_skippable_frame(input)
-            .map(|is_skippable| is_skippable != 0)
-            .map_err(map_error_code)
+    pub fn is_skippable_frame(&self, input: &[u8]) -> bool {
+        zstd_safe::is_skippable_frame(input)
     }
 }
 

src/stream/read/mod.rs

@@ -154,7 +154,7 @@ impl<'a, R: Read + Seek> Decoder<'a, BufReader<R>> {
             let op = self.reader.operation();
             // FIXME: I feel like we should do that check right after reading the magic number, but
             // ZSTD does it after reading the content size.
-            if !op.is_skippable_frame(&magic_buffer)? {
+            if !op.is_skippable_frame(&magic_buffer) {
                 bytes_to_seek = U32_SIZE * 2;
                 return Err(io::Error::new(io::ErrorKind::Other, "Unsupported frame parameter"));
             }

src/stream/zio/writer.rs

@@ -134,15 +134,13 @@ where
     /// Write a skippable frame after finishing the previous frame if needed.
     #[cfg(feature = "experimental")]
     pub fn write_skippable_frame(&mut self, buf: &[u8], magic_variant: u32) -> io::Result<()> {
-        use zstd_safe::CCtx;
-
         use crate::map_error_code;
 
         if self.writing_frame {
             self.finish()?; // Since we're about to overwrite the buffer, flush its content to the destination.
         }
 
-        CCtx::write_skippable_frame(&mut OutBuffer::around(&mut self.buffer), buf, magic_variant)
+        zstd_safe::write_skippable_frame(&mut self.buffer, buf, magic_variant)
             .map_err(map_error_code)?;
         self.offset = 0;
         self.write_from_offset()?;

zstd-safe/src/lib.rs

@@ -444,23 +444,6 @@ impl<'a> CCtx<'a> {
         })
     }
 
-    #[cfg(feature = "experimental")]
-    // TODO: use InBuffer?
-    pub fn write_skippable_frame<C: WriteBuf + ?Sized>(output: &mut OutBuffer<'_, C>, input: &[u8], magic_variant: u32) -> SafeResult {
-        let input_len = input.len();
-        unsafe {
-            output.dst.write_from(|buffer, capacity| {
-                parse_code(zstd_sys::ZSTD_writeSkippableFrame(
-                    buffer,
-                    capacity,
-                    input.as_ptr() as *mut _,
-                    input_len,
-                    magic_variant,
-                ))
-            })
-        }
-    }
-
     /// Performs a step of a streaming compression operation.
     ///
     /// This will read some data from `input` and/or write some data to `output`.
@@ -821,6 +804,45 @@ impl Default for DCtx<'_> {
     }
 }
 
+#[cfg(feature = "experimental")]
+pub fn read_skippable_frame<C: WriteBuf + ?Sized>(dst: &mut C, magic_variant: &mut u32, input: &[u8]) -> SafeResult {
+    let input_len = input.len();
+    unsafe {
+        dst.write_from(|buffer, capacity| {
+            parse_code(zstd_sys::ZSTD_readSkippableFrame(
+                    buffer,
+                    capacity,
+                    magic_variant,
+                    ptr_void(input),
+                    input_len,
+            ))
+        })
+    }
+}
+
+#[cfg(feature = "experimental")]
+pub fn write_skippable_frame<C: WriteBuf + ?Sized>(dst: &mut C, input: &[u8], magic_variant: u32) -> SafeResult {
+    let input_len = input.len();
+    unsafe {
+        dst.write_from(|buffer, capacity| {
+            parse_code(zstd_sys::ZSTD_writeSkippableFrame(
+                    buffer,
+                    capacity,
+                    input.as_ptr() as *mut _,
+                    input_len,
+                    magic_variant,
+            ))
+        })
+    }
+}
+
+#[cfg(feature = "experimental")]
+pub fn is_skippable_frame(input: &[u8]) -> bool {
+    unsafe {
+        zstd_sys::ZSTD_isSkippableFrame(ptr_void(input), input.len()) > 0
+    }
+}
+
 impl<'a> DCtx<'a> {
     /// Try to create a new decompression context.
     ///
@@ -920,29 +942,6 @@ impl<'a> DCtx<'a> {
         }
     }
 
-    #[cfg(feature = "experimental")]
-    pub fn read_skippable_frame<C: WriteBuf + ?Sized>(output: &mut OutBuffer<'_, C>, magic_variant: &mut u32, input: &[u8]) -> SafeResult {
-        let input_len = input.len();
-        unsafe {
-            output.dst.write_from(|buffer, capacity| {
-                parse_code(zstd_sys::ZSTD_readSkippableFrame(
-                    buffer,
-                    capacity,
-                    magic_variant,
-                    input.as_ptr() as *mut _,
-                    input_len,
-                ))
-            })
-        }
-    }
-
-    #[cfg(feature = "experimental")]
-    pub fn is_skippable_frame(input: &[u8]) -> SafeResult {
-        unsafe {
-            parse_code(zstd_sys::ZSTD_isSkippableFrame(input.as_ptr() as *mut _, input.len()) as usize)
-        }
-    }
-
     /// Wraps the `ZSTD_initCStream()` function.
     ///
     /// Initializes an existing `DStream` for decompression.