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