mod.rs

   1 use std::fmt;
   2 use std::ops::{Add, AddAssign, Sub, SubAssign};
   3
   4 pub use crate::frame::*;
   5 use std::mem;
   6 use crate::io::byteio::ByteIOError;
   7 use crate::io::bitreader::BitReaderError;
   8 use crate::io::codebook::CodebookError;
   9
  10 #[derive(Debug,Clone,Copy,PartialEq)]
  11 #[allow(dead_code)]
  12 pub enum DecoderError {
  13     NoFrame,
  14     AllocError,
  15     TryAgain,
  16     InvalidData,
  17     ShortData,
  18     MissingReference,
  19     NotImplemented,
  20     Bug,
  21 }
  22
  23 pub type DecoderResult<T> = Result<T, DecoderError>;
  24
  25 impl From<ByteIOError> for DecoderError {
  26     fn from(_: ByteIOError) -> Self { DecoderError::ShortData }
  27 }
  28
  29 impl From<BitReaderError> for DecoderError {
  30     fn from(e: BitReaderError) -> Self {
  31         match e {
  32             BitReaderError::BitstreamEnd => DecoderError::ShortData,
  33             _ => DecoderError::InvalidData,
  34         }
  35     }
  36 }
  37
  38 impl From<CodebookError> for DecoderError {
  39     fn from(_: CodebookError) -> Self { DecoderError::InvalidData }
  40 }
  41
  42 impl From<AllocatorError> for DecoderError {
  43     fn from(_: AllocatorError) -> Self { DecoderError::AllocError }
  44 }
  45
  46 #[allow(dead_code)]
  47 pub struct HAMShuffler {
  48     lastframe: Option<NAVideoBufferRef<u8>>,
  49 }
  50
  51 impl HAMShuffler {
  52     #[allow(dead_code)]
  53     pub fn new() -> Self { HAMShuffler { lastframe: None } }
  54     #[allow(dead_code)]
  55     pub fn clear(&mut self) { self.lastframe = None; }
  56     #[allow(dead_code)]
  57     pub fn add_frame(&mut self, buf: NAVideoBufferRef<u8>) {
  58         self.lastframe = Some(buf);
  59     }
  60     #[allow(dead_code)]
  61     pub fn clone_ref(&mut self) -> Option<NAVideoBufferRef<u8>> {
  62         if let Some(ref mut frm) = self.lastframe {
  63             let newfrm = frm.copy_buffer();
  64             *frm = newfrm.clone().into_ref();
  65             Some(newfrm.into_ref())
  66         } else {
  67             None
  68         }
  69     }
  70     #[allow(dead_code)]
  71     pub fn get_output_frame(&mut self) -> Option<NAVideoBufferRef<u8>> {
  72         match self.lastframe {
  73             Some(ref frm) => Some(frm.clone()),
  74             None => None,
  75         }
  76     }
  77 }
  78
  79 impl Default for HAMShuffler {
  80     fn default() -> Self { Self { lastframe: None } }
  81 }
  82
  83 #[allow(dead_code)]
  84 pub struct IPShuffler {
  85     lastframe: Option<NAVideoBufferRef<u8>>,
  86 }
  87
  88 impl IPShuffler {
  89     #[allow(dead_code)]
  90     pub fn new() -> Self { IPShuffler { lastframe: None } }
  91     #[allow(dead_code)]
  92     pub fn clear(&mut self) { self.lastframe = None; }
  93     #[allow(dead_code)]
  94     pub fn add_frame(&mut self, buf: NAVideoBufferRef<u8>) {
  95         self.lastframe = Some(buf);
  96     }
  97     #[allow(dead_code)]
  98     pub fn get_ref(&mut self) -> Option<NAVideoBufferRef<u8>> {
  99         if let Some(ref frm) = self.lastframe {
 100             Some(frm.clone())
 101         } else {
 102             None
 103         }
 104     }
 105 }
 106
 107 impl Default for IPShuffler {
 108     fn default() -> Self { Self { lastframe: None } }
 109 }
 110
 111 #[allow(dead_code)]
 112 pub struct IPBShuffler {
 113     lastframe: Option<NAVideoBufferRef<u8>>,
 114     nextframe: Option<NAVideoBufferRef<u8>>,
 115 }
 116
 117 impl IPBShuffler {
 118     #[allow(dead_code)]
 119     pub fn new() -> Self { IPBShuffler { lastframe: None, nextframe: None } }
 120     #[allow(dead_code)]
 121     pub fn clear(&mut self) { self.lastframe = None; self.nextframe = None; }
 122     #[allow(dead_code)]
 123     pub fn add_frame(&mut self, buf: NAVideoBufferRef<u8>) {
 124         mem::swap(&mut self.lastframe, &mut self.nextframe);
 125         self.lastframe = Some(buf);
 126     }
 127     #[allow(dead_code)]
 128     pub fn get_lastref(&mut self) -> Option<NAVideoBufferRef<u8>> {
 129         if let Some(ref frm) = self.lastframe {
 130             Some(frm.clone())
 131         } else {
 132             None
 133         }
 134     }
 135     #[allow(dead_code)]
 136     pub fn get_nextref(&mut self) -> Option<NAVideoBufferRef<u8>> {
 137         if let Some(ref frm) = self.nextframe {
 138             Some(frm.clone())
 139         } else {
 140             None
 141         }
 142     }
 143     #[allow(dead_code)]
 144     pub fn get_b_fwdref(&mut self) -> Option<NAVideoBufferRef<u8>> {
 145         if let Some(ref frm) = self.nextframe {
 146             Some(frm.clone())
 147         } else {
 148             None
 149         }
 150     }
 151     #[allow(dead_code)]
 152     pub fn get_b_bwdref(&mut self) -> Option<NAVideoBufferRef<u8>> {
 153         if let Some(ref frm) = self.lastframe {
 154             Some(frm.clone())
 155         } else {
 156             None
 157         }
 158     }
 159 }
 160
 161 impl Default for IPBShuffler {
 162     fn default() -> Self { Self { lastframe: None, nextframe: None } }
 163 }
 164
 165 #[derive(Debug,Clone,Copy,Default,PartialEq)]
 166 pub struct MV {
 167     pub x: i16,
 168     pub y: i16,
 169 }
 170
 171 #[allow(clippy::many_single_char_names)]
 172 #[allow(clippy::collapsible_if)]
 173 impl MV {
 174     pub fn new(x: i16, y: i16) -> Self { MV{ x, y } }
 175     pub fn pred(a: MV, b: MV, c: MV) -> Self {
 176         let x;
 177         if a.x < b.x {
 178             if b.x < c.x {
 179                 x = b.x;
 180             } else {
 181                 if a.x < c.x { x = c.x; } else { x = a.x; }
 182             }
 183         } else {
 184             if b.x < c.x {
 185                 if a.x < c.x { x = a.x; } else { x = c.x; }
 186             } else {
 187                 x = b.x;
 188             }
 189         }
 190         let y;
 191         if a.y < b.y {
 192             if b.y < c.y {
 193                 y = b.y;
 194             } else {
 195                 if a.y < c.y { y = c.y; } else { y = a.y; }
 196             }
 197         } else {
 198             if b.y < c.y {
 199                 if a.y < c.y { y = a.y; } else { y = c.y; }
 200             } else {
 201                 y = b.y;
 202             }
 203         }
 204         MV { x, y }
 205     }
 206 }
 207
 208 pub const ZERO_MV: MV = MV { x: 0, y: 0 };
 209
 210 impl Add for MV {
 211     type Output = MV;
 212     fn add(self, other: MV) -> MV { MV { x: self.x + other.x, y: self.y + other.y } }
 213 }
 214
 215 impl AddAssign for MV {
 216     fn add_assign(&mut self, other: MV) { self.x += other.x; self.y += other.y; }
 217 }
 218
 219 impl Sub for MV {
 220     type Output = MV;
 221     fn sub(self, other: MV) -> MV { MV { x: self.x - other.x, y: self.y - other.y } }
 222 }
 223
 224 impl SubAssign for MV {
 225     fn sub_assign(&mut self, other: MV) { self.x -= other.x; self.y -= other.y; }
 226 }
 227
 228 impl fmt::Display for MV {
 229     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 230         write!(f, "{},{}", self.x, self.y)
 231     }
 232 }
 233
 234 pub struct NADecoderSupport {
 235     pub pool_u8:        NAVideoBufferPool<u8>,
 236     pub pool_u16:       NAVideoBufferPool<u16>,
 237     pub pool_u32:       NAVideoBufferPool<u32>,
 238 }
 239
 240 impl NADecoderSupport {
 241     pub fn new() -> Self {
 242         Self {
 243             pool_u8:        NAVideoBufferPool::new(0),
 244             pool_u16:       NAVideoBufferPool::new(0),
 245             pool_u32:       NAVideoBufferPool::new(0),
 246         }
 247     }
 248 }
 249
 250 impl Default for NADecoderSupport {
 251     fn default() -> Self { Self::new() }
 252 }
 253
 254
 255 pub trait NADecoder {
 256     fn init(&mut self, supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()>;
 257     fn decode(&mut self, supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef>;
 258     fn flush(&mut self);
 259 }
 260
 261 #[derive(Clone,Copy)]
 262 pub struct DecoderInfo {
 263     pub name: &'static str,
 264     pub get_decoder: fn () -> Box<dyn NADecoder + Send>,
 265 }
 266
 267 #[cfg(any(feature="blockdsp"))]
 268 pub mod blockdsp;
 269
 270 #[cfg(feature="h263")]
 271 pub mod h263;
 272
 273 #[derive(Default)]
 274 pub struct RegisteredDecoders {
 275     decs:   Vec<DecoderInfo>,
 276 }
 277
 278 impl RegisteredDecoders {
 279     pub fn new() -> Self {
 280         Self { decs: Vec::new() }
 281     }
 282     pub fn add_decoder(&mut self, dec: DecoderInfo) {
 283         self.decs.push(dec);
 284     }
 285     pub fn find_decoder(&self, name: &str) -> Option<fn () -> Box<dyn NADecoder + Send>> {
 286         for &dec in self.decs.iter() {
 287             if dec.name == name {
 288                 return Some(dec.get_decoder);
 289             }
 290         }
 291         None
 292     }
 293     pub fn iter(&self) -> std::slice::Iter<DecoderInfo> {
 294         self.decs.iter()
 295     }
 296 }
 297
 298 pub const ZIGZAG: [usize; 64] = [
 299      0,  1,  8, 16,  9,  2,  3, 10,
 300     17, 24, 32, 25, 18, 11,  4,  5,
 301     12, 19, 26, 33, 40, 48, 41, 34,
 302     27, 20, 13,  6,  7, 14, 21, 28,
 303     35, 42, 49, 56, 57, 50, 43, 36,
 304     29, 22, 15, 23, 30, 37, 44, 51,
 305     58, 59, 52, 45, 38, 31, 39, 46,
 306     53, 60, 61, 54, 47, 55, 62, 63
 307 ];