Add support for row pitch in ImageView and ImageViewMut (image-rs#66)

Author: RunDevelopment

src/decode/astc.rs

@@ -84,13 +84,12 @@ macro_rules! astc_decoder {
                     process_blocks,
                 )
             },
-            |RArgs(r, out, row_pitch, rect, context)| {
+            |RArgs(r, out, offset, context)| {
                 for_each_block_rect_untyped::<BLOCK_WIDTH, BLOCK_HEIGHT, BYTES_PER_BLOCK>(
                     r,
                     out,
-                    row_pitch,
+                    offset,
                     context,
-                    rect,
                     NATIVE_COLOR,
                     process_blocks,
                 )

src/decode/bc.rs

@@ -39,13 +39,12 @@ macro_rules! underlying {
                     process_blocks,
                 )
             },
-            |RArgs(r, out, row_pitch, rect, context)| {
+            |RArgs(r, out, offset, context)| {
                 for_each_block_rect_untyped::<4, 4, BYTES_PER_BLOCK>(
                     r,
                     out,
-                    row_pitch,
+                    offset,
                     context,
-                    rect,
                     NATIVE_COLOR,
                     process_blocks,
                 )

src/decode/bi_planar.rs

@@ -42,13 +42,12 @@ macro_rules! underlying {
             |Args(r, out, context)| {
                 for_each_bi_planar(r, out, context, NATIVE_COLOR, INFO, process_bi_planar)
             },
-            |RArgs(r, out, row_pitch, rect, context)| {
+            |RArgs(r, out, offset, context)| {
                 for_each_bi_planar_rect(
                     r,
                     out,
-                    row_pitch,
+                    offset,
                     context,
-                    rect,
                     NATIVE_COLOR,
                     INFO,
                     process_bi_planar,

src/decode/decoder.rs

@@ -2,7 +2,7 @@ use std::io::{Read, Seek};
 use std::mem::size_of;
 
 use crate::{
-    Channels, ColorFormat, ColorFormatSet, DecodingError, ImageViewMut, Precision, Rect, Size,
+    Channels, ColorFormat, ColorFormatSet, DecodingError, ImageViewMut, Offset, Precision, Size,
 };
 
 use super::DecodeOptions;
@@ -11,8 +11,7 @@ pub(crate) type DecodeFn = fn(args: Args) -> Result<(), DecodingError>;
 pub(crate) type DecodeRectFn = fn(args: RArgs) -> Result<(), DecodingError>;
 
 pub(crate) struct DecodeContext {
-    pub color: ColorFormat,
-    pub size: Size,
+    pub surface_size: Size,
     pub memory_limit: usize,
 }
 impl DecodeContext {
@@ -51,75 +50,18 @@ impl<T: Read + Seek> ReadSeek for T {}
 /// The "fix" is to wrap all mutable references in a struct so that compiler
 /// can't see them in the type signature of the function pointer anymore. Truly
 /// silly, and thankfully not necessary on never compiler versions.
-pub(crate) struct Args<'a, 'b>(pub &'a mut dyn Read, pub &'b mut [u8], pub DecodeContext);
-impl<'a, 'b> Args<'a, 'b> {
-    pub fn new(
-        reader: &'a mut dyn Read,
-        output: &'b mut [u8],
-        context: DecodeContext,
-    ) -> Result<Self, DecodingError> {
-        let bytes_per_pixel = context.color.bytes_per_pixel() as u64;
-        assert_eq!(
-            output.len() as u64,
-            context.size.pixels().saturating_mul(bytes_per_pixel)
-        );
-
-        Ok(Self(reader, output, context))
-    }
-}
+pub(crate) struct Args<'a, 'b, 'c>(
+    pub &'a mut dyn Read,
+    pub &'b mut ImageViewMut<'c>,
+    pub DecodeContext,
+);
 
-pub(crate) struct RArgs<'a, 'b>(
+pub(crate) struct RArgs<'a, 'b, 'c>(
     pub &'a mut dyn ReadSeek,
-    pub &'b mut [u8],
-    pub usize,
-    pub Rect,
+    pub &'b mut ImageViewMut<'c>,
+    pub Offset,
     pub DecodeContext,
 );
-impl<'a, 'b> RArgs<'a, 'b> {
-    pub fn new(
-        reader: &'a mut dyn ReadSeek,
-        output: &'b mut [u8],
-        row_pitch: usize,
-        rect: Rect,
-        context: DecodeContext,
-    ) -> Result<Self, DecodingError> {
-        // Check that the rect is within the bounds of the image.
-        if !rect.is_within_bounds(context.size) {
-            return Err(DecodingError::RectOutOfBounds);
-        }
-
-        // Check row pitch
-        let min_row_pitch = if rect.size().is_empty() {
-            0
-        } else {
-            usize::saturating_mul(
-                rect.width as usize,
-                context.color.bytes_per_pixel() as usize,
-            )
-        };
-        if row_pitch < min_row_pitch {
-            return Err(DecodingError::RowPitchTooSmall {
-                required_minimum: min_row_pitch,
-            });
-        }
-
-        // Check that the buffer is long enough
-        // saturate to usize::MAX on overflow
-        let required_bytes = if rect.size().is_empty() {
-            0
-        } else {
-            usize::saturating_mul(row_pitch, (rect.height - 1) as usize)
-                .saturating_add(min_row_pitch)
-        };
-        if output.len() < required_bytes {
-            return Err(DecodingError::RectBufferTooSmall {
-                required_minimum: required_bytes,
-            });
-        }
-
-        Ok(Self(reader, output, row_pitch, rect, context))
-    }
-}
 
 /// Contains decode functions directly. These functions can be used as is.
 pub(crate) struct Decoder {
@@ -219,21 +161,20 @@ impl DecoderSet {
     pub fn decode(
         &self,
         reader: &mut dyn Read,
-        mut image: ImageViewMut,
+        image: &mut ImageViewMut,
         options: &DecodeOptions,
     ) -> Result<(), DecodingError> {
         let color = image.color();
         let size = image.size();
 
-        let args = Args::new(
+        let args = Args(
             reader,
-            image.data(),
+            image,
             DecodeContext {
-                color,
-                size,
+                surface_size: size,
                 memory_limit: options.memory_limit,
             },
-        )?;
+        );
 
         // never decode empty images
         if size.is_empty() {
@@ -251,33 +192,27 @@ impl DecoderSet {
         (decoder.decode_fn)(args)
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn decode_rect(
         &self,
-        color: ColorFormat,
         reader: &mut dyn ReadSeek,
-        size: Size,
-        rect: Rect,
-        output: &mut [u8],
-        row_pitch: usize,
+        image: &mut ImageViewMut,
+        offset: Offset,
+        surface_size: Size,
         options: &DecodeOptions,
     ) -> Result<(), DecodingError> {
-        let args = RArgs::new(
+        let color = image.color();
+
+        debug_assert!(!image.size().is_empty());
+
+        let args = RArgs(
             reader,
-            output,
-            row_pitch,
-            rect,
+            image,
+            offset,
             DecodeContext {
-                color,
-                size,
+                surface_size,
                 memory_limit: options.memory_limit,
             },
-        )?;
-
-        // never decode empty rectangles
-        if rect.size().is_empty() {
-            return Ok(());
-        }
+        );
 
         let decoder = self.get_decoder(color);
         (decoder.decode_rect_fn)(args)

src/decode/mod.rs

@@ -18,7 +18,7 @@ pub(crate) use decoder::*;
 use sub_sampled::*;
 use uncompressed::*;
 
-use crate::{ColorFormat, DecodingError, Format, ImageViewMut, Rect, Size};
+use crate::{util, DecodingError, Format, ImageViewMut, Offset, PixelInfo, Size};
 
 pub(crate) const fn get_decoders(format: Format) -> DecoderSet {
     match format {
@@ -129,20 +129,18 @@ pub(crate) const fn get_decoders(format: Format) -> DecoderSet {
 /// This method will only panic in the given reader panics while reading.
 pub fn decode(
     reader: &mut dyn Read,
-    image: ImageViewMut,
+    mut image: ImageViewMut,
     format: Format,
     options: &DecodeOptions,
 ) -> Result<(), DecodingError> {
-    get_decoders(format).decode(reader, image, options)
+    get_decoders(format).decode(reader, &mut image, options)
 }
 
 /// Decodes a rectangle of the image data of a surface from the given reader
 /// and writes it to the given output buffer.
 ///
-/// ## Row pitch and the output buffer
-///
-/// The `row_pitch` parameter specifies the number of bytes between the start
-/// of one row and the start of the next row in the output buffer.
+/// Note: The rectangle to decode is defined by `offset` and the size of
+/// `image`. The rectangle must be within the bounds of the surface size.
 ///
 /// ## State of the reader
 ///
@@ -159,20 +157,41 @@ pub fn decode(
 /// ## Panics
 ///
 /// This method will only panic in the given reader panics while reading.
-#[allow(clippy::too_many_arguments)]
 pub fn decode_rect<R: Read + Seek>(
     reader: &mut R,
-    output: &mut [u8],
-    row_pitch: usize,
-    color: ColorFormat,
-    size: Size,
-    rect: Rect,
+    mut image: ImageViewMut,
+    offset: Offset,
+    surface_size: Size,
     format: Format,
     options: &DecodeOptions,
 ) -> Result<(), DecodingError> {
     let reader = reader as &mut dyn ReadSeek;
-    let decoders = get_decoders(format);
-    decoders.decode_rect(color, reader, size, rect, output, row_pitch, options)
+
+    return inner(reader, &mut image, offset, surface_size, format, options);
+
+    fn inner(
+        reader: &mut dyn ReadSeek,
+        image: &mut ImageViewMut,
+        offset: Offset,
+        surface_size: Size,
+        format: Format,
+        options: &DecodeOptions,
+    ) -> Result<(), DecodingError> {
+        if !surface_size.contains_rect(offset, image.size()) {
+            return Err(DecodingError::RectOutOfBounds);
+        }
+
+        if image.size().is_empty() {
+            // skip the entire surface
+            let pixel_info = PixelInfo::from(format);
+            let bytes = pixel_info.surface_bytes(surface_size).unwrap_or(u64::MAX);
+            util::io_skip_exact(reader, bytes)?;
+            return Ok(());
+        }
+
+        let decoders = get_decoders(format);
+        decoders.decode_rect(reader, image, offset, surface_size, options)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]