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