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.1.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.

src/codecs/openexr.rs

@@ -0,0 +1,184 @@
+//! Decoding of OpenEXR (.exr) Images
+//!
+//! OpenEXR is an image format that is widely used, especially in VFX,
+//! because it supports lossless and lossy compression for float data.
+//!
+//! # Related Links
+//! * <https://www.openexr.com/documentation.html> - The OpenEXR reference.
+
+// # ROADMAP
+// - [] ImageDecoder
+// - [] ImageEncoder
+// - [] GenericImageView?
+// - [] GenericImage?
+// - [] Progress
+
+// # MAYBE SOON
+// - [] ImageDecoderExt::read_rect_with_progress
+// - [] Layers -> Animation?
+
+
+extern crate exr;
+use exr::prelude::*;
+
+use crate::{ImageDecoder, ImageResult, ColorType, Progress, image, ImageError, ImageFormat};
+use std::io::{Write, Seek, BufRead, SeekFrom, Cursor};
+use crate::error::{DecodingError, ImageFormatHint};
+use self::exr::meta::header::Header;
+
+/// An OpenEXR decoder
+#[derive(Debug)]
+pub struct ExrDecoder<R> {
+    source: R,
+    header: exr::meta::header::Header,
+}
+
+
+
+impl<R: BufRead + Seek + Send> ExrDecoder<R> {
+
+    /// Create a decoder. Consumes the first few bytes of the source to extract image dimensions.
+    pub fn read(mut source: R) -> ImageResult<Self> {
+
+        // read meta data, then go back to the start of the file
+        let mut meta_data = {
+            let start_position = source.stream_position()?;
+            let meta: MetaData = exr::meta::MetaData::read_from_buffered(&mut source, true)?;
+            source.seek(SeekFrom::Start(start_position))?;
+            meta
+        };
+
+        let header: Header = meta_data.headers.into_iter()
+            .filter(|header|{
+                let has_rgb = ["R","G","B"].iter().all(
+                    |required| header.channels.list.iter().find(|chan| chan.name.eq(required)).is_some() // TODO eq_lowercase only if exrs supports it
+                );
+
+                !header.deep && has_rgb
+            })
+            .next()
+            .ok_or_else(|| ImageError::Decoding(DecodingError::new(
+                ImageFormatHint::Exact(ImageFormat::Exr),
+                "image does not contain non-deep rgb channels"
+            )))?;
+
+        Ok(Self { source, header })
+    }
+}
+
+
+impl<'a, R: 'a + BufRead + Seek + Send> ImageDecoder<'a> for ExrDecoder<R> {
+    type Reader = Cursor<Vec<u8>>;
+
+    fn dimensions(&self) -> (u32, u32) {
+        let s = self.header.layer_size;
+        (s.width() as u32, s.height() as u32)
+    }
+
+    // TODO fn original_color_type(&self) -> ExtendedColorType {}
+
+    fn color_type(&self) -> ColorType {
+        // TODO adapt to actual exr color type
+        // TODO f32 ColorType::Rgba32
+        ColorType::Rgba16
+    }
+
+    /// Use `read_image` if possible,
+    /// as this method creates a whole new buffer to contain the entire image.
+    fn into_reader(self) -> ImageResult<Self::Reader> {
+        Ok(Cursor::new(image::decoder_to_vec(self)?)) // TODO no vec?
+    }
+
+    fn scanline_bytes(&self) -> u64 {
+        // we cannot always read individual scan lines,
+        // as the tiles or lines in the file could be in random order.
+        // therefore we currently read all lines at once
+        // Todo: respect exr.line_order
+       self.total_bytes()
+    }
+
+    fn read_image(mut self, target: &mut [u8]) -> ImageResult<()> {
+        self.read_image_with_progress(target, |_|{})
+    }
+
+    fn read_image_with_progress<F: Fn(Progress)>(self, target: &mut [u8], progress_callback: F) -> ImageResult<()> {
+        // TODO reuse meta-data from earlier
+
+        let result = exr::prelude::read()
+            .no_deep_data().largest_resolution_level()
+            .rgba_channels(
+                // FIXME no alloc+copy, write into target slice directly!
+                |size, _channels| (
+                    size, vec![0_u16; size.area()*4]
+                ),
+
+                |(size, buffer), position, (r,g,b,a_or_1): (f32,f32,f32,f32)| {
+                    // TODO white point chromaticities + srgb/linear conversion?
+                    let first_f32_index = position.flat_index_for_size(*size);
+                    let to_u16 = |v:f32| (v.clamp(0.0, 1.0) * u16::MAX as f32) as u16; // TODO remove, always use 32
+
+                    buffer[first_f32_index*4 .. (first_f32_index + 1)*4]
+                        .copy_from_slice(&[to_u16(r), to_u16(g), to_u16(b), to_u16(a_or_1)]);
+                }
+            )
+            .first_valid_layer().all_attributes()
+            .on_progress(move |progress| {
+                let mut prog = progress_callback;
+                prog(Progress::new((progress*100.0) as u64, 100_u64));
+            })
+            .from_buffered(self.source)?;
+
+        target.copy_from_slice(bytemuck::cast_slice(result.layer_data.channel_data.pixels.1.as_slice()));
+        // TODO keep meta data?
+
+        Ok(())
+    }
+}
+
+
+
+pub fn write_image(mut out: impl Write, bytes: &[u8], width: u32, height: u32, color_type: ColorType) -> ImageResult<()> {
+    let pixels: &[u16] = bytemuck::try_cast_slice(bytes).expect("byte buffer must be aligned to u16");
+
+    let mut seekable_write = Cursor::new(Vec::<u8>::with_capacity(bytes.len())); // TODO make parameter +seek
+    let as_f32 = |v:u16| (v as f32) / u16::MAX as f32; // TODO remove, always use f32
+
+    match color_type {
+        ColorType::Rgb16 => {
+            exr::prelude::Image::from_channels(
+                (width as usize, height as usize),
+                SpecificChannels::rgb(|pixel: Vec2<usize>| {
+                    let pixel_index = 3 * pixel.flat_index_for_size(Vec2(width as usize, height as usize));
+                    (as_f32(pixels[pixel_index]), as_f32(pixels[pixel_index+1]), as_f32(pixels[pixel_index+2]))
+                })
+            ).write().to_buffered(&mut seekable_write)?;
+        }
+
+        ColorType::Rgba16 => {
+            exr::prelude::Image::from_channels(
+                (width as usize, height as usize),
+                SpecificChannels::rgba(|pixel: Vec2<usize>| {
+                    let pixel_index = 4 * pixel.flat_index_for_size(Vec2(width as usize, height as usize));
+                    (as_f32(pixels[pixel_index]), as_f32(pixels[pixel_index+1]), as_f32(pixels[pixel_index+2]), as_f32(pixels[pixel_index+3]))
+                })
+            ).write().to_buffered(&mut seekable_write)?;
+        }
+
+        _ => todo!()
+    }
+
+    out.write_all(seekable_write.into_inner().as_slice())?;
+    Ok(())
+}
+
+
+impl From<exr::error::Error> for ImageError {
+    fn from(exr_error: Error) -> Self {
+        ImageError::Decoding(DecodingError::new(
+            ImageFormatHint::Exact(ImageFormat::Exr),
+            exr_error
+        ))
+    }
+}
+
+

src/image.rs

@@ -55,6 +55,9 @@ pub enum ImageFormat {
     /// An Image in Radiance HDR Format
     Hdr,
 
+    /// An Image in OpenEXR Format
+    Exr,
+
     /// An Image in farbfeld Format
     Farbfeld,
 
@@ -94,6 +97,7 @@ impl ImageFormat {
                 "bmp" => ImageFormat::Bmp,
                 "ico" => ImageFormat::Ico,
                 "hdr" => ImageFormat::Hdr,
+                "exr" => ImageFormat::Exr,
                 "pbm" | "pam" | "ppm" | "pgm" => ImageFormat::Pnm,
                 "ff" | "farbfeld" => ImageFormat::Farbfeld,
                 _ => return None,
@@ -149,6 +153,7 @@ impl ImageFormat {
             ImageFormat::Bmp => true,
             ImageFormat::Ico => true,
             ImageFormat::Hdr => true,
+            ImageFormat::Exr => true,
             ImageFormat::Pnm => true,
             ImageFormat::Farbfeld => true,
             ImageFormat::Avif => true,
@@ -173,6 +178,7 @@ impl ImageFormat {
             ImageFormat::Avif => true,
             ImageFormat::WebP => false,
             ImageFormat::Hdr => false,
+            ImageFormat::Exr => true,
             ImageFormat::Dds => false,
             ImageFormat::__NonExhaustive(marker) => match marker._private {},
         }
@@ -200,6 +206,7 @@ impl ImageFormat {
             ImageFormat::Bmp => &["bmp"],
             ImageFormat::Ico => &["ico"],
             ImageFormat::Hdr => &["hdr"],
+            ImageFormat::Exr => &["exr"],
             ImageFormat::Farbfeld => &["ff"],
             // According to: https://aomediacodec.github.io/av1-avif/#mime-registration
             ImageFormat::Avif => &["avif"],
@@ -243,6 +250,10 @@ pub enum ImageOutputFormat {
     /// An Image in TGA Format
     Tga,
 
+    #[cfg(feature = "openexr")]
+    /// An Image in OpenEXR Format
+    Exr,
+
     #[cfg(feature = "tiff")]
     /// An Image in TIFF Format
     Tiff,
@@ -279,6 +290,8 @@ impl From<ImageFormat> for ImageOutputFormat {
             ImageFormat::Farbfeld => ImageOutputFormat::Farbfeld,
             #[cfg(feature = "tga")]
             ImageFormat::Tga => ImageOutputFormat::Tga,
+            #[cfg(feature = "openexr")]
+            ImageFormat::Exr => ImageOutputFormat::Exr,
             #[cfg(feature = "tiff")]
             ImageFormat::Tiff => ImageOutputFormat::Tiff,
 
@@ -511,6 +524,11 @@ pub struct Progress {
 }
 
 impl Progress {
+    /// Create Progress.
+    pub fn new(current: u64, total: u64) -> Self {
+        Self { current, total }
+    }
+
     /// A measure of completed decoding.
     pub fn current(self) -> u64 {
         self.current

src/io/free_functions.rs

@@ -9,6 +9,8 @@ use crate::codecs::bmp;
 use crate::codecs::gif;
 #[cfg(feature = "hdr")]
 use crate::codecs::hdr;
+#[cfg(feature = "openexr")]
+use crate::codecs::openexr;
 #[cfg(feature = "ico")]
 use crate::codecs::ico;
 #[cfg(feature = "jpeg")]
@@ -81,6 +83,8 @@ pub fn load<R: BufRead + Seek>(r: R, format: ImageFormat) -> ImageResult<Dynamic
         image::ImageFormat::Ico => DynamicImage::from_decoder(ico::IcoDecoder::new(r)?),
         #[cfg(feature = "hdr")]
         image::ImageFormat::Hdr => DynamicImage::from_decoder(hdr::HdrAdapter::new(BufReader::new(r))?),
+        #[cfg(feature = "openexr")]
+        image::ImageFormat::Exr => DynamicImage::from_decoder(openexr::ExrDecoder::read(r)?),
         #[cfg(feature = "pnm")]
         image::ImageFormat::Pnm => DynamicImage::from_decoder(pnm::PnmDecoder::new(BufReader::new(r))?),
         #[cfg(feature = "farbfeld")]
@@ -129,6 +133,8 @@ pub(crate) fn image_dimensions_with_format_impl<R: BufRead + Seek>(fin: R, forma
         image::ImageFormat::Ico => ico::IcoDecoder::new(fin)?.dimensions(),
         #[cfg(feature = "hdr")]
         image::ImageFormat::Hdr => hdr::HdrAdapter::new(fin)?.dimensions(),
+        #[cfg(feature = "openexr")]
+        image::ImageFormat::Exr => openexr::ExrDecoder::read(fin)?.dimensions(),
         #[cfg(feature = "pnm")]
         image::ImageFormat::Pnm => {
             pnm::PnmDecoder::new(fin)?.dimensions()
@@ -218,6 +224,8 @@ pub(crate) fn write_buffer_impl<W: std::io::Write>(
         ImageOutputFormat::Farbfeld => farbfeld::FarbfeldEncoder::new(fout).write_image(buf, width, height, color),
         #[cfg(feature = "tga")]
         ImageOutputFormat::Tga => tga::TgaEncoder::new(fout).write_image(buf, width, height, color),
+        #[cfg(feature = "openexr")]
+        ImageOutputFormat::Exr => openexr::write_image(fout, buf, width, height, color),
         #[cfg(feature = "tiff")]
         ImageOutputFormat::Tiff => {
             let mut cursor = std::io::Cursor::new(Vec::new());
@@ -240,7 +248,7 @@ pub(crate) fn write_buffer_impl<W: std::io::Write>(
     }
 }
 
-static MAGIC_BYTES: [(&[u8], ImageFormat); 20] = [
+static MAGIC_BYTES: [(&[u8], ImageFormat); 21] = [
     (b"\x89PNG\r\n\x1a\n", ImageFormat::Png),
     (&[0xff, 0xd8, 0xff], ImageFormat::Jpeg),
     (b"GIF89a", ImageFormat::Gif),
@@ -261,6 +269,7 @@ static MAGIC_BYTES: [(&[u8], ImageFormat); 20] = [
     (b"P7", ImageFormat::Pnm),
     (b"farbfeld", ImageFormat::Farbfeld),
     (b"\0\0\0 ftypavif", ImageFormat::Avif),
+    (&[0x76, 0x2f, 0x31, 0x01], ImageFormat::Exr), // = &exr::meta::magic_number::BYTES
 ];
 
 /// Guess image format from memory block

src/lib.rs

@@ -244,6 +244,8 @@ pub mod codecs {
     pub mod tiff;
     #[cfg(feature = "webp")]
     pub mod webp;
+    #[cfg(feature = "openexr")]
+    pub mod openexr;
 }
 
 #[cfg(feature = "avif-encoder")]