nihav-core/src/codecs/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 }
 259
 260 #[derive(Clone,Copy)]
 261 pub struct DecoderInfo {
 262     pub name: &'static str,
 263     pub get_decoder: fn () -> Box<dyn NADecoder>,
 264 }
 265
 266 #[cfg(any(feature="blockdsp"))]
 267 pub mod blockdsp;
 268
 269 #[cfg(feature="h263")]
 270 pub mod h263;
 271
 272 #[derive(Default)]
 273 pub struct RegisteredDecoders {
 274     decs:   Vec<DecoderInfo>,
 275 }
 276
 277 impl RegisteredDecoders {
 278     pub fn new() -> Self {
 279         Self { decs: Vec::new() }
 280     }
 281     pub fn add_decoder(&mut self, dec: DecoderInfo) {
 282         self.decs.push(dec);
 283     }
 284     pub fn find_decoder(&self, name: &str) -> Option<fn () -> Box<dyn NADecoder>> {
 285         for &dec in self.decs.iter() {
 286             if dec.name == name {
 287                 return Some(dec.get_decoder);
 288             }
 289         }
 290         None
 291     }
 292     pub fn iter(&self) -> std::slice::Iter<DecoderInfo> {
 293         self.decs.iter()
 294     }
 295 }