xref: /xiu/protocol/rtmp/src/cache/errors.rs (revision ccd9a1fa) 
1 use {
2     crate::{amf0::errors::Amf0WriteError, chunk::errors::PackError},
3     bytesio::bytes_errors::BytesReadError,
4     failure::{Backtrace, Fail},
5     h264::errors::H264Error,
6     std::fmt,
7     xflv::errors::{FlvDemuxerError, MpegAacError, MpegAvcError},
8 };
9 
10 #[derive(Debug, Fail)]
11 pub enum CacheErrorValue {
12     #[fail(display = "cache tag parse error\n")]
13     DemuxerError(FlvDemuxerError),
14     #[fail(display = "mpeg aac error\n")]
15     MpegAacError(MpegAacError),
16     #[fail(display = "mpeg avc error\n")]
17     MpegAvcError(MpegAvcError),
18     #[fail(display = "pack error\n")]
19     PackError(PackError),
20     #[fail(display = "read bytes error\n")]
21     BytesReadError(BytesReadError),
22     #[fail(display = "h264 error\n")]
23     H264Error(H264Error),
24 }
25 
26 impl fmt::Display for CacheError {
27     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
28         fmt::Display::fmt(&self.value, f)
29     }
30 }
31 #[derive(Debug)]
32 pub struct CacheError {
33     pub value: CacheErrorValue,
34 }
35 
36 impl From<FlvDemuxerError> for CacheError {
37     fn from(error: FlvDemuxerError) -> Self {
38         CacheError {
39             value: CacheErrorValue::DemuxerError(error),
40         }
41     }
42 }
43 
44 impl From<H264Error> for CacheError {
45     fn from(error: H264Error) -> Self {
46         CacheError {
47             value: CacheErrorValue::H264Error(error),
48         }
49     }
50 }
51 
52 impl From<MpegAacError> for CacheError {
53     fn from(error: MpegAacError) -> Self {
54         CacheError {
55             value: CacheErrorValue::MpegAacError(error),
56         }
57     }
58 }
59 
60 impl From<MpegAvcError> for CacheError {
61     fn from(error: MpegAvcError) -> Self {
62         CacheError {
63             value: CacheErrorValue::MpegAvcError(error),
64         }
65     }
66 }
67 
68 impl From<BytesReadError> for CacheError {
69     fn from(error: BytesReadError) -> Self {
70         CacheError {
71             value: CacheErrorValue::BytesReadError(error),
72         }
73     }
74 }
75 
76 impl From<PackError> for CacheError {
77     fn from(error: PackError) -> Self {
78         CacheError {
79             value: CacheErrorValue::PackError(error),
80         }
81     }
82 }
83 
84 #[derive(Debug, Fail)]
85 pub enum MetadataErrorValue {
86     #[fail(display = "metadata tag parse error\n")]
87     DemuxerError(FlvDemuxerError),
88     #[fail(display = "pack error\n")]
89     PackError(PackError),
90     #[fail(display = "amf write error\n")]
91     Amf0WriteError(Amf0WriteError),
92 }
93 #[derive(Debug)]
94 pub struct MetadataError {
95     pub value: MetadataErrorValue,
96 }
97 
98 impl From<Amf0WriteError> for MetadataError {
99     fn from(error: Amf0WriteError) -> Self {
100         MetadataError {
101             value: MetadataErrorValue::Amf0WriteError(error),
102         }
103     }
104 }
105 
106 impl Fail for MetadataError {
107     fn cause(&self) -> Option<&dyn Fail> {
108         self.value.cause()
109     }
110 
111     fn backtrace(&self) -> Option<&Backtrace> {
112         self.value.backtrace()
113     }
114 }
115 
116 impl fmt::Display for MetadataError {
117     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
118         fmt::Display::fmt(&self.value, f)
119     }
120 }
121