jxl_render/
error.rs

1#[derive(Debug)]
2#[non_exhaustive]
3pub enum Error {
4    Bitstream(jxl_bitstream::Error),
5    Decoder(jxl_coding::Error),
6    Buffer(jxl_grid::Error),
7    Modular(jxl_modular::Error),
8    Frame(jxl_frame::Error),
9    Color(jxl_color::Error),
10    IncompleteFrame,
11    FailedReference,
12    UninitializedLfFrame(u32),
13    InvalidReference(u32),
14    NotReady,
15    NotSupported(&'static str),
16}
17
18impl From<jxl_bitstream::Error> for Error {
19    fn from(err: jxl_bitstream::Error) -> Self {
20        Self::Bitstream(err)
21    }
22}
23
24impl From<jxl_coding::Error> for Error {
25    fn from(err: jxl_coding::Error) -> Self {
26        Self::Decoder(err)
27    }
28}
29
30impl From<jxl_grid::Error> for Error {
31    fn from(err: jxl_grid::Error) -> Self {
32        Self::Buffer(err)
33    }
34}
35
36impl From<jxl_modular::Error> for Error {
37    fn from(err: jxl_modular::Error) -> Self {
38        Self::Modular(err)
39    }
40}
41
42impl From<jxl_frame::Error> for Error {
43    fn from(err: jxl_frame::Error) -> Self {
44        Self::Frame(err)
45    }
46}
47
48impl From<jxl_color::Error> for Error {
49    fn from(err: jxl_color::Error) -> Self {
50        Self::Color(err)
51    }
52}
53
54impl std::fmt::Display for Error {
55    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56        use Error::*;
57
58        match self {
59            Bitstream(err) => write!(f, "bitstream error: {}", err),
60            Decoder(err) => write!(f, "entropy decoder error: {}", err),
61            Buffer(err) => write!(f, "{}", err),
62            Modular(err) => write!(f, "modular subimage decode error: {}", err),
63            Frame(err) => write!(f, "frame error: {}", err),
64            Color(err) => write!(f, "color management error: {err}"),
65            IncompleteFrame => write!(f, "frame data is incomplete"),
66            FailedReference => write!(f, "reference frame failed to render"),
67            UninitializedLfFrame(lf_level) => {
68                write!(f, "uninitialized LF frame for level {lf_level}")
69            }
70            InvalidReference(idx) => write!(f, "invalid reference {idx}"),
71            NotReady => write!(f, "image is not ready to be rendered"),
72            NotSupported(msg) => write!(f, "not supported: {}", msg),
73        }
74    }
75}
76
77impl std::error::Error for Error {
78    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
79        use Error::*;
80
81        match self {
82            Bitstream(err) => Some(err),
83            Decoder(err) => Some(err),
84            Buffer(err) => Some(err),
85            Modular(err) => Some(err),
86            Frame(err) => Some(err),
87            Color(err) => Some(err),
88            _ => None,
89        }
90    }
91}
92
93impl Error {
94    pub fn unexpected_eof(&self) -> bool {
95        match self {
96            Error::Bitstream(e) => e.unexpected_eof(),
97            Error::Decoder(e) => e.unexpected_eof(),
98            Error::Modular(e) => e.unexpected_eof(),
99            Error::Frame(e) => e.unexpected_eof(),
100            Error::Color(e) => e.unexpected_eof(),
101            _ => false,
102        }
103    }
104}
105
106pub type Result<T> = std::result::Result<T, Error>;