OpenEXR basic support

Cargo.toml

@@ -36,6 +36,7 @@ rgb = { version = "0.8.25", optional = true }
 mp4parse = { version = "0.11.5", optional = true }
 dav1d = { version = "0.6.0", optional = true }
 dcv-color-primitives = { version = "0.1.16", optional = true }
+exr = { version = "1.3.0", optional = true }
 color_quant = "1.1"
 
 [dev-dependencies]
@@ -47,7 +48,7 @@ criterion = "0.3"
 
 [features]
 # TODO: Add "avif" to this list while preparing for 0.24.0
-default = ["gif", "jpeg", "ico", "png", "pnm", "tga", "tiff", "webp", "bmp", "hdr", "dxt", "dds", "farbfeld", "jpeg_rayon"]
+default = ["gif", "jpeg", "ico", "png", "pnm", "tga", "tiff", "webp", "bmp", "hdr", "dxt", "dds", "farbfeld", "jpeg_rayon", "openexr"]
 
 ico = ["bmp", "png"]
 pnm = []
@@ -58,6 +59,7 @@ hdr = ["scoped_threadpool"]
 dxt = []
 dds = ["dxt"]
 farbfeld = []
+openexr = ["exr"]
 
 # Enables multi-threading.
 # Requires latest stable Rust.

Cargo.toml.public-private-dependencies

@@ -38,6 +38,7 @@ tiff = { version = "0.6.0", optional = true }
 ravif = { version = "0.6.0", optional = true }
 rgb = { version = "0.8.25", optional = true }
 color_quant = { version = "1.1", public = true }
+exr = { version = "1.3.0", optional = true }
 
 [dev-dependencies]
 crc32fast = "1.2.0"
@@ -46,7 +47,7 @@ glob = "0.3"
 quickcheck = "0.9"
 
 [features]
-default = ["gif", "jpeg", "ico", "png", "pnm", "tga", "tiff", "webp", "bmp", "hdr", "dxt", "dds", "jpeg_rayon"]
+default = ["gif", "jpeg", "ico", "png", "pnm", "tga", "tiff", "webp", "bmp", "hdr", "dxt", "dds", "jpeg_rayon", "openexr"]
 
 ico = ["bmp", "png"]
 pnm = []
@@ -57,5 +58,6 @@ hdr = ["scoped_threadpool"]
 dxt = []
 dds = ["dxt"]
 jpeg_rayon = ["jpeg/rayon"]
+openexr = ["exr"]
 
 benchmarks = []

README.md

@@ -23,14 +23,15 @@ All image processing functions provided operate on types that implement the `Gen
 | PNG    | All supported color types | Same as decoding |
 | JPEG   | Baseline and progressive | Baseline JPEG |
 | GIF    | Yes | Yes |
-| BMP    | Yes | RGB(8), RGBA(8), Gray(8), GrayA(8) |
+| BMP    | Yes | Rgb8, Rgba8, Gray8, GrayA8 |
 | ICO    | Yes | Yes |
-| TIFF   | Baseline(no fax support) + LZW + PackBits | RGB(8), RGBA(8), Gray(8) |
+| TIFF   | Baseline(no fax support) + LZW + PackBits | Rgb8, Rgba8, Gray8 |
 | WebP   | Lossy(Luma channel only) | No |
 | AVIF   | Only 8-bit | Lossy |
 | PNM    | PBM, PGM, PPM, standard PAM | Yes |
 | DDS    | DXT1, DXT3, DXT5 | No |
-| TGA    | Yes | RGB(8), RGBA(8), BGR(8), BGRA(8), Gray(8), GrayA(8) |
+| TGA    | Yes | Rgb8, Rgba8, Bgr8, Bgra8, Gray8, GrayA8 |
+| OpenEXR  | Rgb32F, Rgba32F (no dwa compression) | Rgb32F, Rgba32F (no dwa compression) |
 | farbfeld | Yes | Yes |
 
 ### The [`ImageDecoder`](https://docs.rs/image/*/image/trait.ImageDecoder.html) and [`ImageDecoderExt`](https://docs.rs/image/*/image/trait.ImageDecoderExt.html) Traits

fuzz/Cargo.toml

@@ -60,3 +60,7 @@ path = "fuzzers/fuzzer_script_ico.rs"
 [[bin]]
 name = "fuzzer_script_hdr"
 path = "fuzzers/fuzzer_script_hdr.rs"
+
+[[bin]]
+name = "fuzzer_script_exr"
+path = "fuzzers/fuzzer_script_exr.rs"

fuzz/fuzzers/fuzzer_script_exr.rs

@@ -0,0 +1,59 @@
+#![no_main]
+#[macro_use] extern crate libfuzzer_sys;
+extern crate image;
+
+use std::io::Cursor;
+use image::ImageResult;
+use image::codecs::openexr::*;
+use image::Rgba32FImage;
+use std::io::Seek;
+use std::io::BufRead;
+use std::convert::TryFrom;
+use image::ImageDecoder;
+
+
+// "just dont panic"
+fn roundtrip(bytes: &[u8]) -> ImageResult<()> {
+    use std::io::Write;
+
+    /// Read the file from the specified path into an `Rgba32FImage`.
+    // TODO this method should probably already exist in the main image crate
+    fn read_as_rgba_byte_image(read: impl BufRead + Seek) -> ImageResult<(usize,usize,Vec<u8>)> {
+        let decoder = OpenExrDecoder::with_alpha_preference(read, Some(true))?;
+        let (width, height) = decoder.dimensions();
+
+        let mut buffer = vec![0; usize::try_from(decoder.total_bytes()).unwrap()];
+        decoder.read_image(buffer.as_mut_slice())?;
+
+        Ok((width, height, buffer))
+    }
+
+    /// Write an `Rgba32FImage`.
+    /// Assumes the writer is buffered. In most cases,
+    /// you should wrap your writer in a `BufWriter` for best performance.
+    // TODO this method should probably already exist in the main image crate
+    fn write_rgba_image(write: impl Write/* + Seek*/, image: &Rgba32FImage) -> ImageResult<()> {
+        OpenExrEncoder::new(write).write_image(
+            bytemuck::cast_slice(image.as_raw().as_slice()),
+            image.width(), image.height(),
+            ColorType::Rgba32F
+        )
+    }
+
+
+
+    let decoded_image = read_as_rgba_byte_image(Cursor::new(bytes))?;
+
+    let mut bytes = Vec::with_capacity(bytes.len() + 20);
+    write_rgba_image(Cursor::new(&mut bytes), &decoded_image)?;
+
+    let redecoded_image = read_as_rgba_byte_image(Cursor::new(bytes))?;
+
+    // if both images are valid, assert read/write consistency
+    assert_eq!(decoded_image, redecoded_image, "image was valid but was not reproducible");
+    Ok(())
+}
+
+fuzz_target!(|data: &[u8]| {
+    let _img = roundtrip(data); // fixme not optimized away?
+});

src/buffer.rs

@@ -896,8 +896,9 @@ where
     /// Saves the buffer to a file at the path specified.
     ///
     /// The image format is derived from the file extension.
-    /// Currently only jpeg, png, ico, pnm, bmp and 
+    /// Currently only jpeg, png, ico, pnm, bmp and
     /// tiff files are supported.
+    // TODO exr supported, but Rgba32F is not yet
     pub fn save<Q>(&self, path: Q) -> ImageResult<()>
     where
         Q: AsRef<Path>,
@@ -948,6 +949,9 @@ where
 {
     /// Writes the buffer to a writer in the specified format.
     ///
+    /// Assumes the writer is buffered. In most cases,
+    /// you should wrap your writer in a `BufWriter` for best performance.
+    ///
     /// See [`ImageOutputFormat`](../enum.ImageOutputFormat.html) for
     /// supported types.
     ///
@@ -1340,6 +1344,14 @@ pub(crate) type Gray16Image = ImageBuffer<Luma<u16>, Vec<u16>>;
 /// Sendable 16-bit grayscale + alpha channel image buffer
 pub(crate) type GrayAlpha16Image = ImageBuffer<LumaA<u16>, Vec<u16>>;
 
+/// An image buffer for 32-bit float RGB pixels,
+/// where the backing container is a flattened vector of floats.
+pub type Rgb32FImage = ImageBuffer<Rgb<f32>, Vec<f32>>;
+
+/// An image buffer for 32-bit float RGBA pixels,
+/// where the backing container is a flattened vector of floats.
+pub type Rgba32FImage = ImageBuffer<Rgba<f32>, Vec<f32>>;
+
 #[cfg(test)]
 mod test {
     use super::{ImageBuffer, RgbImage};