xref: /xiu/library/container/flv/src/errors.rs (revision 69de9bbd) 
1 use {
2     bytesio::bits_errors::BitError,
3     bytesio::bytes_errors::{BytesReadError, BytesWriteError},
4     failure::{Backtrace, Fail},
5     h264_decoder::errors::H264Error,
6     std::fmt,
7 };
8 
9 #[derive(Debug, Fail)]
10 pub enum TagParseErrorValue {
11     #[fail(display = "bytes read error")]
12     BytesReadError(BytesReadError),
13     #[fail(display = "tag data length error")]
14     TagDataLength,
15     #[fail(display = "unknow tag type error")]
16     UnknownTagType,
17 }
18 #[derive(Debug)]
19 pub struct TagParseError {
20     pub value: TagParseErrorValue,
21 }
22 
23 impl From<BytesReadError> for TagParseError {
from(error: BytesReadError) -> Self24     fn from(error: BytesReadError) -> Self {
25         TagParseError {
26             value: TagParseErrorValue::BytesReadError(error),
27         }
28     }
29 }
30 
31 impl fmt::Display for TagParseError {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result32     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
33         fmt::Display::fmt(&self.value, f)
34     }
35 }
36 
37 impl Fail for TagParseError {
cause(&self) -> Option<&dyn Fail>38     fn cause(&self) -> Option<&dyn Fail> {
39         self.value.cause()
40     }
41 
backtrace(&self) -> Option<&Backtrace>42     fn backtrace(&self) -> Option<&Backtrace> {
43         self.value.backtrace()
44     }
45 }
46 #[derive(Debug)]
47 pub struct FlvMuxerError {
48     pub value: MuxerErrorValue,
49 }
50 
51 #[derive(Debug, Fail)]
52 pub enum MuxerErrorValue {
53     // #[fail(display = "server error")]
54     // Error,
55     #[fail(display = "bytes write error")]
56     BytesWriteError(BytesWriteError),
57 }
58 
59 impl From<BytesWriteError> for FlvMuxerError {
from(error: BytesWriteError) -> Self60     fn from(error: BytesWriteError) -> Self {
61         FlvMuxerError {
62             value: MuxerErrorValue::BytesWriteError(error),
63         }
64     }
65 }
66 
67 impl fmt::Display for FlvMuxerError {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result68     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
69         fmt::Display::fmt(&self.value, f)
70     }
71 }
72 
73 impl Fail for FlvMuxerError {
cause(&self) -> Option<&dyn Fail>74     fn cause(&self) -> Option<&dyn Fail> {
75         self.value.cause()
76     }
77 
backtrace(&self) -> Option<&Backtrace>78     fn backtrace(&self) -> Option<&Backtrace> {
79         self.value.backtrace()
80     }
81 }
82 
83 #[derive(Debug)]
84 pub struct FlvDemuxerError {
85     pub value: DemuxerErrorValue,
86 }
87 
88 #[derive(Debug, Fail)]
89 pub enum DemuxerErrorValue {
90     // #[fail(display = "server error")]
91     // Error,
92     #[fail(display = "bytes write error:{}", _0)]
93     BytesWriteError(#[cause] BytesWriteError),
94     #[fail(display = "bytes read error:{}", _0)]
95     BytesReadError(#[cause] BytesReadError),
96     #[fail(display = "mpeg avc error:{}", _0)]
97     MpegAvcError(#[cause] Mpeg4AvcHevcError),
98     #[fail(display = "mpeg aac error:{}", _0)]
99     MpegAacError(#[cause] MpegAacError),
100 }
101 
102 impl From<BytesWriteError> for FlvDemuxerError {
from(error: BytesWriteError) -> Self103     fn from(error: BytesWriteError) -> Self {
104         FlvDemuxerError {
105             value: DemuxerErrorValue::BytesWriteError(error),
106         }
107     }
108 }
109 
110 impl From<BytesReadError> for FlvDemuxerError {
from(error: BytesReadError) -> Self111     fn from(error: BytesReadError) -> Self {
112         FlvDemuxerError {
113             value: DemuxerErrorValue::BytesReadError(error),
114         }
115     }
116 }
117 
118 impl From<Mpeg4AvcHevcError> for FlvDemuxerError {
from(error: Mpeg4AvcHevcError) -> Self119     fn from(error: Mpeg4AvcHevcError) -> Self {
120         FlvDemuxerError {
121             value: DemuxerErrorValue::MpegAvcError(error),
122         }
123     }
124 }
125 
126 impl From<MpegAacError> for FlvDemuxerError {
from(error: MpegAacError) -> Self127     fn from(error: MpegAacError) -> Self {
128         FlvDemuxerError {
129             value: DemuxerErrorValue::MpegAacError(error),
130         }
131     }
132 }
133 
134 impl fmt::Display for FlvDemuxerError {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result135     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
136         fmt::Display::fmt(&self.value, f)
137     }
138 }
139 
140 impl Fail for FlvDemuxerError {
cause(&self) -> Option<&dyn Fail>141     fn cause(&self) -> Option<&dyn Fail> {
142         self.value.cause()
143     }
144 
backtrace(&self) -> Option<&Backtrace>145     fn backtrace(&self) -> Option<&Backtrace> {
146         self.value.backtrace()
147     }
148 }
149 
150 #[derive(Debug, Fail)]
151 pub enum MpegErrorValue {
152     #[fail(display = "bytes read error:{}", _0)]
153     BytesReadError(#[cause] BytesReadError),
154     #[fail(display = "bytes write error:{}", _0)]
155     BytesWriteError(#[cause] BytesWriteError),
156     #[fail(display = "bits error:{}", _0)]
157     BitError(#[cause] BitError),
158     #[fail(display = "h264 error:{}", _0)]
159     H264Error(#[cause] H264Error),
160     #[fail(display = "there is not enough bits to read")]
161     NotEnoughBitsToRead,
162     #[fail(display = "should not come here")]
163     ShouldNotComeHere,
164     #[fail(display = "the sps nal unit type is not correct")]
165     SPSNalunitTypeNotCorrect,
166 }
167 #[derive(Debug)]
168 pub struct Mpeg4AvcHevcError {
169     pub value: MpegErrorValue,
170 }
171 
172 impl From<BytesReadError> for Mpeg4AvcHevcError {
from(error: BytesReadError) -> Self173     fn from(error: BytesReadError) -> Self {
174         Mpeg4AvcHevcError {
175             value: MpegErrorValue::BytesReadError(error),
176         }
177     }
178 }
179 
180 impl From<BytesWriteError> for Mpeg4AvcHevcError {
from(error: BytesWriteError) -> Self181     fn from(error: BytesWriteError) -> Self {
182         Mpeg4AvcHevcError {
183             value: MpegErrorValue::BytesWriteError(error),
184         }
185     }
186 }
187 
188 impl From<H264Error> for Mpeg4AvcHevcError {
from(error: H264Error) -> Self189     fn from(error: H264Error) -> Self {
190         Mpeg4AvcHevcError {
191             value: MpegErrorValue::H264Error(error),
192         }
193     }
194 }
195 
196 impl fmt::Display for Mpeg4AvcHevcError {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result197     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
198         fmt::Display::fmt(&self.value, f)
199     }
200 }
201 
202 impl Fail for Mpeg4AvcHevcError {
cause(&self) -> Option<&dyn Fail>203     fn cause(&self) -> Option<&dyn Fail> {
204         self.value.cause()
205     }
206 
backtrace(&self) -> Option<&Backtrace>207     fn backtrace(&self) -> Option<&Backtrace> {
208         self.value.backtrace()
209     }
210 }
211 
212 #[derive(Debug)]
213 pub struct MpegAacError {
214     pub value: MpegErrorValue,
215 }
216 
217 impl From<BytesReadError> for MpegAacError {
from(error: BytesReadError) -> Self218     fn from(error: BytesReadError) -> Self {
219         MpegAacError {
220             value: MpegErrorValue::BytesReadError(error),
221         }
222     }
223 }
224 
225 impl From<BytesWriteError> for MpegAacError {
from(error: BytesWriteError) -> Self226     fn from(error: BytesWriteError) -> Self {
227         MpegAacError {
228             value: MpegErrorValue::BytesWriteError(error),
229         }
230     }
231 }
232 
233 impl From<BitError> for MpegAacError {
from(error: BitError) -> Self234     fn from(error: BitError) -> Self {
235         MpegAacError {
236             value: MpegErrorValue::BitError(error),
237         }
238     }
239 }
240 
241 impl fmt::Display for MpegAacError {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result242     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
243         fmt::Display::fmt(&self.value, f)
244     }
245 }
246 
247 impl Fail for MpegAacError {
cause(&self) -> Option<&dyn Fail>248     fn cause(&self) -> Option<&dyn Fail> {
249         self.value.cause()
250     }
251 
backtrace(&self) -> Option<&Backtrace>252     fn backtrace(&self) -> Option<&Backtrace> {
253         self.value.backtrace()
254     }
255 }
256 
257 #[derive(Debug, Fail)]
258 pub enum BitVecErrorValue {
259     #[fail(display = "not enough bits left")]
260     NotEnoughBits,
261 }
262 #[derive(Debug)]
263 pub struct BitVecError {
264     pub value: BitVecErrorValue,
265 }
266