1 use { 2 crate::{amf0::errors::Amf0WriteError, chunk::errors::PackError}, 3 bytesio::bytes_errors::BytesReadError, 4 failure::{Backtrace, Fail}, 5 h264_decoder::errors::H264Error, 6 std::fmt, 7 xflv::errors::{FlvDemuxerError, MpegAacError, Mpeg4AvcHevcError}, 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(Mpeg4AvcHevcError), 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<Mpeg4AvcHevcError> for CacheError { 61 fn from(error: Mpeg4AvcHevcError) -> 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 impl Fail for CacheError { 85 fn cause(&self) -> Option<&dyn Fail> { 86 self.value.cause() 87 } 88 89 fn backtrace(&self) -> Option<&Backtrace> { 90 self.value.backtrace() 91 } 92 } 93 94 #[derive(Debug, Fail)] 95 pub enum MetadataErrorValue { 96 #[fail(display = "metadata tag parse error\n")] 97 DemuxerError(FlvDemuxerError), 98 #[fail(display = "pack error\n")] 99 PackError(PackError), 100 #[fail(display = "amf write error\n")] 101 Amf0WriteError(Amf0WriteError), 102 } 103 #[derive(Debug)] 104 pub struct MetadataError { 105 pub value: MetadataErrorValue, 106 } 107 108 impl From<Amf0WriteError> for MetadataError { 109 fn from(error: Amf0WriteError) -> Self { 110 MetadataError { 111 value: MetadataErrorValue::Amf0WriteError(error), 112 } 113 } 114 } 115 116 impl Fail for MetadataError { 117 fn cause(&self) -> Option<&dyn Fail> { 118 self.value.cause() 119 } 120 121 fn backtrace(&self) -> Option<&Backtrace> { 122 self.value.backtrace() 123 } 124 } 125 126 impl fmt::Display for MetadataError { 127 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 128 fmt::Display::fmt(&self.value, f) 129 } 130 } 131