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