1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#![forbid(missing_docs)]
#![forbid(unsafe_code)]
#![no_std]
use core::fmt::{Display, Formatter, Result as FmtResult};
use core::str::FromStr;
#[cfg(feature = "zerocopy")]
use zerocopy::{AsBytes, FromBytes};
#[repr(C)]
#[derive(Clone, Copy, Debug)]
#[cfg_attr(feature = "zerocopy", derive(AsBytes, FromBytes))]
pub struct Header {
pub color_space: ColorSpaceInfo,
pub data_format: DataFormatInfo,
pub dimensions: [u32; 2],
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "zerocopy", derive(AsBytes, FromBytes))]
pub struct ColorSpaceInfo(u32);
impl ColorSpaceInfo {
pub fn try_parse(self) -> Option<ColorSpace> {
ColorSpace::try_from_u32(self.0)
}
}
impl From<ColorSpace> for ColorSpaceInfo {
fn from(color_space: ColorSpace) -> Self {
Self(color_space as u32)
}
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "zerocopy", derive(AsBytes, FromBytes))]
pub struct DataFormatInfo(u32);
impl DataFormatInfo {
pub fn try_parse(self) -> Option<DataFormat> {
DataFormat::try_from_u32(self.0)
}
}
impl From<DataFormat> for DataFormatInfo {
fn from(data_format: DataFormat) -> Self {
Self(data_format as u32)
}
}
pub struct UnknownVariant {}
macro_rules! gen_enum {
($name:ident, $doc:expr => [$([$variant:ident = $value:expr, $variant_doc:expr],)+]) => {
#[repr(u32)]
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[doc = $doc] pub enum $name { $(#[doc = $variant_doc] $variant = $value,)+ }
impl Display for $name {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
match self { $(Self::$variant => write!(f, stringify!($variant)),)+ }
}
}
impl FromStr for $name {
type Err = UnknownVariant;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
$(stringify!($variant) => Ok(Self::$variant),)+
_ => Err(UnknownVariant {})
}
}
}
impl $name {
pub(crate) fn try_from_u32(value: u32) -> Option<Self> {
match value {
$($value => Some(Self::$variant),)+
_ => None,
}
}
}
}
}
gen_enum!(ColorSpace, "Available color spaces for the pixel data." => [
[NonColor = 0, "The pixel data does not contain color information."],
[CIEXYZ = 1, "The CIE XYZ 1931 color space using the D65 illuminant."],
[SRGB = 2, "The sRGB color space as defined by IEC 61966-2-1:1999."],
[LinearSRGB = 3, "The sRGB color space but without gamma correction, i.e. linear."],
]);
gen_enum!(DataFormat, "Available data formats for the pixel data." => [
[R32F = 0, "32-bit floating-point, 4-byte row alignment."],
[RG32F = 1, "32-bit floating-point, 4-byte row alignment."],
[RGBA32F = 2, "32-bit floating-point, 4-byte row alignment."],
[R8 = 3, "8-bit fixed-point, 4-byte row alignment."],
[PackedR8 = 4, "8-bit fixed-point, 1-byte row alignment."],
[R16F = 5, "16-bit floating-point, 4-byte row alignment."],
[RG16F = 6, "16-bit floating-point, 4-byte row alignment."],
[RGBA16F = 7, "16-bit floating-point, 4-byte row alignment."],
[PackedR16F = 8, "16-bit floating-point, 2-byte row alignment."],
[RGBE8 = 9, "8-bit RGBE, alpha is exponent, 4-byte row alignment."],
[RGBA8 = 10, "8-bit fixed-point, 4-byte row alignment."],
[BC1 = 11, "BC1 block compression format with no alpha."],
]);