#![no_main]

#[macro_use]

extern crate libfuzzer_sys;

extern crate image;

use image::codecs::openexr::*;

use image::ExtendedColorType;

use image::ImageDecoder;

use image::ImageEncoder;

use image::ImageResult;

use image::Limits;

use std::io::{BufRead, Cursor, Seek, Write};

// "just dont panic"

fn roundtrip(bytes: &[u8]) -> ImageResult<()> {

    /// 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<(u32, u32, Vec<u8>)> {

        let mut decoder = OpenExrDecoder::with_alpha_preference(read, Some(true))?;

        let prep = decoder.prepare_image()?;

        match usize::try_from(prep.total_bytes()) {

            Ok(decoded_size) if decoded_size <= 256 * 1024 * 1024 => {

                decoder.set_limits(Limits::default())?;

                let (width, height) = prep.layout.dimensions();

                let mut buffer = vec![0; decoded_size];

                decoder.read_image(buffer.as_mut_slice())?;

                Ok((width, height, buffer))

            }

            _ => Err(image::ImageError::Limits(

                image::error::LimitError::from_kind(

                    image::error::LimitErrorKind::InsufficientMemory,

                ),

            )),

        }

    }

fuzzer_script_exr::roundtrip::read_as_rgba_byte_image::<std::io::cursor::Cursor<alloc::vec::Vec<u8>>>

Line

Count

Source

18

83

    fn read_as_rgba_byte_image(read: impl BufRead + Seek) -> ImageResult<(u32, u32, Vec<u8>)> {

19

83

        let mut decoder = OpenExrDecoder::with_alpha_preference(read, Some(true))?;

20

83

        let prep = decoder.prepare_image()?;

21

83

        match usize::try_from(prep.total_bytes()) {

22

83

            Ok(decoded_size) if decoded_size <= 256 * 1024 * 1024 => {

23

83

                decoder.set_limits(Limits::default())?;

24

83

                let (width, height) = prep.layout.dimensions();

25

83

                let mut buffer = vec![0; decoded_size];

26

83

                decoder.read_image(buffer.as_mut_slice())?;

27

83

                Ok((width, height, buffer))

28

            }

29

0

            _ => Err(image::ImageError::Limits(

30

0

                image::error::LimitError::from_kind(

31

0

                    image::error::LimitErrorKind::InsufficientMemory,

32

0

                ),

33

0

            )),

34

        }

35

83

    }

fuzzer_script_exr::roundtrip::read_as_rgba_byte_image::<std::io::cursor::Cursor<&[u8]>>

Line

Count

Source

18

2.01k

    fn read_as_rgba_byte_image(read: impl BufRead + Seek) -> ImageResult<(u32, u32, Vec<u8>)> {

19

2.01k

        let mut decoder = OpenExrDecoder::with_alpha_preference(read, Some(true))?;

20

804

        let prep = decoder.prepare_image()?;

21

804

        match usize::try_from(prep.total_bytes()) {

22

804

            Ok(decoded_size) if decoded_size <= 256 * 1024 * 1024 => {

23

791

                decoder.set_limits(Limits::default())?;

24

791

                let (width, height) = prep.layout.dimensions();

25

791

                let mut buffer = vec![0; decoded_size];

26

791

                decoder.read_image(buffer.as_mut_slice())?;

27

83

                Ok((width, height, buffer))

28

            }

29

13

            _ => Err(image::ImageError::Limits(

30

13

                image::error::LimitError::from_kind(

31

13

                    image::error::LimitErrorKind::InsufficientMemory,

32

13

                ),

33

13

            )),

34

        }

35

2.01k

    }

    /// 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,

        (width, height, data): &(u32, u32, Vec<u8>),

    ) -> ImageResult<()> {

        OpenExrEncoder::new(write).write_image(

            data.as_slice(),

            *width,

            *height,

            ExtendedColorType::Rgba32F,

        )

    }

    let decoded_image = read_as_rgba_byte_image(Cursor::new(bytes))?;

    #[allow(clippy::disallowed_methods)]

    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?

});