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