rustwav_core/
errors.rs

1#![allow(dead_code)]
2
3use std::{
4    error,
5    fmt::{Display, Formatter},
6    io::{self, ErrorKind},
7};
8
9/// * The error info from `std::io::Error` but this must contains the message
10#[derive(Debug, Clone)]
11pub struct IOErrorInfo {
12    pub kind: ErrorKind,
13    pub message: String,
14}
15
16impl IOErrorInfo {
17    pub fn new(kind: ErrorKind, message: String) -> Self {
18        Self { kind, message }
19    }
20}
21
22/// The error info for reading an audio file
23#[derive(Debug, Clone)]
24pub enum AudioReadError {
25    IncompleteFile(u64),
26    IncompleteData(String),
27    BufferTooSmall(String),
28    InvalidArguments(String),
29    IOError(IOErrorInfo),
30    MissingData(String),
31    FormatError(String),
32    InvalidData(String),
33    Unimplemented(String),
34    Unsupported(String),
35    UnexpectedFlag(String, String),
36    StringDecodeError(Vec<u8>),
37    OtherReason(String),
38}
39
40impl AudioReadError {
41    #[allow(non_snake_case)]
42    pub fn UnexpectedEof(message: String) -> Self {
43        Self::IOError(IOErrorInfo::new(ErrorKind::UnexpectedEof, message))
44    }
45}
46
47impl error::Error for AudioReadError {}
48
49impl Display for AudioReadError {
50    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
51        match self {
52            Self::IncompleteFile(offset) => write!(
53                f,
54                "The file is incomplete, the content from 0x{:x} is empty",
55                offset
56            ),
57            Self::IncompleteData(info) => write!(f, "Incomplete data: {info}"),
58            Self::BufferTooSmall(info) => write!(f, "The buffer is too small: {info}"),
59            Self::InvalidArguments(info) => write!(f, "Invalid arguments: {info}"),
60            Self::IOError(ioerror) => write!(f, "IO error: {:?}", ioerror),
61            Self::MissingData(data) => write!(f, "Missing data: \"{data}\""),
62            Self::FormatError(info) => write!(f, "Invalid format: {info}"),
63            Self::InvalidData(info) => write!(f, "Data corrupted: {info}"),
64            Self::Unimplemented(info) => write!(f, "Unimplemented for the file format: {info}"),
65            Self::Unsupported(feature) => write!(f, "Unsupported feature: {feature}"),
66            Self::UnexpectedFlag(expected, got) => write!(f, "Expect \"{expected}\", got \"{got}\"."),
67            Self::StringDecodeError(bytes) => write!(f, "String decode error: {}", String::from_utf8_lossy(bytes)),
68            Self::OtherReason(info) => write!(f, "Unknown error: {info}"),
69        }
70    }
71}
72
73impl From<io::Error> for AudioReadError {
74    fn from(ioerr: io::Error) -> Self {
75        AudioReadError::IOError(IOErrorInfo {
76            kind: ioerr.kind(),
77            message: ioerr.to_string(),
78        })
79    }
80}
81
82impl From<AudioReadError> for io::Error {
83    fn from(err: AudioReadError) -> Self {
84        match err {
85            AudioReadError::IOError(ioerr) => io::Error::from(ioerr.kind),
86            other => panic!(
87                "When converting `AudioReadError` to `io::Error`, the given error is unrelated: {:?}",
88                other
89            ),
90        }
91    }
92}
93
94/// The error info for writing an audio file
95#[derive(Debug, Clone)]
96pub enum AudioWriteError {
97    InvalidArguments(String),
98    InvalidInput(String),
99    InvalidData(String),
100    IOError(IOErrorInfo),
101    Unsupported(String),
102    Unimplemented(String),
103    AlreadyFinished(String),
104    NotPreparedFor4GBFile,
105    ChunkSizeTooBig(String),
106    StringDecodeError(Vec<u8>),
107    BufferIsFull(String),
108    ChannelsNotInSameSize,
109    FrameChannelsNotSame,
110    WrongChannels(String),
111    TruncatedSamples,
112    MissingData(String),
113    OtherReason(String),
114}
115
116impl error::Error for AudioWriteError {}
117
118impl Display for AudioWriteError {
119    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
120        match self {
121            Self::InvalidArguments(info) => write!(f, "Invalid arguments: {info}"),
122            Self::InvalidInput(info) => write!(f, "Invalid input: {info}"),
123            Self::InvalidData(info) => write!(f, "Invalid data: {info}"),
124            Self::IOError(errkind) => write!(f, "IO error: {:?}", errkind),
125            Self::Unsupported(info) => write!(f, "Unsupported format: {info}"),
126            Self::Unimplemented(info) => write!(f, "Unimplemented format: {info}"),
127            Self::AlreadyFinished(info) => write!(f, "Already finished writing {info}"),
128            Self::NotPreparedFor4GBFile => write!(f, "The WAV file wasn't prepared for being larger than 4GB, please check `file_size_option` when creating the `WaveWriter`."),
129            Self::ChunkSizeTooBig(info) => write!(f, "Chunk size is too big: {info}"),
130            Self::StringDecodeError(bytes) => write!(f, "String decode error: {}", String::from_utf8_lossy(bytes)),
131            Self::BufferIsFull(info) => write!(f, "The buffer is full: {info}"),
132            Self::ChannelsNotInSameSize => write!(f, "The lengths of the channels are not equal."),
133            Self::FrameChannelsNotSame => write!(f, "The channels of each frames are not equal."),
134            Self::WrongChannels(prompt) => write!(f, "Wrong channels: {prompt}"),
135            Self::TruncatedSamples => write!(f, "The samples seem truncated because they can not form an audio frame"),
136            Self::MissingData(data) => write!(f, "Missing data: \"{data}\""),
137            Self::OtherReason(info) => write!(f, "Unknown error: {info}"),
138        }
139    }
140}
141
142impl From<io::Error> for AudioWriteError {
143    fn from(ioerr: io::Error) -> Self {
144        AudioWriteError::IOError(IOErrorInfo {
145            kind: ioerr.kind(),
146            message: ioerr.to_string(),
147        })
148    }
149}
150
151impl From<AudioWriteError> for io::Error {
152    fn from(err: AudioWriteError) -> Self {
153        match err {
154            AudioWriteError::IOError(ioerr) => io::Error::from(ioerr.kind),
155            other => panic!(
156                "When converting `AudioWriteError` to `io::Error`, the given error is unrelated: {:?}",
157                other
158            ),
159        }
160    }
161}
162
163/// The error info for processing an audio file
164#[derive(Debug, Clone)]
165pub enum AudioError {
166    GuessChannelMaskFailed(u16),
167    ChannelNotMatchMask,
168    ChannekMaskNotMatch(String),
169    Unparseable(String),
170    InvalidData(String),
171    NoSuchData(String),
172    Unimplemented(String),
173    InvalidArguments(String),
174    WrongExtensionData(String),
175}
176
177impl error::Error for AudioError {}
178
179impl Display for AudioError {
180    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
181       match self {
182           Self::GuessChannelMaskFailed(channels) => write!(f, "Can't guess channel mask for channels = {channels}"),
183           Self::ChannelNotMatchMask => write!(f, "The number of the channels doesn't match the channel mask."),
184           Self::ChannekMaskNotMatch(info) => write!(f, "The channel mask does not match: {info}"),
185           Self::Unparseable(info) => write!(f, "Could not parse {info}"),
186           Self::InvalidData(info) => write!(f, "Invalid data {info}"),
187           Self::NoSuchData(info) => write!(f, "Could not find data \"{info}\""),
188           Self::Unimplemented(info) => write!(f, "Unimplemented behavior: {info}"),
189           Self::InvalidArguments(info) => write!(f, "Invalid arguments: {info}"),
190           Self::WrongExtensionData(info) => write!(f, "Wrong extension data: {info}"),
191       }
192    }
193}
194
195impl From<AudioError> for AudioReadError {
196    fn from(err: AudioError) -> Self {
197        match err {
198            AudioError::GuessChannelMaskFailed(_) => Self::InvalidArguments(format!("{:?}", err)),
199            AudioError::ChannelNotMatchMask => Self::InvalidData(format!("{:?}", err)),
200            AudioError::ChannekMaskNotMatch(_) => Self::InvalidArguments(format!("{:?}", err)),
201            AudioError::Unparseable(_) => Self::InvalidData(format!("{:?}", err)),
202            AudioError::InvalidData(_) => Self::InvalidData(format!("{:?}", err)),
203            AudioError::NoSuchData(_) => Self::MissingData(format!("{:?}", err)),
204            AudioError::Unimplemented(_) => Self::Unimplemented(format!("{:?}", err)),
205            AudioError::InvalidArguments(_) => Self::InvalidArguments(format!("{:?}", err)),
206            AudioError::WrongExtensionData(_) => Self::InvalidData(format!("{:?}", err)),
207        }
208    }
209}
210
211impl From<AudioError> for AudioWriteError {
212    fn from(err: AudioError) -> Self {
213        match err {
214            AudioError::GuessChannelMaskFailed(_) => Self::InvalidArguments(format!("{:?}", err)),
215            AudioError::ChannelNotMatchMask => Self::InvalidArguments(format!("{:?}", err)),
216            AudioError::ChannekMaskNotMatch(_) => Self::InvalidArguments(format!("{:?}", err)),
217            AudioError::Unparseable(_) => Self::InvalidInput(format!("{:?}", err)),
218            AudioError::InvalidData(_) => Self::InvalidData(format!("{:?}", err)),
219            AudioError::NoSuchData(_) => Self::MissingData(format!("{:?}", err)),
220            AudioError::Unimplemented(_) => Self::Unimplemented(format!("{:?}", err)),
221            AudioError::InvalidArguments(_) => Self::InvalidArguments(format!("{:?}", err)),
222            AudioError::WrongExtensionData(_) => Self::InvalidData(format!("{:?}", err)),
223        }
224    }
225}
226
227use audioutils::AudioConvError;
228impl From<AudioConvError> for AudioWriteError {
229    fn from(err: AudioConvError) -> Self {
230        match err {
231            AudioConvError::InvalidArguments(_) => Self::InvalidArguments(format!("{:?}", err)),
232            AudioConvError::FrameChannelsNotSame => Self::FrameChannelsNotSame,
233            AudioConvError::ChannelsNotInSameSize => Self::ChannelsNotInSameSize,
234            AudioConvError::TruncatedSamples => Self::TruncatedSamples,
235        }
236    }
237}
rustwav_core/errors.rs

rustwav_core/
errors.rs
