[nihav.git] / nihav-codec-support / src / codecs / mod.rs

//! Decoder support functions and definitions.
use std::fmt;
use std::ops::{Add, AddAssign, Sub, SubAssign, Neg};

pub use nihav_core::frame::*;
use std::mem;

/// Frame manager for hold-and-modify codecs.
///
/// This frame manager simplifies frame management for the case when codec decodes new frame by updating parts of the previous frame.
///
/// # Examples
///
/// ```ignore
/// let mut frame = if is_intra_frame {
///         allocate_video_frame()
///     } else {
///         let ret = shuffler.clone_ref();
///         if ret.is_none() {
///             return Err(DecoderError::MissingReference);
///         }
///         ret.unwrap()
///     };
/// // output data into the frame
/// shuffler.add_frame(frame.clone()); // tells frame manager to use the frame as the next reference
/// ```
#[allow(dead_code)]
pub struct HAMShuffler<T: Copy> {
    lastframe: Option<NAVideoBufferRef<T>>,
}

impl<T: Copy> HAMShuffler<T> {
    /// Constructs a new instance of frame manager.
    #[allow(dead_code)]
    pub fn new() -> Self { HAMShuffler { lastframe: None } }
    /// Clears the reference.
    #[allow(dead_code)]
    pub fn clear(&mut self) { self.lastframe = None; }
    /// Sets a new frame reference.
    #[allow(dead_code)]
    pub fn add_frame(&mut self, buf: NAVideoBufferRef<T>) {
        self.lastframe = Some(buf);
    }
    /// Provides a copy of the reference frame if present or `None` if it is not.
    #[allow(dead_code)]
    pub fn clone_ref(&mut self) -> Option<NAVideoBufferRef<T>> {
        if let Some(ref mut frm) = self.lastframe {
            let newfrm = frm.copy_buffer();
            *frm = newfrm.clone().into_ref();
            Some(newfrm.into_ref())
        } else {
            None
        }
    }
    /// Returns the original saved reference frame or `None` if it is not present.
    #[allow(dead_code)]
    pub fn get_output_frame(&mut self) -> Option<NAVideoBufferRef<T>> {
        match self.lastframe {
            Some(ref frm) => Some(frm.clone()),
            None => None,
        }
    }
}

impl<T: Copy> Default for HAMShuffler<T> {
    fn default() -> Self { Self { lastframe: None } }
}

/// Frame manager for codecs with intra and inter frames.
///
/// This frame manager simplifies frame management for the case when codec decodes new frame using previous frame as source of some data.
///
/// # Examples
///
/// ```ignore
/// let mut frame = allocate_video_frame();
/// if is_inter_frame {
///     let ret = shuffler.get_ref();
///     if ret.is_none() {
///         return Err(DecoderError::MissingReference);
///     }
///     let ref_frame = ret.unwrap();
///     // keep decoding using data from ref_frame
/// }
/// shuffler.add_frame(frame.clone()); // tells frame manager to use the frame as the next reference
/// ```
#[allow(dead_code)]
pub struct IPShuffler {
    lastframe: Option<NAVideoBufferRef<u8>>,
}

impl IPShuffler {
    /// Constructs a new instance of frame manager.
    #[allow(dead_code)]
    pub fn new() -> Self { IPShuffler { lastframe: None } }
    /// Clears the reference.
    #[allow(dead_code)]
    pub fn clear(&mut self) { self.lastframe = None; }
    /// Sets a new frame reference.
    #[allow(dead_code)]
    pub fn add_frame(&mut self, buf: NAVideoBufferRef<u8>) {
        self.lastframe = Some(buf);
    }
    /// Returns the original saved reference frame or `None` if it is not present.
    #[allow(dead_code)]
    pub fn get_ref(&mut self) -> Option<NAVideoBufferRef<u8>> {
        if let Some(ref frm) = self.lastframe {
            Some(frm.clone())
        } else {
            None
        }
    }
}

impl Default for IPShuffler {
    fn default() -> Self { Self { lastframe: None } }
}

/// Frame manager for codecs with I-, P- and B-frames.
///
/// This frame manager simplifies frame management for the case when codec uses I/P/B frame scheme.
///
/// # Examples
///
/// ```ignore
/// let mut frame = allocate_video_frame();
/// for mb in all_macroblocks {
///     // decode macroblock type
///     match mb_type {
///         MBType::Inter => {
///             do_mc(&mut frame, shuffler.get_lastref().unwrap());
///         },
///         MBType::BForward => {
///             do_mc(&mut frame, shuffler.get_b_fwdref().unwrap());
///         },
///         MBType::BBackward => {
///             do_mc(&mut frame, shuffler.get_b_bwdref().unwrap());
///         },
///         // handle the rest of cases
///     };
/// if is_random_access_frame {
///     shuffler.clear(); // remove all saved references
/// }
/// if is_intra_frame || is_p_frame {
///     shuffler.add_frame(frame.clone()); // tells frame manager to use the frame as the next reference
/// }
/// ```
#[allow(dead_code)]
pub struct IPBShuffler {
    lastframe: Option<NAVideoBufferRef<u8>>,
    nextframe: Option<NAVideoBufferRef<u8>>,
}

impl IPBShuffler {
    /// Constructs a new instance of frame manager.
    #[allow(dead_code)]
    pub fn new() -> Self { IPBShuffler { lastframe: None, nextframe: None } }
    /// Clears the reference.
    #[allow(dead_code)]
    pub fn clear(&mut self) { self.lastframe = None; self.nextframe = None; }
    /// Sets a new frame reference.
    #[allow(dead_code)]
    pub fn add_frame(&mut self, buf: NAVideoBufferRef<u8>) {
        mem::swap(&mut self.lastframe, &mut self.nextframe);
        self.lastframe = Some(buf);
    }
    /// Returns the previous reference frame or `None` if it is not present.
    #[allow(dead_code)]
    pub fn get_lastref(&mut self) -> Option<NAVideoBufferRef<u8>> {
        if let Some(ref frm) = self.lastframe {
            Some(frm.clone())
        } else {
            None
        }
    }
    /// Returns second last reference frame or `None` if it is not present.
    #[allow(dead_code)]
    pub fn get_nextref(&mut self) -> Option<NAVideoBufferRef<u8>> {
        if let Some(ref frm) = self.nextframe {
            Some(frm.clone())
        } else {
            None
        }
    }
    /// Returns the temporally following reference for B-frame or `None` if it is not present.
    #[allow(dead_code)]
    pub fn get_b_fwdref(&mut self) -> Option<NAVideoBufferRef<u8>> {
        if let Some(ref frm) = self.nextframe {
            Some(frm.clone())
        } else {
            None
        }
    }
    /// Returns the temporally preceeding reference for B-frame or `None` if it is not present.
    #[allow(dead_code)]
    pub fn get_b_bwdref(&mut self) -> Option<NAVideoBufferRef<u8>> {
        if let Some(ref frm) = self.lastframe {
            Some(frm.clone())
        } else {
            None
        }
    }
}

impl Default for IPBShuffler {
    fn default() -> Self { Self { lastframe: None, nextframe: None } }
}

/// Motion vector data type.
///
/// # Examples
///
/// ```
/// use nihav_codec_support::codecs::MV;
///
/// let mv0 = MV::new(1, 3);
/// let mv1 = MV { x: 2, y: 3 }; // choose whatever style you prefer
/// let mv2 = mv1 - mv0;
/// let mv_pred = MV::pred(mv0, mv1, mv2); // get median prediction for the vectors (1, 0)
/// ```
#[derive(Debug,Clone,Copy,Default,PartialEq)]
pub struct MV {
    /// X coordinate of the vector.
    pub x: i16,
    /// Y coordinate of the vector.
    pub y: i16,
}

#[allow(clippy::many_single_char_names)]
#[allow(clippy::collapsible_if)]
impl MV {
    /// Creates a new motion vector instance.
    pub fn new(x: i16, y: i16) -> Self { MV{ x, y } }
    /// Predicts median from provided motion vectors.
    ///
    /// Each component of the vector is predicted as the median of corresponding input vector components.
    pub fn pred(a: MV, b: MV, c: MV) -> Self {
        let x;
        if a.x < b.x {
            if b.x < c.x {
                x = b.x;
            } else {
                if a.x < c.x { x = c.x; } else { x = a.x; }
            }
        } else {
            if b.x < c.x {
                if a.x < c.x { x = a.x; } else { x = c.x; }
            } else {
                x = b.x;
            }
        }
        let y;
        if a.y < b.y {
            if b.y < c.y {
                y = b.y;
            } else {
                if a.y < c.y { y = c.y; } else { y = a.y; }
            }
        } else {
            if b.y < c.y {
                if a.y < c.y { y = a.y; } else { y = c.y; }
            } else {
                y = b.y;
            }
        }
        MV { x, y }
    }
}

/// Zero motion vector.
pub const ZERO_MV: MV = MV { x: 0, y: 0 };

impl Add for MV {
    type Output = MV;
    fn add(self, other: MV) -> MV { MV { x: self.x + other.x, y: self.y + other.y } }
}

impl AddAssign for MV {
    fn add_assign(&mut self, other: MV) { self.x += other.x; self.y += other.y; }
}

impl Sub for MV {
    type Output = MV;
    fn sub(self, other: MV) -> MV { MV { x: self.x - other.x, y: self.y - other.y } }
}

impl SubAssign for MV {
    fn sub_assign(&mut self, other: MV) { self.x -= other.x; self.y -= other.y; }
}

impl Neg for MV {
    type Output = MV;
    fn neg(self) -> Self::Output {
        MV { x: -self.x, y: -self.y }
    }
}

impl fmt::Display for MV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{},{}", self.x, self.y)
    }
}

#[cfg(any(feature="blockdsp"))]
pub mod blockdsp;

#[cfg(feature="h263")]
#[allow(clippy::collapsible_if)]
#[allow(clippy::manual_memcpy)]
#[allow(clippy::needless_range_loop)]
pub mod h263;

/// The common 8x8 zigzag scan.
pub const ZIGZAG: [usize; 64] = [
     0,  1,  8, 16,  9,  2,  3, 10,
    17, 24, 32, 25, 18, 11,  4,  5,
    12, 19, 26, 33, 40, 48, 41, 34,
    27, 20, 13,  6,  7, 14, 21, 28,
    35, 42, 49, 56, 57, 50, 43, 36,
    29, 22, 15, 23, 30, 37, 44, 51,
    58, 59, 52, 45, 38, 31, 39, 46,
    53, 60, 61, 54, 47, 55, 62, 63
];

pub mod imaadpcm;
Commit	Line	Data
b4d5b851 KS	1	//! Decoder support functions and definitions.
b4d5b851 KS	2	use std::fmt;
473c2f76	3	use std::ops::{Add, AddAssign, Sub, SubAssign, Neg};
b4d5b851 KS	4
	5	pub use nihav_core::frame::*;
	6	use std::mem;
	7
	8	/// Frame manager for hold-and-modify codecs.
	9	///
	10	/// This frame manager simplifies frame management for the case when codec decodes new frame by updating parts of the previous frame.
	11	///
	12	/// # Examples
	13	///
fa49f061	14	/// ```ignore
b4d5b851 KS	15	/// let mut frame = if is_intra_frame {
	16	/// allocate_video_frame()
	17	/// } else {
	18	/// let ret = shuffler.clone_ref();
	19	/// if ret.is_none() {
fa49f061	20	/// return Err(DecoderError::MissingReference);
b4d5b851 KS	21	/// }
	22	/// ret.unwrap()
	23	/// };
	24	/// // output data into the frame
	25	/// shuffler.add_frame(frame.clone()); // tells frame manager to use the frame as the next reference
fa49f061	26	/// ```
b4d5b851	27	#[allow(dead_code)]
8d7a1c5c KS	28	pub struct HAMShuffler<T: Copy> {
8d7a1c5c KS	29	lastframe: Option<NAVideoBufferRef<T>>,
b4d5b851 KS	30	}
b4d5b851 KS	31
8d7a1c5c	32	impl<T: Copy> HAMShuffler<T> {
b4d5b851 KS	33	/// Constructs a new instance of frame manager.
	34	#[allow(dead_code)]
	35	pub fn new() -> Self { HAMShuffler { lastframe: None } }
	36	/// Clears the reference.
	37	#[allow(dead_code)]
	38	pub fn clear(&mut self) { self.lastframe = None; }
	39	/// Sets a new frame reference.
	40	#[allow(dead_code)]
8d7a1c5c	41	pub fn add_frame(&mut self, buf: NAVideoBufferRef<T>) {
b4d5b851 KS	42	self.lastframe = Some(buf);
	43	}
	44	/// Provides a copy of the reference frame if present or `None` if it is not.
	45	#[allow(dead_code)]
8d7a1c5c	46	pub fn clone_ref(&mut self) -> Option<NAVideoBufferRef<T>> {
b4d5b851 KS	47	if let Some(ref mut frm) = self.lastframe {
	48	let newfrm = frm.copy_buffer();
	49	*frm = newfrm.clone().into_ref();
	50	Some(newfrm.into_ref())
	51	} else {
	52	None
	53	}
	54	}
	55	/// Returns the original saved reference frame or `None` if it is not present.
	56	#[allow(dead_code)]
8d7a1c5c	57	pub fn get_output_frame(&mut self) -> Option<NAVideoBufferRef<T>> {
b4d5b851 KS	58	match self.lastframe {
	59	Some(ref frm) => Some(frm.clone()),
	60	None => None,
	61	}
	62	}
	63	}
	64
8d7a1c5c	65	impl<T: Copy> Default for HAMShuffler<T> {
b4d5b851 KS	66	fn default() -> Self { Self { lastframe: None } }
	67	}
	68
	69	/// Frame manager for codecs with intra and inter frames.
	70	///
	71	/// This frame manager simplifies frame management for the case when codec decodes new frame using previous frame as source of some data.
	72	///
	73	/// # Examples
	74	///
fa49f061	75	/// ```ignore
b4d5b851 KS	76	/// let mut frame = allocate_video_frame();
	77	/// if is_inter_frame {
	78	/// let ret = shuffler.get_ref();
	79	/// if ret.is_none() {
fa49f061	80	/// return Err(DecoderError::MissingReference);
b4d5b851 KS	81	/// }
	82	/// let ref_frame = ret.unwrap();
	83	/// // keep decoding using data from ref_frame
	84	/// }
	85	/// shuffler.add_frame(frame.clone()); // tells frame manager to use the frame as the next reference
fa49f061	86	/// ```
b4d5b851 KS	87	#[allow(dead_code)]
	88	pub struct IPShuffler {
	89	lastframe: Option<NAVideoBufferRef<u8>>,
	90	}
	91
	92	impl IPShuffler {
	93	/// Constructs a new instance of frame manager.
	94	#[allow(dead_code)]
	95	pub fn new() -> Self { IPShuffler { lastframe: None } }
	96	/// Clears the reference.
	97	#[allow(dead_code)]
	98	pub fn clear(&mut self) { self.lastframe = None; }
	99	/// Sets a new frame reference.
	100	#[allow(dead_code)]
	101	pub fn add_frame(&mut self, buf: NAVideoBufferRef<u8>) {
	102	self.lastframe = Some(buf);
	103	}
	104	/// Returns the original saved reference frame or `None` if it is not present.
	105	#[allow(dead_code)]
	106	pub fn get_ref(&mut self) -> Option<NAVideoBufferRef<u8>> {
	107	if let Some(ref frm) = self.lastframe {
	108	Some(frm.clone())
	109	} else {
	110	None
	111	}
	112	}
	113	}
	114
	115	impl Default for IPShuffler {
	116	fn default() -> Self { Self { lastframe: None } }
	117	}
	118
	119	/// Frame manager for codecs with I-, P- and B-frames.
	120	///
	121	/// This frame manager simplifies frame management for the case when codec uses I/P/B frame scheme.
	122	///
	123	/// # Examples
	124	///
fa49f061	125	/// ```ignore
b4d5b851 KS	126	/// let mut frame = allocate_video_frame();
	127	/// for mb in all_macroblocks {
	128	/// // decode macroblock type
	129	/// match mb_type {
	130	/// MBType::Inter => {
	131	/// do_mc(&mut frame, shuffler.get_lastref().unwrap());
	132	/// },
	133	/// MBType::BForward => {
	134	/// do_mc(&mut frame, shuffler.get_b_fwdref().unwrap());
	135	/// },
	136	/// MBType::BBackward => {
	137	/// do_mc(&mut frame, shuffler.get_b_bwdref().unwrap());
	138	/// },
	139	/// // handle the rest of cases
	140	/// };
	141	/// if is_random_access_frame {
	142	/// shuffler.clear(); // remove all saved references
	143	/// }
	144	/// if is_intra_frame \|\| is_p_frame {
	145	/// shuffler.add_frame(frame.clone()); // tells frame manager to use the frame as the next reference
	146	/// }
fa49f061	147	/// ```
b4d5b851 KS	148	#[allow(dead_code)]
	149	pub struct IPBShuffler {
	150	lastframe: Option<NAVideoBufferRef<u8>>,
	151	nextframe: Option<NAVideoBufferRef<u8>>,
	152	}
	153
	154	impl IPBShuffler {
	155	/// Constructs a new instance of frame manager.
	156	#[allow(dead_code)]
	157	pub fn new() -> Self { IPBShuffler { lastframe: None, nextframe: None } }
	158	/// Clears the reference.
	159	#[allow(dead_code)]
	160	pub fn clear(&mut self) { self.lastframe = None; self.nextframe = None; }
	161	/// Sets a new frame reference.
	162	#[allow(dead_code)]
	163	pub fn add_frame(&mut self, buf: NAVideoBufferRef<u8>) {
	164	mem::swap(&mut self.lastframe, &mut self.nextframe);
	165	self.lastframe = Some(buf);
	166	}
	167	/// Returns the previous reference frame or `None` if it is not present.
	168	#[allow(dead_code)]
	169	pub fn get_lastref(&mut self) -> Option<NAVideoBufferRef<u8>> {
	170	if let Some(ref frm) = self.lastframe {
	171	Some(frm.clone())
	172	} else {
	173	None
	174	}
	175	}
	176	/// Returns second last reference frame or `None` if it is not present.
	177	#[allow(dead_code)]
	178	pub fn get_nextref(&mut self) -> Option<NAVideoBufferRef<u8>> {
	179	if let Some(ref frm) = self.nextframe {
	180	Some(frm.clone())
	181	} else {
	182	None
	183	}
	184	}
	185	/// Returns the temporally following reference for B-frame or `None` if it is not present.
	186	#[allow(dead_code)]
	187	pub fn get_b_fwdref(&mut self) -> Option<NAVideoBufferRef<u8>> {
	188	if let Some(ref frm) = self.nextframe {
	189	Some(frm.clone())
	190	} else {
	191	None
	192	}
	193	}
	194	/// Returns the temporally preceeding reference for B-frame or `None` if it is not present.
	195	#[allow(dead_code)]
	196	pub fn get_b_bwdref(&mut self) -> Option<NAVideoBufferRef<u8>> {
	197	if let Some(ref frm) = self.lastframe {
	198	Some(frm.clone())
	199	} else {
	200	None
	201	}
	202	}
	203	}
	204
	205	impl Default for IPBShuffler {
	206	fn default() -> Self { Self { lastframe: None, nextframe: None } }
	207	}
	208
	209	/// Motion vector data type.
	210	///
	211	/// # Examples
212	///
213	/// ```
214	/// use nihav_codec_support::codecs::MV;
215	///
216	/// let mv0 = MV::new(1, 3);
217	/// let mv1 = MV { x: 2, y: 3 }; // choose whatever style you prefer
218	/// let mv2 = mv1 - mv0;
219	/// let mv_pred = MV::pred(mv0, mv1, mv2); // get median prediction for the vectors (1, 0)
220	/// ```
221	#[derive(Debug,Clone,Copy,Default,PartialEq)]
222	pub struct MV {
223	/// X coordinate of the vector.
224	pub x: i16,
225	/// Y coordinate of the vector.
226	pub y: i16,
227	}
228
229	#[allow(clippy::many_single_char_names)]
230	#[allow(clippy::collapsible_if)]
231	impl MV {
232	/// Creates a new motion vector instance.
233	pub fn new(x: i16, y: i16) -> Self { MV{ x, y } }
234	/// Predicts median from provided motion vectors.
235	///
236	/// Each component of the vector is predicted as the median of corresponding input vector components.
237	pub fn pred(a: MV, b: MV, c: MV) -> Self {
238	let x;
239	if a.x < b.x {
240	if b.x < c.x {
241	x = b.x;
242	} else {
243	if a.x < c.x { x = c.x; } else { x = a.x; }
244	}
245	} else {
246	if b.x < c.x {
247	if a.x < c.x { x = a.x; } else { x = c.x; }
248	} else {
249	x = b.x;
250	}
251	}
252	let y;
253	if a.y < b.y {
254	if b.y < c.y {
255	y = b.y;
256	} else {
257	if a.y < c.y { y = c.y; } else { y = a.y; }
258	}
259	} else {
260	if b.y < c.y {
261	if a.y < c.y { y = a.y; } else { y = c.y; }
262	} else {
263	y = b.y;
264	}
265	}
266	MV { x, y }
267	}
268	}
269
270	/// Zero motion vector.
271	pub const ZERO_MV: MV = MV { x: 0, y: 0 };
272
273	impl Add for MV {
274	type Output = MV;
275	fn add(self, other: MV) -> MV { MV { x: self.x + other.x, y: self.y + other.y } }
276	}
277
278	impl AddAssign for MV {
279	fn add_assign(&mut self, other: MV) { self.x += other.x; self.y += other.y; }
280	}
281
282	impl Sub for MV {
283	type Output = MV;
284	fn sub(self, other: MV) -> MV { MV { x: self.x - other.x, y: self.y - other.y } }
285	}
286
287	impl SubAssign for MV {
288	fn sub_assign(&mut self, other: MV) { self.x -= other.x; self.y -= other.y; }
289	}
290
473c2f76 KS	291	impl Neg for MV {
	292	type Output = MV;
	293	fn neg(self) -> Self::Output {
	294	MV { x: -self.x, y: -self.y }
	295	}
	296	}
	297
b4d5b851 KS	298	impl fmt::Display for MV {
	299	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	300	write!(f, "{},{}", self.x, self.y)
	301	}
	302	}
	303
	304	#[cfg(any(feature="blockdsp"))]
	305	pub mod blockdsp;
	306
	307	#[cfg(feature="h263")]
03011b99 KS	308	#[allow(clippy::collapsible_if)]
	309	#[allow(clippy::manual_memcpy)]
	310	#[allow(clippy::needless_range_loop)]
b4d5b851 KS	311	pub mod h263;
	312
	313	/// The common 8x8 zigzag scan.
	314	pub const ZIGZAG: [usize; 64] = [
	315	0, 1, 8, 16, 9, 2, 3, 10,
	316	17, 24, 32, 25, 18, 11, 4, 5,
	317	12, 19, 26, 33, 40, 48, 41, 34,
	318	27, 20, 13, 6, 7, 14, 21, 28,
	319	35, 42, 49, 56, 57, 50, 43, 36,
	320	29, 22, 15, 23, 30, 37, 44, 51,
	321	58, 59, 52, 45, 38, 31, 39, 46,
	322	53, 60, 61, 54, 47, 55, 62, 63
	323	];
e781ccc3 KS	324
e781ccc3 KS	325	pub mod imaadpcm;