src/codecs/mod.rs

   1 use frame::*;
   2 use std::rc::Rc;
   3 use std::cell::RefCell;
   4 use std::mem;
   5 use io::byteio::ByteIOError;
   6 use io::bitreader::BitReaderError;
   7 use io::codebook::CodebookError;
   8
   9 #[derive(Debug,Clone,Copy,PartialEq)]
  10 #[allow(dead_code)]
  11 pub enum DecoderError {
  12     NoFrame,
  13     AllocError,
  14     TryAgain,
  15     InvalidData,
  16     ShortData,
  17     MissingReference,
  18     NotImplemented,
  19     Bug,
  20 }
  21
  22 pub type DecoderResult<T> = Result<T, DecoderError>;
  23
  24 impl From<ByteIOError> for DecoderError {
  25     fn from(_: ByteIOError) -> Self { DecoderError::ShortData }
  26 }
  27
  28 impl From<BitReaderError> for DecoderError {
  29     fn from(e: BitReaderError) -> Self {
  30         match e {
  31             BitReaderError::BitstreamEnd => DecoderError::ShortData,
  32             _ => DecoderError::InvalidData,
  33         }
  34     }
  35 }
  36
  37 impl From<CodebookError> for DecoderError {
  38     fn from(_: CodebookError) -> Self { DecoderError::InvalidData }
  39 }
  40
  41 impl From<AllocatorError> for DecoderError {
  42     fn from(_: AllocatorError) -> Self { DecoderError::AllocError }
  43 }
  44
  45 macro_rules! validate {
  46     ($a:expr) => { if !$a { println!("check failed at {}:{}", file!(), line!()); return Err(DecoderError::InvalidData); } };
  47 }
  48
  49 #[allow(dead_code)]
  50 struct HAMShuffler {
  51     lastframe: Option<NAVideoBuffer<u8>>,
  52 }
  53
  54 impl HAMShuffler {
  55     #[allow(dead_code)]
  56     fn new() -> Self { HAMShuffler { lastframe: None } }
  57     #[allow(dead_code)]
  58     fn clear(&mut self) { self.lastframe = None; }
  59     #[allow(dead_code)]
  60     fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
  61         self.lastframe = Some(buf);
  62     }
  63     #[allow(dead_code)]
  64     fn clone_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
  65         if let Some(ref mut frm) = self.lastframe {
  66             let newfrm = frm.copy_buffer();
  67             *frm = newfrm.clone();
  68             Some(newfrm)
  69         } else {
  70             None
  71         }
  72     }
  73     #[allow(dead_code)]
  74     fn get_output_frame(&mut self) -> Option<NAVideoBuffer<u8>> {
  75         match self.lastframe {
  76             Some(ref frm) => Some(frm.clone()),
  77             None => None,
  78         }
  79     }
  80 }
  81
  82 #[allow(dead_code)]
  83 struct IPShuffler {
  84     lastframe: Option<NAVideoBuffer<u8>>,
  85 }
  86
  87 impl IPShuffler {
  88     #[allow(dead_code)]
  89     fn new() -> Self { IPShuffler { lastframe: None } }
  90     #[allow(dead_code)]
  91     fn clear(&mut self) { self.lastframe = None; }
  92     #[allow(dead_code)]
  93     fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
  94         self.lastframe = Some(buf);
  95     }
  96     #[allow(dead_code)]
  97     fn get_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
  98         if let Some(ref frm) = self.lastframe {
  99             Some(frm.clone())
 100         } else {
 101             None
 102         }
 103     }
 104 }
 105
 106 #[allow(dead_code)]
 107 struct IPBShuffler {
 108     lastframe: Option<NAVideoBuffer<u8>>,
 109     nextframe: Option<NAVideoBuffer<u8>>,
 110 }
 111
 112 impl IPBShuffler {
 113     #[allow(dead_code)]
 114     fn new() -> Self { IPBShuffler { lastframe: None, nextframe: None } }
 115     #[allow(dead_code)]
 116     fn clear(&mut self) { self.lastframe = None; self.nextframe = None; }
 117     #[allow(dead_code)]
 118     fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
 119         mem::swap(&mut self.lastframe, &mut self.nextframe);
 120         self.lastframe = Some(buf);
 121     }
 122     #[allow(dead_code)]
 123     fn get_lastref(&mut self) -> Option<NAVideoBuffer<u8>> {
 124         if let Some(ref frm) = self.lastframe {
 125             Some(frm.clone())
 126         } else {
 127             None
 128         }
 129     }
 130     #[allow(dead_code)]
 131     fn get_nextref(&mut self) -> Option<NAVideoBuffer<u8>> {
 132         if let Some(ref frm) = self.nextframe {
 133             Some(frm.clone())
 134         } else {
 135             None
 136         }
 137     }
 138 }
 139
 140 pub trait NADecoder {
 141     fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()>;
 142     fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef>;
 143 }
 144
 145 #[derive(Clone,Copy)]
 146 pub struct DecoderInfo {
 147     name: &'static str,
 148     get_decoder: fn () -> Box<NADecoder>,
 149 }
 150
 151 #[cfg(feature="h263")]
 152 mod blockdsp;
 153
 154 #[cfg(feature="decoder_clearvideo")]
 155 mod clearvideo;
 156 #[cfg(feature="decoder_gdvvid")]
 157 mod gremlinvideo;
 158 #[cfg(any(feature="decoder_indeo2", feature="decoder_indeo3", feature="decoder_indeo4", feature="decoder_indeo5", feature="decoder_imc"))]
 159 mod indeo;
 160 #[cfg(feature="h263")]
 161 mod h263;
 162
 163 #[cfg(feature="decoder_pcm")]
 164 mod pcm;
 165
 166 const DECODERS: &[DecoderInfo] = &[
 167 #[cfg(feature="decoder_clearvideo")]
 168     DecoderInfo { name: "clearvideo", get_decoder: clearvideo::get_decoder },
 169 #[cfg(feature="decoder_clearvideo")]
 170     DecoderInfo { name: "clearvideo_rm", get_decoder: clearvideo::get_decoder_rm },
 171 #[cfg(feature="decoder_gdvvid")]
 172     DecoderInfo { name: "gdv-video", get_decoder: gremlinvideo::get_decoder },
 173 #[cfg(feature="decoder_indeo2")]
 174     DecoderInfo { name: "indeo2", get_decoder: indeo::indeo2::get_decoder },
 175 #[cfg(feature="decoder_indeo3")]
 176     DecoderInfo { name: "indeo3", get_decoder: indeo::indeo3::get_decoder },
 177 #[cfg(feature="decoder_indeo4")]
 178     DecoderInfo { name: "indeo4", get_decoder: indeo::indeo4::get_decoder },
 179 #[cfg(feature="decoder_indeo5")]
 180     DecoderInfo { name: "indeo5", get_decoder: indeo::indeo5::get_decoder },
 181 #[cfg(feature="decoder_intel263")]
 182     DecoderInfo { name: "intel263", get_decoder: h263::intel263::get_decoder },
 183 #[cfg(feature="decoder_realvideo1")]
 184     DecoderInfo { name: "realvideo1", get_decoder: h263::rv10::get_decoder },
 185 #[cfg(feature="decoder_realvideo2")]
 186     DecoderInfo { name: "realvideo2", get_decoder: h263::rv20::get_decoder },
 187
 188 #[cfg(feature="decoder_pcm")]
 189     DecoderInfo { name: "pcm", get_decoder: pcm::get_decoder },
 190 #[cfg(feature="decoder_imc")]
 191     DecoderInfo { name: "imc", get_decoder: indeo::imc::get_decoder_imc },
 192 #[cfg(feature="decoder_imc")]
 193     DecoderInfo { name: "iac", get_decoder: indeo::imc::get_decoder_iac },
 194 ];
 195
 196 pub fn find_decoder(name: &str) -> Option<fn () -> Box<NADecoder>> {
 197     for &dec in DECODERS {
 198         if dec.name == name {
 199             return Some(dec.get_decoder);
 200         }
 201     }
 202     None
 203 }