xref: /xiu/protocol/hls/src/errors.rs (revision f4262a36) 
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 = "ts write error")]
47     TsError(TsError),
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<TsError> for MediaError {
91     fn from(error: TsError) -> Self {
92         MediaError {
93             value: MediaErrorValue::TsError(error),
94         }
95     }
96 }
97 
98 impl fmt::Display for MediaError {
99     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
100         fmt::Display::fmt(&self.value, f)
101     }
102 }
103 
104 pub struct HlsError {
105     pub value: HlsErrorValue,
106 }
107 
108 #[derive(Debug, Fail)]
109 pub enum HlsErrorValue {
110     #[fail(display = "server error")]
111     Error,
112     #[fail(display = "session error")]
113     SessionError(SessionError),
114     #[fail(display = "amf write error")]
115     Amf0WriteError(Amf0WriteError),
116     #[fail(display = "metadata error")]
117     MetadataError(MetadataError),
118     #[fail(display = "flv demuxer error")]
119     FlvDemuxerError(FlvDemuxerError),
120     #[fail(display = "media error")]
121     MediaError(MediaError),
122 }
123 
124 impl From<MediaError> for HlsError {
125     fn from(error: MediaError) -> Self {
126         HlsError {
127             value: HlsErrorValue::MediaError(error),
128         }
129     }
130 }
131 
132 impl From<SessionError> for HlsError {
133     fn from(error: SessionError) -> Self {
134         HlsError {
135             value: HlsErrorValue::SessionError(error),
136         }
137     }
138 }
139 
140 impl From<FlvDemuxerError> for HlsError {
141     fn from(error: FlvDemuxerError) -> Self {
142         HlsError {
143             value: HlsErrorValue::FlvDemuxerError(error),
144         }
145     }
146 }
147 
148 impl From<Amf0WriteError> for HlsError {
149     fn from(error: Amf0WriteError) -> Self {
150         HlsError {
151             value: HlsErrorValue::Amf0WriteError(error),
152         }
153     }
154 }
155 
156 impl From<MetadataError> for HlsError {
157     fn from(error: MetadataError) -> Self {
158         HlsError {
159             value: HlsErrorValue::MetadataError(error),
160         }
161     }
162 }
163 
164 impl fmt::Display for HlsError {
165     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
166         fmt::Display::fmt(&self.value, f)
167     }
168 }
169 #[derive(Debug, Fail)]
170 pub struct TsError {
171     pub value: TsErrorValue,
172 }
173 
174 impl fmt::Display for TsError {
175     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
176         fmt::Display::fmt(&self.value, f)
177     }
178 }
179 
180 #[derive(Debug, Fail)]
181 pub enum TsErrorValue {
182     #[fail(display = "write file error")]
183     IOError(std::io::Error),
184 }
185 
186 impl From<std::io::Error> for TsError {
187     fn from(error: std::io::Error) -> Self {
188         TsError {
189             value: TsErrorValue::IOError(error),
190         }
191     }
192 }
193