xref: /xiu/protocol/hls/src/errors.rs (revision 15fa2386) 
1 use bytes::BytesMut;
2 use failure::Fail;
3 
4 use libflv::errors::FlvDemuxerError;
5 use rtmp::session::errors::SessionError;
6 
7 use networkio::bytes_errors::BytesWriteError;
8 use rtmp::amf0::errors::Amf0WriteError;
9 use rtmp::cache::errors::MetadataError;
10 
11 use libmpegts::errors::MpegTsError;
12 use std::fmt;
13 
14 // use tokio::sync::mpsc::error::SendError;
15 
16 #[derive(Debug)]
17 pub struct ServerError {
18     pub value: ServerErrorValue,
19 }
20 
21 #[derive(Debug, Fail)]
22 pub enum ServerErrorValue {
23     #[fail(display = "server error")]
24     Error,
25 }
26 #[derive(Debug)]
27 pub struct MediaError {
28     pub value: MediaErrorValue,
29 }
30 
31 #[derive(Debug, Fail)]
32 pub enum MediaErrorValue {
33     #[fail(display = "server error")]
34     Error,
35     #[fail(display = "session error")]
36     SessionError(SessionError),
37     #[fail(display = "amf write error")]
38     Amf0WriteError(Amf0WriteError),
39     #[fail(display = "metadata error")]
40     MetadataError(MetadataError),
41     #[fail(display = "flv demuxer error")]
42     FlvDemuxerError(FlvDemuxerError),
43     #[fail(display = "mpegts error")]
44     MpegTsError(MpegTsError),
45 
46     #[fail(display = "write file error")]
47     IOError(std::io::Error),
48 }
49 
50 impl From<SessionError> for MediaError {
51     fn from(error: SessionError) -> Self {
52         MediaError {
53             value: MediaErrorValue::SessionError(error),
54         }
55     }
56 }
57 
58 impl From<FlvDemuxerError> for MediaError {
59     fn from(error: FlvDemuxerError) -> Self {
60         MediaError {
61             value: MediaErrorValue::FlvDemuxerError(error),
62         }
63     }
64 }
65 
66 impl From<MpegTsError> for MediaError {
67     fn from(error: MpegTsError) -> Self {
68         MediaError {
69             value: MediaErrorValue::MpegTsError(error),
70         }
71     }
72 }
73 
74 impl From<Amf0WriteError> for MediaError {
75     fn from(error: Amf0WriteError) -> Self {
76         MediaError {
77             value: MediaErrorValue::Amf0WriteError(error),
78         }
79     }
80 }
81 
82 impl From<MetadataError> for MediaError {
83     fn from(error: MetadataError) -> Self {
84         MediaError {
85             value: MediaErrorValue::MetadataError(error),
86         }
87     }
88 }
89 
90 impl From<std::io::Error> for MediaError {
91     fn from(error: std::io::Error) -> Self {
92         MediaError {
93             value: MediaErrorValue::IOError(error),
94         }
95     }
96 }
97 
98 
99 impl fmt::Display for MediaError {
100     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
101         fmt::Display::fmt(&self.value, f)
102     }
103 }
104 
105 pub struct HlsError {
106     pub value: HlsErrorValue,
107 }
108 
109 #[derive(Debug, Fail)]
110 pub enum HlsErrorValue {
111     #[fail(display = "server error")]
112     Error,
113     #[fail(display = "session error")]
114     SessionError(SessionError),
115     #[fail(display = "amf write error")]
116     Amf0WriteError(Amf0WriteError),
117     #[fail(display = "metadata error")]
118     MetadataError(MetadataError),
119     #[fail(display = "flv demuxer error")]
120     FlvDemuxerError(FlvDemuxerError),
121     #[fail(display = "media error")]
122     MediaError(MediaError),
123 }
124 
125 impl From<MediaError> for HlsError {
126     fn from(error: MediaError) -> Self {
127         HlsError {
128             value: HlsErrorValue::MediaError(error),
129         }
130     }
131 }
132 
133 impl From<SessionError> for HlsError {
134     fn from(error: SessionError) -> Self {
135         HlsError {
136             value: HlsErrorValue::SessionError(error),
137         }
138     }
139 }
140 
141 impl From<FlvDemuxerError> for HlsError {
142     fn from(error: FlvDemuxerError) -> Self {
143         HlsError {
144             value: HlsErrorValue::FlvDemuxerError(error),
145         }
146     }
147 }
148 
149 impl From<Amf0WriteError> for HlsError {
150     fn from(error: Amf0WriteError) -> Self {
151         HlsError {
152             value: HlsErrorValue::Amf0WriteError(error),
153         }
154     }
155 }
156 
157 impl From<MetadataError> for HlsError {
158     fn from(error: MetadataError) -> Self {
159         HlsError {
160             value: HlsErrorValue::MetadataError(error),
161         }
162     }
163 }
164 
165 impl fmt::Display for HlsError {
166     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
167         fmt::Display::fmt(&self.value, f)
168     }
169 }
170 // #[derive(Debug, Fail)]
171 // pub struct TsError {
172 //     pub value: TsErrorValue,
173 // }
174 
175 // impl fmt::Display for TsError {
176 //     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
177 //         fmt::Display::fmt(&self.value, f)
178 //     }
179 // }
180 
181 // #[derive(Debug, Fail)]
182 // pub enum TsErrorValue {
183 //     #[fail(display = "write file error")]
184 //     IOError(std::io::Error),
185 // }
186 
187 // impl From<std::io::Error> for TsError {
188 //     fn from(error: std::io::Error) -> Self {
189 //         TsError {
190 //             value: TsErrorValue::IOError(error),
191 //         }
192 //     }
193 // }
194