Skip to main content

wgame_image/
endec.rs

1use std::{fmt::Debug, io::Cursor};
2
3use anyhow::{Error, Result, anyhow};
4use euclid::default::Size2D;
5use half::f16;
6use image::{DynamicImage, GrayImage, ImageFormat, ImageReader, Rgba32FImage};
7use rgb::{ComponentMap, Rgba};
8
9use crate::{Image, ImageBase, ImageReadExt, ImageSlice};
10
11#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
12pub enum Encoding {
13    #[cfg(feature = "png")]
14    Png,
15}
16
17impl TryFrom<&str> for Encoding {
18    type Error = Error;
19    fn try_from(value: &str) -> Result<Self> {
20        match value {
21            #[cfg(feature = "png")]
22            "png" => Ok(Self::Png),
23            other => Err(anyhow!("Unsupported format string: {other:?}")),
24        }
25    }
26}
27
28impl TryFrom<ImageFormat> for Encoding {
29    type Error = Error;
30    fn try_from(format: ImageFormat) -> Result<Self> {
31        match format {
32            #[cfg(feature = "png")]
33            ImageFormat::Png => Ok(Self::Png),
34            other => Err(anyhow!("Unsupported format: {other:?}")),
35        }
36    }
37}
38
39impl From<Encoding> for ImageFormat {
40    fn from(value: Encoding) -> Self {
41        match value {
42            #[cfg(feature = "png")]
43            Encoding::Png => Self::Png,
44        }
45    }
46}
47
48impl TryFrom<image::DynamicImage> for Image<Rgba<f16>> {
49    type Error = Error;
50    fn try_from(image: image::DynamicImage) -> Result<Self> {
51        let data: Vec<f16> = {
52            // TODO: Convert directly to f16
53            let image = image.to_rgba32f();
54            image.into_vec().into_iter().map(f16::from_f32).collect()
55        };
56
57        Ok(Self::with_data(
58            (image.width(), image.height()),
59            bytemuck::cast_slice(&data).to_vec(),
60        ))
61    }
62}
63
64impl Image<Rgba<f16>> {
65    fn decode_inner(bytes: &[u8], encoding: Option<Encoding>) -> Result<Self> {
66        let mut reader = ImageReader::new(Cursor::new(bytes));
67        match encoding {
68            None => reader = reader.with_guessed_format()?,
69            Some(enc) => reader.set_format(enc.into()),
70        }
71
72        let image = reader.decode()?;
73        Self::try_from(image)
74    }
75
76    pub fn decode(bytes: &[u8], encoding: impl Into<Encoding>) -> Result<Self> {
77        Self::decode_inner(bytes, Some(encoding.into()))
78    }
79
80    pub fn decode_auto(bytes: &[u8]) -> Result<Self> {
81        Self::decode_inner(bytes, None)
82    }
83}
84
85impl ImageSlice<'_, Rgba<f16>> {
86    pub fn encode<C: TryInto<Encoding>>(&self, encoding: C) -> Result<Vec<u8>>
87    where
88        C::Error: Into<Error>,
89    {
90        let encoding = encoding.try_into().map_err(|e| e.into())?;
91        let Size2D { width, height, .. } = self.size();
92        let data: Vec<Rgba<f32>> = self
93            .rows()
94            .flat_map(|(_, row)| row.iter().map(|c| c.map(f32::from)))
95            .collect();
96        let image = DynamicImage::from(
97            Rgba32FImage::from_vec(width, height, bytemuck::cast_vec(data))
98                .expect("Buffer is smaller than expected"),
99        )
100        .to_rgba8();
101
102        let mut buffer = Cursor::new(Vec::<u8>::new());
103        image.write_to(&mut buffer, encoding.into())?;
104        Ok(buffer.into_inner())
105    }
106}
107
108impl ImageSlice<'_, u8> {
109    pub fn encode<C: TryInto<Encoding>>(&self, encoding: C) -> Result<Vec<u8>>
110    where
111        C::Error: Into<Error>,
112    {
113        let encoding = encoding.try_into().map_err(|e| e.into())?;
114        let Size2D { width, height, .. } = self.size();
115        let data: Vec<u8> = self
116            .rows()
117            .flat_map(|(_, row)| row.iter().copied())
118            .collect();
119        let image = GrayImage::from_vec(width, height, bytemuck::cast_vec(data))
120            .expect("Buffer is smaller than expected");
121
122        let mut buffer = Cursor::new(Vec::<u8>::new());
123        image.write_to(&mut buffer, encoding.into())?;
124        Ok(buffer.into_inner())
125    }
126}