]> git.nihav.org Git - nihav.git/blob - mod.rs
9c59c40184029358038e1a87bdcc25910503ae28
[nihav.git] / 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 ];