[nihav.git] / src / codecs / mod.rs

use frame::*;
use std::rc::Rc;
use std::cell::RefCell;
use io::byteio::ByteIOError;
use io::bitreader::BitReaderError;
use io::codebook::CodebookError;

#[derive(Debug,Clone,Copy,PartialEq)]
#[allow(dead_code)]
pub enum DecoderError {
    NoFrame,
    AllocError,
    TryAgain,
    InvalidData,
    ShortData,
    MissingReference,
    NotImplemented,
    Bug,
}

pub type DecoderResult<T> = Result<T, DecoderError>;

impl From<ByteIOError> for DecoderError {
    fn from(_: ByteIOError) -> Self { DecoderError::ShortData }
}

impl From<BitReaderError> for DecoderError {
    fn from(e: BitReaderError) -> Self {
        match e {
            BitReaderError::BitstreamEnd => DecoderError::ShortData,
            _ => DecoderError::InvalidData,
        }
    }
}

impl From<CodebookError> for DecoderError {
    fn from(_: CodebookError) -> Self { DecoderError::InvalidData }
}

impl From<AllocatorError> for DecoderError {
    fn from(_: AllocatorError) -> Self { DecoderError::AllocError }
}

macro_rules! validate {
    ($a:expr) => { if !$a { return Err(DecoderError::InvalidData); } };
}

#[allow(dead_code)]
struct HAMShuffler {
    lastframe: Option<NAVideoBuffer<u8>>,
}

impl HAMShuffler {
    #[allow(dead_code)]
    fn new() -> Self { HAMShuffler { lastframe: None } }
    #[allow(dead_code)]
    fn clear(&mut self) { self.lastframe = None; }
    #[allow(dead_code)]
    fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
        self.lastframe = Some(buf);
    }
    #[allow(dead_code)]
    fn clone_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
        if let Some(ref mut frm) = self.lastframe {
            let newfrm = frm.copy_buffer();
            *frm = newfrm.clone();
            Some(newfrm)
        } else {
            None
        }
    }
    #[allow(dead_code)]
    fn get_output_frame(&mut self) -> Option<NAVideoBuffer<u8>> {
        match self.lastframe {
            Some(ref frm) => Some(frm.clone()),
            None => None,
        }
    }
}

#[allow(dead_code)]
struct IPShuffler {
    lastframe: Option<NAVideoBuffer<u8>>,
}

impl IPShuffler {
    #[allow(dead_code)]
    fn new() -> Self { IPShuffler { lastframe: None } }
    #[allow(dead_code)]
    fn clear(&mut self) { self.lastframe = None; }
    #[allow(dead_code)]
    fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
        self.lastframe = Some(buf);
    }
    #[allow(dead_code)]
    fn get_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
        if let Some(ref frm) = self.lastframe {
            Some(frm.clone())
        } else {
            None
        }
    }
}

pub trait NADecoder {
    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()>;
    fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef>;
}

#[derive(Clone,Copy)]
pub struct DecoderInfo {
    name: &'static str,
    get_decoder: fn () -> Box<NADecoder>,
}

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

#[cfg(feature="decoder_gdvvid")]
mod gremlinvideo;
#[cfg(any(feature="decoder_indeo2", feature="decoder_indeo3", feature="decoder_imc"))]
mod indeo;
#[cfg(feature="h263")]
mod h263;

#[cfg(feature="decoder_pcm")]
mod pcm;

const DECODERS: &[DecoderInfo] = &[
#[cfg(feature="decoder_gdvvid")]
    DecoderInfo { name: "gdv-video", get_decoder: gremlinvideo::get_decoder },
#[cfg(feature="decoder_indeo2")]
    DecoderInfo { name: "indeo2", get_decoder: indeo::indeo2::get_decoder },
#[cfg(feature="decoder_indeo3")]
    DecoderInfo { name: "indeo3", get_decoder: indeo::indeo3::get_decoder },
#[cfg(feature="decoder_intel263")]
    DecoderInfo { name: "intel263", get_decoder: h263::intel263::get_decoder },

#[cfg(feature="decoder_pcm")]
    DecoderInfo { name: "pcm", get_decoder: pcm::get_decoder },
#[cfg(feature="decoder_imc")]
    DecoderInfo { name: "imc", get_decoder: indeo::imc::get_decoder_imc },
#[cfg(feature="decoder_imc")]
    DecoderInfo { name: "iac", get_decoder: indeo::imc::get_decoder_iac },
];

pub fn find_decoder(name: &str) -> Option<fn () -> Box<NADecoder>> {
    for &dec in DECODERS {
        if dec.name == name {
            return Some(dec.get_decoder);
        }
    }
    None
}

#[cfg(test)]
use std::fs::{File, OpenOptions};
#[cfg(test)]
use std::io::prelude::*;

#[cfg(test)]
#[allow(dead_code)]
fn write_pgmyuv(pfx: &str, strno: usize, num: u64, frmref: NAFrameRef) {
    let frm = frmref.borrow();
    if let NABufferType::None = frm.get_buffer() { return; }
    let name = format!("assets/{}out{:02}_{:04}.pgm", pfx, strno, num);
    let mut ofile = File::create(name).unwrap();
    let buf = frm.get_buffer().get_vbuf().unwrap();
    let (w, h) = buf.get_dimensions(0);
    let (w2, h2) = buf.get_dimensions(1);
    let tot_h = h + h2;
    let hdr = format!("P5\n{} {}\n255\n", w, tot_h);
    ofile.write_all(hdr.as_bytes()).unwrap();
    let dta = buf.get_data();
    let ls = buf.get_stride(0);
    let mut idx = 0;
    let mut idx2 = w;
    let mut pad: Vec<u8> = Vec::with_capacity((w - w2 * 2) / 2);
    pad.resize((w - w2 * 2) / 2, 0xFF);
    for _ in 0..h {
        let line = &dta[idx..idx2];
        ofile.write_all(line).unwrap();
        idx  += ls;
        idx2 += ls;
    }
    let mut base1 = buf.get_offset(1);
    let stride1 = buf.get_stride(1);
    let mut base2 = buf.get_offset(2);
    let stride2 = buf.get_stride(2);
    for _ in 0..h2 {
        let bend1 = base1 + w2;
        let line = &dta[base1..bend1];
        ofile.write_all(line).unwrap();
        ofile.write_all(pad.as_slice()).unwrap();

        let bend2 = base2 + w2;
        let line = &dta[base2..bend2];
        ofile.write_all(line).unwrap();
        ofile.write_all(pad.as_slice()).unwrap();

        base1 += stride1;
        base2 += stride2;
    }
}

#[cfg(test)]
#[allow(dead_code)]
fn write_palppm(pfx: &str, strno: usize, num: u64, frmref: NAFrameRef) {
    let frm = frmref.borrow();
    let name = format!("assets/{}out{:02}_{:04}.ppm", pfx, strno, num);
    let mut ofile = File::create(name).unwrap();
    let buf = frm.get_buffer().get_vbuf().unwrap();
    let (w, h) = buf.get_dimensions(0);
    let paloff = buf.get_offset(1);
    let hdr = format!("P6\n{} {}\n255\n", w, h);
    ofile.write_all(hdr.as_bytes()).unwrap();
    let dta = buf.get_data();
    let ls = buf.get_stride(0);
    let mut idx  = 0;
    let mut line: Vec<u8> = Vec::with_capacity(w * 3);
    line.resize(w * 3, 0);
    for _ in 0..h {
        let src = &dta[idx..(idx+w)];
        for x in 0..w {
            let pix = src[x] as usize;
            line[x * 3 + 0] = dta[paloff + pix * 3 + 2];
            line[x * 3 + 1] = dta[paloff + pix * 3 + 1];
            line[x * 3 + 2] = dta[paloff + pix * 3 + 0];
        }
        ofile.write_all(line.as_slice()).unwrap();
        idx  += ls;
    }
}

#[cfg(test)]
#[allow(dead_code)]
fn write_sound(pfx: &str, strno: usize, frmref: NAFrameRef, first: bool) {
    let frm = frmref.borrow();
    let name = format!("assets/{}out{:02}.raw", pfx, strno);
    let mut file = if first { File::create(name).unwrap() } else { OpenOptions::new().write(true).append(true).open(name).unwrap() };
    let btype = frm.get_buffer();
    let _ = match btype {
        NABufferType::AudioU8(ref ab)      => file.write_all(ab.get_data().as_ref()),
        NABufferType::AudioPacked(ref ab)   => file.write_all(ab.get_data().as_ref()),
        _ => Ok(()),
    };
}
Commit	Line	Data
77d06de2	1	use frame::*;
88c03b61 KS	2	use std::rc::Rc;
88c03b61 KS	3	use std::cell::RefCell;
77d06de2 KS	4	use io::byteio::ByteIOError;
	5	use io::bitreader::BitReaderError;
	6	use io::codebook::CodebookError;
	7
	8	#[derive(Debug,Clone,Copy,PartialEq)]
	9	#[allow(dead_code)]
	10	pub enum DecoderError {
6d3bb0b2	11	NoFrame,
e35062e7	12	AllocError,
503374e7	13	TryAgain,
77d06de2 KS	14	InvalidData,
	15	ShortData,
	16	MissingReference,
	17	NotImplemented,
	18	Bug,
	19	}
	20
cf64af13	21	pub type DecoderResult<T> = Result<T, DecoderError>;
77d06de2 KS	22
	23	impl From<ByteIOError> for DecoderError {
	24	fn from(_: ByteIOError) -> Self { DecoderError::ShortData }
	25	}
	26
	27	impl From<BitReaderError> for DecoderError {
	28	fn from(e: BitReaderError) -> Self {
	29	match e {
	30	BitReaderError::BitstreamEnd => DecoderError::ShortData,
	31	_ => DecoderError::InvalidData,
	32	}
	33	}
	34	}
	35
	36	impl From<CodebookError> for DecoderError {
	37	fn from(_: CodebookError) -> Self { DecoderError::InvalidData }
	38	}
	39
e35062e7 KS	40	impl From<AllocatorError> for DecoderError {
	41	fn from(_: AllocatorError) -> Self { DecoderError::AllocError }
	42	}
	43
cf64af13 KS	44	macro_rules! validate {
	45	($a:expr) => { if !$a { return Err(DecoderError::InvalidData); } };
	46	}
	47
88c03b61 KS	48	#[allow(dead_code)]
88c03b61 KS	49	struct HAMShuffler {
22cb00db	50	lastframe: Option<NAVideoBuffer<u8>>,
88c03b61 KS	51	}
	52
	53	impl HAMShuffler {
	54	#[allow(dead_code)]
	55	fn new() -> Self { HAMShuffler { lastframe: None } }
	56	#[allow(dead_code)]
	57	fn clear(&mut self) { self.lastframe = None; }
	58	#[allow(dead_code)]
22cb00db KS	59	fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
22cb00db KS	60	self.lastframe = Some(buf);
88c03b61 KS	61	}
88c03b61 KS	62	#[allow(dead_code)]
22cb00db	63	fn clone_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
3bd541c8	64	if let Some(ref mut frm) = self.lastframe {
22cb00db	65	let newfrm = frm.copy_buffer();
3bd541c8 KS	66	*frm = newfrm.clone();
3bd541c8 KS	67	Some(newfrm)
5c253468 KS	68	} else {
	69	None
	70	}
88c03b61 KS	71	}
88c03b61 KS	72	#[allow(dead_code)]
22cb00db	73	fn get_output_frame(&mut self) -> Option<NAVideoBuffer<u8>> {
88c03b61 KS	74	match self.lastframe {
	75	Some(ref frm) => Some(frm.clone()),
	76	None => None,
	77	}
	78	}
	79	}
	80
3f29a2a8 KS	81	#[allow(dead_code)]
	82	struct IPShuffler {
	83	lastframe: Option<NAVideoBuffer<u8>>,
	84	}
	85
	86	impl IPShuffler {
	87	#[allow(dead_code)]
	88	fn new() -> Self { IPShuffler { lastframe: None } }
	89	#[allow(dead_code)]
	90	fn clear(&mut self) { self.lastframe = None; }
	91	#[allow(dead_code)]
	92	fn add_frame(&mut self, buf: NAVideoBuffer<u8>) {
	93	self.lastframe = Some(buf);
	94	}
	95	#[allow(dead_code)]
	96	fn get_ref(&mut self) -> Option<NAVideoBuffer<u8>> {
	97	if let Some(ref frm) = self.lastframe {
	98	Some(frm.clone())
	99	} else {
	100	None
	101	}
	102	}
	103	}
	104
77d06de2 KS	105	pub trait NADecoder {
77d06de2 KS	106	fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()>;
88c03b61	107	fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef>;
77d06de2 KS	108	}
77d06de2 KS	109
70259941	110	#[derive(Clone,Copy)]
2a4130ba	111	pub struct DecoderInfo {
70259941 KS	112	name: &'static str,
	113	get_decoder: fn () -> Box<NADecoder>,
	114	}
	115
88c58b1b KS	116	#[cfg(feature="h263")]
	117	mod blockdsp;
	118
e120f8fd KS	119	#[cfg(feature="decoder_gdvvid")]
e120f8fd KS	120	mod gremlinvideo;
e35062e7	121	#[cfg(any(feature="decoder_indeo2", feature="decoder_indeo3", feature="decoder_imc"))]
88c58b1b KS	122	mod indeo;
	123	#[cfg(feature="h263")]
	124	mod h263;
cf64af13	125
3f29a2a8 KS	126	#[cfg(feature="decoder_pcm")]
	127	mod pcm;
	128
2a4130ba	129	const DECODERS: &[DecoderInfo] = &[
e120f8fd KS	130	#[cfg(feature="decoder_gdvvid")]
e120f8fd KS	131	DecoderInfo { name: "gdv-video", get_decoder: gremlinvideo::get_decoder },
70259941	132	#[cfg(feature="decoder_indeo2")]
88c58b1b	133	DecoderInfo { name: "indeo2", get_decoder: indeo::indeo2::get_decoder },
3f29a2a8	134	#[cfg(feature="decoder_indeo3")]
88c58b1b KS	135	DecoderInfo { name: "indeo3", get_decoder: indeo::indeo3::get_decoder },
	136	#[cfg(feature="decoder_intel263")]
	137	DecoderInfo { name: "intel263", get_decoder: h263::intel263::get_decoder },
cf64af13	138
3234da61 KS	139	#[cfg(feature="decoder_pcm")]
3234da61 KS	140	DecoderInfo { name: "pcm", get_decoder: pcm::get_decoder },
e35062e7 KS	141	#[cfg(feature="decoder_imc")]
	142	DecoderInfo { name: "imc", get_decoder: indeo::imc::get_decoder_imc },
	143	#[cfg(feature="decoder_imc")]
	144	DecoderInfo { name: "iac", get_decoder: indeo::imc::get_decoder_iac },
70259941 KS	145	];
	146
	147	pub fn find_decoder(name: &str) -> Option<fn () -> Box<NADecoder>> {
	148	for &dec in DECODERS {
	149	if dec.name == name {
	150	return Some(dec.get_decoder);
	151	}
	152	}
	153	None
	154	}
3f29a2a8 KS	155
	156	#[cfg(test)]
	157	use std::fs::{File, OpenOptions};
	158	#[cfg(test)]
	159	use std::io::prelude::*;
	160
	161	#[cfg(test)]
503374e7	162	#[allow(dead_code)]
3f29a2a8 KS	163	fn write_pgmyuv(pfx: &str, strno: usize, num: u64, frmref: NAFrameRef) {
3f29a2a8 KS	164	let frm = frmref.borrow();
cf64af13	165	if let NABufferType::None = frm.get_buffer() { return; }
3f29a2a8 KS	166	let name = format!("assets/{}out{:02}_{:04}.pgm", pfx, strno, num);
	167	let mut ofile = File::create(name).unwrap();
	168	let buf = frm.get_buffer().get_vbuf().unwrap();
	169	let (w, h) = buf.get_dimensions(0);
	170	let (w2, h2) = buf.get_dimensions(1);
	171	let tot_h = h + h2;
	172	let hdr = format!("P5\n{} {}\n255\n", w, tot_h);
	173	ofile.write_all(hdr.as_bytes()).unwrap();
	174	let dta = buf.get_data();
	175	let ls = buf.get_stride(0);
	176	let mut idx = 0;
6c8e5c40	177	let mut idx2 = w;
3f29a2a8 KS	178	let mut pad: Vec<u8> = Vec::with_capacity((w - w2 * 2) / 2);
	179	pad.resize((w - w2 * 2) / 2, 0xFF);
	180	for _ in 0..h {
	181	let line = &dta[idx..idx2];
	182	ofile.write_all(line).unwrap();
	183	idx += ls;
	184	idx2 += ls;
	185	}
	186	let mut base1 = buf.get_offset(1);
	187	let stride1 = buf.get_stride(1);
	188	let mut base2 = buf.get_offset(2);
	189	let stride2 = buf.get_stride(2);
	190	for _ in 0..h2 {
	191	let bend1 = base1 + w2;
	192	let line = &dta[base1..bend1];
	193	ofile.write_all(line).unwrap();
	194	ofile.write_all(pad.as_slice()).unwrap();
	195
	196	let bend2 = base2 + w2;
	197	let line = &dta[base2..bend2];
	198	ofile.write_all(line).unwrap();
	199	ofile.write_all(pad.as_slice()).unwrap();
	200
	201	base1 += stride1;
	202	base2 += stride2;
	203	}
	204	}
	205
	206	#[cfg(test)]
503374e7 KS	207	#[allow(dead_code)]
	208	fn write_palppm(pfx: &str, strno: usize, num: u64, frmref: NAFrameRef) {
	209	let frm = frmref.borrow();
	210	let name = format!("assets/{}out{:02}_{:04}.ppm", pfx, strno, num);
	211	let mut ofile = File::create(name).unwrap();
	212	let buf = frm.get_buffer().get_vbuf().unwrap();
	213	let (w, h) = buf.get_dimensions(0);
	214	let paloff = buf.get_offset(1);
	215	let hdr = format!("P6\n{} {}\n255\n", w, h);
	216	ofile.write_all(hdr.as_bytes()).unwrap();
	217	let dta = buf.get_data();
	218	let ls = buf.get_stride(0);
	219	let mut idx = 0;
	220	let mut line: Vec<u8> = Vec::with_capacity(w * 3);
	221	line.resize(w * 3, 0);
	222	for _ in 0..h {
	223	let src = &dta[idx..(idx+w)];
	224	for x in 0..w {
	225	let pix = src[x] as usize;
	226	line[x * 3 + 0] = dta[paloff + pix * 3 + 2];
	227	line[x * 3 + 1] = dta[paloff + pix * 3 + 1];
	228	line[x * 3 + 2] = dta[paloff + pix * 3 + 0];
	229	}
	230	ofile.write_all(line.as_slice()).unwrap();
	231	idx += ls;
	232	}
	233	}
	234
	235	#[cfg(test)]
	236	#[allow(dead_code)]
3f29a2a8 KS	237	fn write_sound(pfx: &str, strno: usize, frmref: NAFrameRef, first: bool) {
	238	let frm = frmref.borrow();
	239	let name = format!("assets/{}out{:02}.raw", pfx, strno);
	240	let mut file = if first { File::create(name).unwrap() } else { OpenOptions::new().write(true).append(true).open(name).unwrap() };
	241	let btype = frm.get_buffer();
	242	let _ = match btype {
	243	NABufferType::AudioU8(ref ab) => file.write_all(ab.get_data().as_ref()),
	244	NABufferType::AudioPacked(ref ab) => file.write_all(ab.get_data().as_ref()),
	245	_ => Ok(()),
	246	};
	247	}