Further speed optimizations

TESTING.md

@@ -37,7 +37,9 @@ the CI toolchain, validator, or corpus forward deliberately.
 - pixel-for-pixel comparison of the `image` crate integration hook output
   (`ImageReader`/`DynamicImage::from_decoder`) against the direct Rust decode
   for every comparable verifier file, including exact ICC-profile equality
-  through the hook decoder's `ImageDecoder::icc_profile`
+  through the hook decoder's `ImageDecoder::icc_profile`; this reproduces
+  Ente's production hook shape, including its explicit guardrails,
+  `with_guessed_format`, `Limits::reserve`, and `set_limits`
 - embedded ICC colour-profile comparison against the validator's PNG output:
   when `heif-dec` embeds a profile, the Rust PNG must carry byte-identical
   profile data; a Rust-only profile is allowed (the Rust decoder synthesizes

scripts/heic_tests.sh

@@ -419,9 +419,9 @@ fn main() -> Result<(), Box<dyn Error>> {
 RS
 
   cat > "$HELPER_DIR/src/bin/heif-image-adapter-bench.rs" <<'RS'
-use heic_decoder::image_integration::register_image_decoder_hooks;
-use heic_decoder::{DecodedRgbaImage, DecodedRgbaPixels, decode_path_to_rgba};
-use image::{DynamicImage, ImageReader};
+use heic_decoder::image_integration::register_image_decoder_hooks_with_guardrails;
+use heic_decoder::{DecodeGuardrails, DecodedRgbaImage, DecodedRgbaPixels, decode_path_to_rgba};
+use image::{DynamicImage, ImageDecoder, ImageReader, Limits};
 use std::error::Error;
 use std::path::Path;
 
@@ -462,8 +462,18 @@ fn main() -> Result<(), Box<dyn Error>> {
     let value = match args[1].as_str() {
         "direct" => direct_checksum(&decode_path_to_rgba(input)?),
         "adapter" => {
-            let _ = register_image_decoder_hooks();
-            let decoded = ImageReader::open(input)?.decode()?;
+            let _ = register_image_decoder_hooks_with_guardrails(DecodeGuardrails {
+                max_input_bytes: Some(128 * 1024 * 1024),
+                max_pixels: Some(256_000_000),
+                max_temp_spool_bytes: Some(256 * 1024 * 1024),
+                temp_spool_directory: None,
+            });
+            let mut decoder = ImageReader::open(input)?.with_guessed_format()?.into_decoder()?;
+            let _icc_profile = decoder.icc_profile()?;
+            let mut limits = Limits::default();
+            limits.reserve(decoder.total_bytes())?;
+            decoder.set_limits(limits)?;
+            let decoded = DynamicImage::from_decoder(decoder)?;
             let (width, height) = (decoded.width(), decoded.height());
             let pixels = match decoded {
                 DynamicImage::ImageRgba8(buffer) => checksum(buffer.as_raw()),
@@ -480,9 +490,9 @@ fn main() -> Result<(), Box<dyn Error>> {
 RS
 
   cat > "$HELPER_DIR/src/bin/heif-image-hook-check.rs" <<'RS'
-use heic_decoder::image_integration::register_image_decoder_hooks;
-use heic_decoder::{DecodedRgbaPixels, decode_path_to_rgba};
-use image::{DynamicImage, ImageDecoder, ImageReader};
+use heic_decoder::image_integration::register_image_decoder_hooks_with_guardrails;
+use heic_decoder::{DecodeGuardrails, DecodedRgbaPixels, decode_path_to_rgba};
+use image::{DynamicImage, ImageDecoder, ImageReader, Limits};
 use std::error::Error;
 use std::path::Path;
 
@@ -495,9 +505,17 @@ fn main() -> Result<(), Box<dyn Error>> {
     let input = Path::new(&args[1]);
     let direct = decode_path_to_rgba(input)?;
 
-    let _ = register_image_decoder_hooks();
-    let mut decoder = ImageReader::open(input)?.into_decoder()?;
+    let _ = register_image_decoder_hooks_with_guardrails(DecodeGuardrails {
+        max_input_bytes: Some(128 * 1024 * 1024),
+        max_pixels: Some(256_000_000),
+        max_temp_spool_bytes: Some(256 * 1024 * 1024),
+        temp_spool_directory: None,
+    });
+    let mut decoder = ImageReader::open(input)?.with_guessed_format()?.into_decoder()?;
     let icc_profile = decoder.icc_profile()?;
+    let mut limits = Limits::default();
+    limits.reserve(decoder.total_bytes())?;
+    decoder.set_limits(limits)?;
     if icc_profile != direct.icc_profile {
         return Err("image hook ICC profile differs from direct decode".into());
     }

src/bin/heif-image-adapter-bench.rs

@@ -1,6 +1,6 @@
-use heic_decoder::image_integration::register_image_decoder_hooks;
-use heic_decoder::{DecodedRgbaPixels, decode_path_to_rgb8, decode_path_to_rgba};
-use image::{DynamicImage, ImageReader};
+use heic_decoder::image_integration::register_image_decoder_hooks_with_guardrails;
+use heic_decoder::{DecodeGuardrails, DecodedRgbaPixels, decode_path_to_rgb8, decode_path_to_rgba};
+use image::{DynamicImage, ImageDecoder, ImageReader, Limits};
 use std::env;
 use std::error::Error;
 use std::fmt::{Display, Formatter};
@@ -80,10 +80,26 @@ fn bench_direct(input_path: &Path) -> Result<u64, Box<dyn Error>> {
     Ok(((decoded.width as u64) << 32) ^ (decoded.height as u64) ^ checksum)
 }
 
-fn bench_adapter(input_path: &Path) -> Result<u64, Box<dyn Error>> {
-    let _ = register_image_decoder_hooks();
+fn decode_adapter(input_path: &Path) -> Result<DynamicImage, Box<dyn Error>> {
+    let _ = register_image_decoder_hooks_with_guardrails(DecodeGuardrails {
+        max_input_bytes: Some(128 * 1024 * 1024),
+        max_pixels: Some(256_000_000),
+        max_temp_spool_bytes: Some(256 * 1024 * 1024),
+        temp_spool_directory: None,
+    });
+
+    let mut decoder = ImageReader::open(input_path)?
+        .with_guessed_format()?
+        .into_decoder()?;
+    let _icc_profile = decoder.icc_profile()?;
+    let mut limits = Limits::default();
+    limits.reserve(decoder.total_bytes())?;
+    decoder.set_limits(limits)?;
+    Ok(DynamicImage::from_decoder(decoder)?)
+}
 
-    let decoded = ImageReader::open(input_path)?.decode()?;
+fn bench_adapter(input_path: &Path) -> Result<u64, Box<dyn Error>> {
+    let decoded = decode_adapter(input_path)?;
     let (width, height) = (decoded.width(), decoded.height());
     let checksum = match decoded {
         DynamicImage::ImageRgba8(buffer) => small_checksum(buffer.as_raw()),
@@ -105,8 +121,7 @@ fn bench_rgb(input_path: &Path) -> Result<u64, Box<dyn Error>> {
 }
 
 fn decode_adapter_rgb(input_path: &Path) -> Result<image::RgbImage, Box<dyn Error>> {
-    let _ = register_image_decoder_hooks();
-    Ok(ImageReader::open(input_path)?.decode()?.into_rgb8())
+    Ok(decode_adapter(input_path)?.into_rgb8())
 }
 
 fn bench_adapter_rgb(input_path: &Path) -> Result<u64, Box<dyn Error>> {