src/codecs/mod.rs

   1 use frame::*;
   2 use std::rc::Rc;
   3 use std::cell::RefCell;
   4 use io::byteio::ByteIOError;
   5 use io::bitreader::BitReaderError;
   6 use io::codebook::CodebookError;
   7
   8 #[derive(Debug,Clone,Copy,PartialEq)]
   9 #[allow(dead_code)]
  10 pub enum DecoderError {
  11     InvalidData,
  12     ShortData,
  13     MissingReference,
  14     NotImplemented,
  15     Bug,
  16 }
  17
  18 type DecoderResult<T> = Result<T, DecoderError>;
  19
  20 impl From<ByteIOError> for DecoderError {
  21     fn from(_: ByteIOError) -> Self { DecoderError::ShortData }
  22 }
  23
  24 impl From<BitReaderError> for DecoderError {
  25     fn from(e: BitReaderError) -> Self {
  26         match e {
  27             BitReaderError::BitstreamEnd => DecoderError::ShortData,
  28             _ => DecoderError::InvalidData,
  29         }
  30     }
  31 }
  32
  33 impl From<CodebookError> for DecoderError {
  34     fn from(_: CodebookError) -> Self { DecoderError::InvalidData }
  35 }
  36
  37 #[allow(dead_code)]
  38 struct HAMShuffler {
  39     lastframe: Option<NAVideoBuffer<u8>>,
  40 }
  41
  42 impl HAMShuffler {
  43     #[allow(dead_code)]
  44     fn new() -> Self { HAMShuffler { lastframe: None } }
  45     #[allow(dead_code)]
  46     fn clear(&mut self) { self.lastframe = None; }
  47     #[allow(dead_code)]
  48     fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
  49         self.lastframe = Some(buf);
  50     }
  51     #[allow(dead_code)]
  52     fn clone_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
  53         if let Some(ref mut frm) = self.lastframe {
  54             let newfrm = frm.copy_buffer();
  55             *frm = newfrm.clone();
  56             Some(newfrm)
  57         } else {
  58             None
  59         }
  60     }
  61     #[allow(dead_code)]
  62     fn get_output_frame(&mut self) -> Option<NAVideoBuffer<u8>> {
  63         match self.lastframe {
  64             Some(ref frm) => Some(frm.clone()),
  65             None => None,
  66         }
  67     }
  68 }
  69
  70 #[allow(dead_code)]
  71 struct IPShuffler {
  72     lastframe: Option<NAVideoBuffer<u8>>,
  73 }
  74
  75 impl IPShuffler {
  76     #[allow(dead_code)]
  77     fn new() -> Self { IPShuffler { lastframe: None } }
  78     #[allow(dead_code)]
  79     fn clear(&mut self) { self.lastframe = None; }
  80     #[allow(dead_code)]
  81     fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
  82         self.lastframe = Some(buf);
  83     }
  84     #[allow(dead_code)]
  85     fn get_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
  86         if let Some(ref frm) = self.lastframe {
  87             Some(frm.clone())
  88         } else {
  89             None
  90         }
  91     }
  92 }
  93
  94 pub trait NADecoder {
  95     fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()>;
  96     fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef>;
  97 }
  98
  99 #[derive(Clone,Copy)]
 100 pub struct DecoderInfo {
 101     name: &'static str,
 102     get_decoder: fn () -> Box<NADecoder>,
 103 }
 104
 105 macro_rules! validate {
 106     ($a:expr) => { if !$a { return Err(DecoderError::InvalidData); } };
 107 }
 108
 109 #[cfg(feature="decoder_indeo2")]
 110 mod indeo2;
 111 #[cfg(feature="decoder_indeo3")]
 112 mod indeo3;
 113 #[cfg(feature="decoder_pcm")]
 114 mod pcm;
 115
 116 const DECODERS: &[DecoderInfo] = &[
 117 #[cfg(feature="decoder_indeo2")]
 118     DecoderInfo { name: "indeo2", get_decoder: indeo2::get_decoder },
 119 #[cfg(feature="decoder_indeo3")]
 120     DecoderInfo { name: "indeo3", get_decoder: indeo3::get_decoder },
 121 #[cfg(feature="decoder_pcm")]
 122     DecoderInfo { name: "pcm", get_decoder: pcm::get_decoder },
 123 ];
 124
 125 pub fn find_decoder(name: &str) -> Option<fn () -> Box<NADecoder>> {
 126     for &dec in DECODERS {
 127         if dec.name == name {
 128             return Some(dec.get_decoder);
 129         }
 130     }
 131     None
 132 }
 133
 134 #[cfg(test)]
 135 use std::fs::{File, OpenOptions};
 136 #[cfg(test)]
 137 use std::io::prelude::*;
 138
 139 #[cfg(test)]
 140 fn write_pgmyuv(pfx: &str, strno: usize, num: u64, frmref: NAFrameRef) {
 141     let frm = frmref.borrow();
 142     let name = format!("assets/{}out{:02}_{:04}.pgm", pfx, strno, num);
 143     let mut ofile = File::create(name).unwrap();
 144     let buf = frm.get_buffer().get_vbuf().unwrap();
 145     let (w, h) = buf.get_dimensions(0);
 146     let (w2, h2) = buf.get_dimensions(1);
 147     let tot_h = h + h2;
 148     let hdr = format!("P5\n{} {}\n255\n", w, tot_h);
 149     ofile.write_all(hdr.as_bytes()).unwrap();
 150     let dta = buf.get_data();
 151     let ls = buf.get_stride(0);
 152     let mut idx = 0;
 153     let mut idx2 = ls;
 154     let mut pad: Vec<u8> = Vec::with_capacity((w - w2 * 2) / 2);
 155     pad.resize((w - w2 * 2) / 2, 0xFF);
 156     for _ in 0..h {
 157         let line = &dta[idx..idx2];
 158         ofile.write_all(line).unwrap();
 159         idx  += ls;
 160         idx2 += ls;
 161     }
 162     let mut base1 = buf.get_offset(1);
 163     let stride1 = buf.get_stride(1);
 164     let mut base2 = buf.get_offset(2);
 165     let stride2 = buf.get_stride(2);
 166     for _ in 0..h2 {
 167         let bend1 = base1 + w2;
 168         let line = &dta[base1..bend1];
 169         ofile.write_all(line).unwrap();
 170         ofile.write_all(pad.as_slice()).unwrap();
 171
 172         let bend2 = base2 + w2;
 173         let line = &dta[base2..bend2];
 174         ofile.write_all(line).unwrap();
 175         ofile.write_all(pad.as_slice()).unwrap();
 176
 177         base1 += stride1;
 178         base2 += stride2;
 179     }
 180 }
 181
 182 #[cfg(test)]
 183 fn write_sound(pfx: &str, strno: usize, frmref: NAFrameRef, first: bool) {
 184     let frm = frmref.borrow();
 185     let name = format!("assets/{}out{:02}.raw", pfx, strno);
 186     let mut file = if first { File::create(name).unwrap() } else { OpenOptions::new().write(true).append(true).open(name).unwrap() };
 187     let btype = frm.get_buffer();
 188     let _ = match btype {
 189         NABufferType::AudioU8(ref ab)      => file.write_all(ab.get_data().as_ref()),
 190         NABufferType::AudioPacked(ref ab)   => file.write_all(ab.get_data().as_ref()),
 191         _ => Ok(()),
 192     };
 193 }