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