Merge branch 'refs/heads/main' into gaussian_blur

Author: awxkee

Cargo.toml

@@ -43,10 +43,10 @@ num-traits = { version = "0.2.0" }
 color_quant = { version = "1.1", optional = true }
 dav1d = { version = "0.10.3", optional = true }
 exr = { version = "1.5.0", optional = true }
-gif = { version = "0.13", optional = true }
+gif = { version = "0.13.1", optional = true }
 image-webp = { version = "0.2.0", optional = true }
 mp4parse = { version = "0.17.0", optional = true }
-png = { version = "0.17.6", optional = true }
+png = { version = "0.17.11", optional = true }
 qoi = { version = "0.4", optional = true }
 ravif = { version = "0.11.11", default-features = false, optional = true }
 rayon = { version = "1.7.0", optional = true }
@@ -114,4 +114,4 @@ harness = false
 [[bench]]
 path = "benches/blur.rs"
 name = "blur"
-harness = false
+harness = false

deny.toml

@@ -19,16 +19,9 @@ allow = [
     "BSD-2-Clause",
     "BSD-3-Clause",
     "MIT",
-    "MIT-0",
-    "MPL-2.0",
-    "Unicode-DFS-2016",
+    "Unicode-3.0",
 ]
 
-[[licenses.exceptions]]
-allow = ["WTFPL"]
-name = "pcx"
-version = "*"
-
 [advisories]
 yanked = "deny"
 ignore = []
@@ -41,5 +34,4 @@ deny = []
 skip = [
     { name = "bitflags" },   # Some deps depend on 1.3.2 while others on 2.6.0
     { name = "hashbrown" },  # Some deps depend on 0.13.2 while others on 0.14.5
-    { name = "miniz_oxide" } # Some deps depend on 0.7.4 while others on 0.8.0
 ]

src/buffer.rs

@@ -801,7 +801,7 @@ where
     /// the bounds will not overflow.
     fn check_image_fits(width: u32, height: u32, len: usize) -> bool {
         let checked_len = Self::image_buffer_len(width, height);
-        checked_len.map_or(false, |min_len| min_len <= len)
+        checked_len.is_some_and(|min_len| min_len <= len)
     }
 
     fn image_buffer_len(width: u32, height: u32) -> Option<usize> {

src/codecs/avif/yuv.rs

@@ -521,13 +521,23 @@ fn process_halved_chroma_row<
 
     let max_value = (1 << BIT_DEPTH) - 1;
 
+    // If the stride is larger than the plane size,
+    // it might contain junk data beyond the actual valid region.
+    // To avoid processing artifacts when working with odd-sized images,
+    // the buffer is reshaped to its actual size,
+    // preventing accidental use of invalid values from the trailing region.
+
+    let y_plane = &image.y_plane[0..image.width];
+    let chroma_size = (image.width + 1) / 2;
+    let u_plane = &image.u_plane[0..chroma_size];
+    let v_plane = &image.v_plane[0..chroma_size];
+    let rgba = &mut rgba[0..image.width * CHANNELS];
+
     let bias_y = range.bias_y as i32;
     let bias_uv = range.bias_uv as i32;
-    let y_iter = image.y_plane.chunks_exact(2);
+    let y_iter = y_plane.chunks_exact(2);
     let rgb_chunks = rgba.chunks_exact_mut(CHANNELS * 2);
-    for (((y_src, &u_src), &v_src), rgb_dst) in
-        y_iter.zip(image.u_plane).zip(image.v_plane).zip(rgb_chunks)
-    {
+    for (((y_src, &u_src), &v_src), rgb_dst) in y_iter.zip(u_plane).zip(v_plane).zip(rgb_chunks) {
         let y_value: i32 = (y_src[0].as_() - bias_y) * y_coef;
         let cb_value: i32 = u_src.as_() - bias_uv;
         let cr_value: i32 = v_src.as_() - bias_uv;
@@ -571,13 +581,13 @@ fn process_halved_chroma_row<
 
     // Process remainder if width is odd.
     if image.width & 1 != 0 {
-        let y_left = image.y_plane.chunks_exact(2).remainder();
+        let y_left = y_plane.chunks_exact(2).remainder();
         let rgb_chunks = rgba
             .chunks_exact_mut(CHANNELS * 2)
             .into_remainder()
             .chunks_exact_mut(CHANNELS);
-        let u_iter = image.u_plane.iter().rev();
-        let v_iter = image.v_plane.iter().rev();
+        let u_iter = u_plane.iter().rev();
+        let v_iter = v_plane.iter().rev();
 
         for (((y_src, u_src), v_src), rgb_dst) in
             y_left.iter().zip(u_iter).zip(v_iter).zip(rgb_chunks)

src/codecs/jpeg/encoder.rs

@@ -30,6 +30,7 @@ static SOS: u8 = 0xDA;
 static DQT: u8 = 0xDB;
 // Application segments start and end
 static APP0: u8 = 0xE0;
+static APP2: u8 = 0xE2;
 
 // section K.1
 // table K.1
@@ -346,6 +347,8 @@ pub struct JpegEncoder<W> {
     chroma_actable: Cow<'static, [(u8, u16); 256]>,
 
     pixel_density: PixelDensity,
+
+    icc_profile: Vec<u8>,
 }
 
 impl<W: Write> JpegEncoder<W> {
@@ -415,6 +418,8 @@ impl<W: Write> JpegEncoder<W> {
             chroma_actable: Cow::Borrowed(&STD_CHROMA_AC_HUFF_LUT),
 
             pixel_density: PixelDensity::default(),
+
+            icc_profile: Vec::new(),
         }
     }
 
@@ -494,6 +499,9 @@ impl<W: Write> JpegEncoder<W> {
         build_jfif_header(&mut buf, self.pixel_density);
         self.writer.write_segment(APP0, &buf)?;
 
+        // Write ICC profile chunks if present
+        self.write_icc_profile_chunks()?;
+
         build_frame_header(
             &mut buf,
             8,
@@ -648,6 +656,43 @@ impl<W: Write> JpegEncoder<W> {
 
         Ok(())
     }
+
+    fn write_icc_profile_chunks(&mut self) -> io::Result<()> {
+        if self.icc_profile.is_empty() {
+            return Ok(());
+        }
+
+        const MAX_CHUNK_SIZE: usize = 65533 - 14;
+        const MAX_CHUNK_COUNT: usize = 255;
+        const MAX_ICC_PROFILE_SIZE: usize = MAX_CHUNK_SIZE * MAX_CHUNK_COUNT;
+
+        if self.icc_profile.len() > MAX_ICC_PROFILE_SIZE {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "ICC profile too large",
+            ));
+        }
+
+        let chunk_iter = self.icc_profile.chunks(MAX_CHUNK_SIZE);
+        let num_chunks = chunk_iter.len() as u8;
+        let mut segment = Vec::new();
+
+        for (i, chunk) in chunk_iter.enumerate() {
+            let chunk_number = (i + 1) as u8;
+            let length = 14 + chunk.len();
+
+            segment.clear();
+            segment.reserve(length);
+            segment.extend_from_slice(b"ICC_PROFILE\0");
+            segment.push(chunk_number);
+            segment.push(num_chunks);
+            segment.extend_from_slice(chunk);
+
+            self.writer.write_segment(APP2, &segment)?;
+        }
+
+        Ok(())
+    }
 }
 
 impl<W: Write> ImageEncoder for JpegEncoder<W> {
@@ -661,6 +706,11 @@ impl<W: Write> ImageEncoder for JpegEncoder<W> {
     ) -> ImageResult<()> {
         self.encode(buf, width, height, color_type)
     }
+
+    fn set_icc_profile(&mut self, icc_profile: Vec<u8>) -> Result<(), UnsupportedError> {
+        self.icc_profile = icc_profile;
+        Ok(())
+    }
 }
 
 fn build_jfif_header(m: &mut Vec<u8>, density: PixelDensity) {

src/codecs/png.rs

@@ -6,6 +6,7 @@
 //! * <http://www.w3.org/TR/PNG/> - The PNG Specification
 //!
 
+use std::borrow::Cow;
 use std::fmt;
 use std::io::{BufRead, Seek, Write};
 
@@ -482,6 +483,7 @@ pub struct PngEncoder<W: Write> {
     w: W,
     compression: CompressionType,
     filter: FilterType,
+    icc_profile: Vec<u8>,
 }
 
 /// Compression level of a PNG encoder. The default setting is `Fast`.
@@ -535,6 +537,7 @@ impl<W: Write> PngEncoder<W> {
             w,
             compression: CompressionType::default(),
             filter: FilterType::default(),
+            icc_profile: Vec::new(),
         }
     }
 
@@ -559,6 +562,7 @@ impl<W: Write> PngEncoder<W> {
             w,
             compression,
             filter,
+            icc_profile: Vec::new(),
         }
     }
 
@@ -604,7 +608,15 @@ impl<W: Write> PngEncoder<W> {
             FilterType::Adaptive => (png::FilterType::Sub, png::AdaptiveFilterType::Adaptive),
         };
 
-        let mut encoder = png::Encoder::new(self.w, width, height);
+        let mut info = png::Info::with_size(width, height);
+
+        if !self.icc_profile.is_empty() {
+            info.icc_profile = Some(Cow::Borrowed(&self.icc_profile));
+        }
+
+        let mut encoder =
+            png::Encoder::with_info(self.w, info).map_err(|e| ImageError::IoError(e.into()))?;
+
         encoder.set_color(ct);
         encoder.set_depth(bits);
         encoder.set_compression(comp);
@@ -669,6 +681,11 @@ impl<W: Write> ImageEncoder for PngEncoder<W> {
             ))),
         }
     }
+
+    fn set_icc_profile(&mut self, icc_profile: Vec<u8>) -> Result<(), UnsupportedError> {
+        self.icc_profile = icc_profile;
+        Ok(())
+    }
 }
 
 impl ImageError {

src/codecs/pnm/decoder.rs

@@ -692,8 +692,8 @@ where
 
     let token = reader
         .bytes()
-        .skip_while(|v| v.as_ref().ok().map_or(false, is_separator))
-        .take_while(|v| v.as_ref().ok().map_or(false, |c| !is_separator(c)))
+        .skip_while(|v| v.as_ref().ok().is_some_and(is_separator))
+        .take_while(|v| v.as_ref().ok().is_some_and(|c| !is_separator(c)))
         .collect::<Result<Vec<u8>, _>>()?;
 
     if !token.is_ascii() {

src/color.rs

@@ -441,6 +441,7 @@ impl<T: Primitive> FromPrimitive<T> for T {
 // 1.0 (white) was picked as firefox and chrome choose to map NaN to that.
 #[inline]
 fn normalize_float(float: f32, max: f32) -> f32 {
+    #[allow(clippy::neg_cmp_op_on_partial_ord)]
     let clamped = if !(float < 1.0) { 1.0 } else { float.max(0.0) };
     (clamped * max).round()
 }

src/flat.rs

@@ -282,7 +282,7 @@ impl SampleLayout {
     /// Check if a buffer of length `len` is large enough.
     #[must_use]
     pub fn fits(&self, len: usize) -> bool {
-        self.min_length().map_or(false, |min| len >= min)
+        self.min_length().is_some_and(|min| len >= min)
     }
 
     /// The extents of this array, in order of increasing strides.
@@ -747,10 +747,7 @@ impl<Buffer> FlatSamples<Buffer> {
     where
         Buffer: AsRef<[T]>,
     {
-        let min_length = match self.min_length() {
-            None => return None,
-            Some(index) => index,
-        };
+        let min_length = self.min_length()?;
 
         let slice = self.samples.as_ref();
         if slice.len() < min_length {
@@ -765,10 +762,7 @@ impl<Buffer> FlatSamples<Buffer> {
     where
         Buffer: AsMut<[T]>,
     {
-        let min_length = match self.min_length() {
-            None => return None,
-            Some(index) => index,
-        };
+        let min_length = self.min_length()?;
 
         let slice = self.samples.as_mut();
         if slice.len() < min_length {

src/imageops/sample.rs

@@ -879,6 +879,7 @@ where
     let max = S::DEFAULT_MAX_VALUE;
     let max: f32 = NumCast::from(max).unwrap();
 
+    #[allow(clippy::redundant_guards)]
     let sum = match kernel.iter().fold(0.0, |s, &item| s + item) {
         x if x == 0.0 => 1.0,
         sum => sum,