src/codecs/mod.rs

   1 use std::fmt;
   2 use std::ops::{Add, AddAssign, Sub, SubAssign};
   3
   4 use crate::frame::*;
   5 use std::rc::Rc;
   6 use std::cell::RefCell;
   7 use std::mem;
   8 use crate::io::byteio::ByteIOError;
   9 use crate::io::bitreader::BitReaderError;
  10 use crate::io::codebook::CodebookError;
  11
  12 #[derive(Debug,Clone,Copy,PartialEq)]
  13 #[allow(dead_code)]
  14 pub enum DecoderError {
  15     NoFrame,
  16     AllocError,
  17     TryAgain,
  18     InvalidData,
  19     ShortData,
  20     MissingReference,
  21     NotImplemented,
  22     Bug,
  23 }
  24
  25 pub type DecoderResult<T> = Result<T, DecoderError>;
  26
  27 impl From<ByteIOError> for DecoderError {
  28     fn from(_: ByteIOError) -> Self { DecoderError::ShortData }
  29 }
  30
  31 impl From<BitReaderError> for DecoderError {
  32     fn from(e: BitReaderError) -> Self {
  33         match e {
  34             BitReaderError::BitstreamEnd => DecoderError::ShortData,
  35             _ => DecoderError::InvalidData,
  36         }
  37     }
  38 }
  39
  40 impl From<CodebookError> for DecoderError {
  41     fn from(_: CodebookError) -> Self { DecoderError::InvalidData }
  42 }
  43
  44 impl From<AllocatorError> for DecoderError {
  45     fn from(_: AllocatorError) -> Self { DecoderError::AllocError }
  46 }
  47
  48 macro_rules! validate {
  49     ($a:expr) => { if !$a { println!("check failed at {}:{}", file!(), line!()); return Err(DecoderError::InvalidData); } };
  50 }
  51
  52 #[allow(dead_code)]
  53 struct HAMShuffler {
  54     lastframe: Option<NAVideoBuffer<u8>>,
  55 }
  56
  57 impl HAMShuffler {
  58     #[allow(dead_code)]
  59     fn new() -> Self { HAMShuffler { lastframe: None } }
  60     #[allow(dead_code)]
  61     fn clear(&mut self) { self.lastframe = None; }
  62     #[allow(dead_code)]
  63     fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
  64         self.lastframe = Some(buf);
  65     }
  66     #[allow(dead_code)]
  67     fn clone_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
  68         if let Some(ref mut frm) = self.lastframe {
  69             let newfrm = frm.copy_buffer();
  70             *frm = newfrm.clone();
  71             Some(newfrm)
  72         } else {
  73             None
  74         }
  75     }
  76     #[allow(dead_code)]
  77     fn get_output_frame(&mut self) -> Option<NAVideoBuffer<u8>> {
  78         match self.lastframe {
  79             Some(ref frm) => Some(frm.clone()),
  80             None => None,
  81         }
  82     }
  83 }
  84
  85 #[allow(dead_code)]
  86 struct IPShuffler {
  87     lastframe: Option<NAVideoBuffer<u8>>,
  88 }
  89
  90 impl IPShuffler {
  91     #[allow(dead_code)]
  92     fn new() -> Self { IPShuffler { lastframe: None } }
  93     #[allow(dead_code)]
  94     fn clear(&mut self) { self.lastframe = None; }
  95     #[allow(dead_code)]
  96     fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
  97         self.lastframe = Some(buf);
  98     }
  99     #[allow(dead_code)]
 100     fn get_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
 101         if let Some(ref frm) = self.lastframe {
 102             Some(frm.clone())
 103         } else {
 104             None
 105         }
 106     }
 107 }
 108
 109 #[allow(dead_code)]
 110 struct IPBShuffler {
 111     lastframe: Option<NAVideoBuffer<u8>>,
 112     nextframe: Option<NAVideoBuffer<u8>>,
 113 }
 114
 115 impl IPBShuffler {
 116     #[allow(dead_code)]
 117     fn new() -> Self { IPBShuffler { lastframe: None, nextframe: None } }
 118     #[allow(dead_code)]
 119     fn clear(&mut self) { self.lastframe = None; self.nextframe = None; }
 120     #[allow(dead_code)]
 121     fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
 122         mem::swap(&mut self.lastframe, &mut self.nextframe);
 123         self.lastframe = Some(buf);
 124     }
 125     #[allow(dead_code)]
 126     fn get_lastref(&mut self) -> Option<NAVideoBuffer<u8>> {
 127         if let Some(ref frm) = self.lastframe {
 128             Some(frm.clone())
 129         } else {
 130             None
 131         }
 132     }
 133     #[allow(dead_code)]
 134     fn get_nextref(&mut self) -> Option<NAVideoBuffer<u8>> {
 135         if let Some(ref frm) = self.nextframe {
 136             Some(frm.clone())
 137         } else {
 138             None
 139         }
 140     }
 141     #[allow(dead_code)]
 142     fn get_b_fwdref(&mut self) -> Option<NAVideoBuffer<u8>> {
 143         if let Some(ref frm) = self.nextframe {
 144             Some(frm.clone())
 145         } else {
 146             None
 147         }
 148     }
 149     #[allow(dead_code)]
 150     fn get_b_bwdref(&mut self) -> Option<NAVideoBuffer<u8>> {
 151         if let Some(ref frm) = self.lastframe {
 152             Some(frm.clone())
 153         } else {
 154             None
 155         }
 156     }
 157 }
 158
 159 #[derive(Debug,Clone,Copy,PartialEq)]
 160 pub struct MV {
 161     pub x: i16,
 162     pub y: i16,
 163 }
 164
 165 impl MV {
 166     pub fn new(x: i16, y: i16) -> Self { MV{ x: x, y: y } }
 167     pub fn pred(a: MV, b: MV, c: MV) -> Self {
 168         let x;
 169         if a.x < b.x {
 170             if b.x < c.x {
 171                 x = b.x;
 172             } else {
 173                 if a.x < c.x { x = c.x; } else { x = a.x; }
 174             }
 175         } else {
 176             if b.x < c.x {
 177                 if a.x < c.x { x = a.x; } else { x = c.x; }
 178             } else {
 179                 x = b.x;
 180             }
 181         }
 182         let y;
 183         if a.y < b.y {
 184             if b.y < c.y {
 185                 y = b.y;
 186             } else {
 187                 if a.y < c.y { y = c.y; } else { y = a.y; }
 188             }
 189         } else {
 190             if b.y < c.y {
 191                 if a.y < c.y { y = a.y; } else { y = c.y; }
 192             } else {
 193                 y = b.y;
 194             }
 195         }
 196         MV { x: x, y: y }
 197     }
 198 }
 199
 200 pub const ZERO_MV: MV = MV { x: 0, y: 0 };
 201
 202 impl Add for MV {
 203     type Output = MV;
 204     fn add(self, other: MV) -> MV { MV { x: self.x + other.x, y: self.y + other.y } }
 205 }
 206
 207 impl AddAssign for MV {
 208     fn add_assign(&mut self, other: MV) { self.x += other.x; self.y += other.y; }
 209 }
 210
 211 impl Sub for MV {
 212     type Output = MV;
 213     fn sub(self, other: MV) -> MV { MV { x: self.x - other.x, y: self.y - other.y } }
 214 }
 215
 216 impl SubAssign for MV {
 217     fn sub_assign(&mut self, other: MV) { self.x -= other.x; self.y -= other.y; }
 218 }
 219
 220 impl fmt::Display for MV {
 221     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 222         write!(f, "{},{}", self.x, self.y)
 223     }
 224 }
 225
 226
 227 pub trait NADecoder {
 228     fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()>;
 229     fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef>;
 230 }
 231
 232 #[derive(Clone,Copy)]
 233 pub struct DecoderInfo {
 234     name: &'static str,
 235     get_decoder: fn () -> Box<NADecoder>,
 236 }
 237
 238 #[cfg(any(feature="h263", feature="decoder_realvideo3", feature="decoder_realvideo4"))]
 239 mod blockdsp;
 240
 241 #[cfg(feature="decoder_clearvideo")]
 242 mod clearvideo;
 243 #[cfg(feature="decoder_gdvvid")]
 244 mod gremlinvideo;
 245 #[cfg(any(feature="decoder_indeo2", feature="decoder_indeo3", feature="decoder_indeo4", feature="decoder_indeo5", feature="decoder_imc"))]
 246 mod indeo;
 247 #[cfg(feature="h263")]
 248 mod h263;
 249 #[cfg(any(feature="decoder_realvideo3", feature="decoder_realvideo4", feature="decoder_realvideo6", feature="decoder_realaudio144", feature="decoder_realaudio288", feature="decoder_cook", feature="decoder_ralf"))]
 250 mod real;
 251
 252 #[cfg(feature="decoder_aac")]
 253 mod aac;
 254 #[cfg(feature="decoder_atrac3")]
 255 mod atrac3;
 256 #[cfg(feature="decoder_pcm")]
 257 mod pcm;
 258 #[cfg(feature="decoder_sipro")]
 259 mod sipro;
 260 #[cfg(feature="decoder_ts102366")]
 261 mod ts102366;
 262
 263 const DECODERS: &[DecoderInfo] = &[
 264 #[cfg(feature="decoder_clearvideo")]
 265     DecoderInfo { name: "clearvideo", get_decoder: clearvideo::get_decoder },
 266 #[cfg(feature="decoder_clearvideo")]
 267     DecoderInfo { name: "clearvideo_rm", get_decoder: clearvideo::get_decoder_rm },
 268 #[cfg(feature="decoder_gdvvid")]
 269     DecoderInfo { name: "gdv-audio", get_decoder: gremlinvideo::get_decoder_audio },
 270 #[cfg(feature="decoder_gdvvid")]
 271     DecoderInfo { name: "gdv-video", get_decoder: gremlinvideo::get_decoder_video },
 272 #[cfg(feature="decoder_indeo2")]
 273     DecoderInfo { name: "indeo2", get_decoder: indeo::indeo2::get_decoder },
 274 #[cfg(feature="decoder_indeo3")]
 275     DecoderInfo { name: "indeo3", get_decoder: indeo::indeo3::get_decoder },
 276 #[cfg(feature="decoder_indeo4")]
 277     DecoderInfo { name: "indeo4", get_decoder: indeo::indeo4::get_decoder },
 278 #[cfg(feature="decoder_indeo5")]
 279     DecoderInfo { name: "indeo5", get_decoder: indeo::indeo5::get_decoder },
 280 #[cfg(feature="decoder_intel263")]
 281     DecoderInfo { name: "intel263", get_decoder: h263::intel263::get_decoder },
 282 #[cfg(feature="decoder_realvideo1")]
 283     DecoderInfo { name: "realvideo1", get_decoder: h263::rv10::get_decoder },
 284 #[cfg(feature="decoder_realvideo2")]
 285     DecoderInfo { name: "realvideo2", get_decoder: h263::rv20::get_decoder },
 286 #[cfg(feature="decoder_realvideo3")]
 287     DecoderInfo { name: "realvideo3", get_decoder: real::rv30::get_decoder },
 288 #[cfg(feature="decoder_realvideo4")]
 289     DecoderInfo { name: "realvideo4", get_decoder: real::rv40::get_decoder },
 290 #[cfg(feature="decoder_realvideo6")]
 291     DecoderInfo { name: "realvideo6", get_decoder: real::rv60::get_decoder },
 292
 293 #[cfg(feature="decoder_pcm")]
 294     DecoderInfo { name: "pcm", get_decoder: pcm::get_decoder },
 295 #[cfg(feature="decoder_imc")]
 296     DecoderInfo { name: "imc", get_decoder: indeo::imc::get_decoder_imc },
 297 #[cfg(feature="decoder_imc")]
 298     DecoderInfo { name: "iac", get_decoder: indeo::imc::get_decoder_iac },
 299 #[cfg(feature="decoder_realaudio144")]
 300     DecoderInfo { name: "ra14.4", get_decoder: real::ra144::get_decoder },
 301 #[cfg(feature="decoder_realaudio288")]
 302     DecoderInfo { name: "ra28.8", get_decoder: real::ra288::get_decoder },
 303 #[cfg(feature="decoder_sipro")]
 304     DecoderInfo { name: "sipro", get_decoder: sipro::get_decoder },
 305 #[cfg(feature="decoder_ts102366")]
 306     DecoderInfo { name: "ac3", get_decoder: ts102366::get_decoder },
 307 #[cfg(feature="decoder_cook")]
 308     DecoderInfo { name: "cook", get_decoder: real::cook::get_decoder },
 309 #[cfg(feature="decoder_atrac3")]
 310     DecoderInfo { name: "atrac3", get_decoder: atrac3::get_decoder },
 311 #[cfg(feature="decoder_aac")]
 312     DecoderInfo { name: "aac", get_decoder: aac::get_decoder },
 313 #[cfg(feature="decoder_ralf")]
 314     DecoderInfo { name: "ralf", get_decoder: real::ralf::get_decoder },
 315 ];
 316
 317 pub fn find_decoder(name: &str) -> Option<fn () -> Box<NADecoder>> {
 318     for &dec in DECODERS {
 319         if dec.name == name {
 320             return Some(dec.get_decoder);
 321         }
 322     }
 323     None
 324 }