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 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}