[nihav.git] / nihav-duck / src / codecs / dkadpcm.rs

use nihav_core::codecs::*;
use nihav_core::io::byteio::*;
use nihav_codec_support::codecs::imaadpcm::*;
use std::str::FromStr;

struct DuckADPCMDecoder {
    ainfo:      NAAudioInfo,
    chmap:      NAChannelMap,
    is_dk3:     bool,
    ch_state:   [IMAState; 2],
    block_len:  usize,
}

impl DuckADPCMDecoder {
    fn new(is_dk3: bool) -> Self {
        Self {
            ainfo:      NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
            chmap:      NAChannelMap::new(),
            is_dk3,
            ch_state:   [IMAState::new(), IMAState::new()],
            block_len:  0,
        }
    }
}

impl NADecoder for DuckADPCMDecoder {
    fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
        if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
            validate!(ainfo.get_block_len() > 16);
            self.block_len = ainfo.get_block_len();
            let channels = ainfo.get_channels();
            validate!(channels == 2 || (!self.is_dk3 && channels == 1));
            let len = if self.is_dk3 {
                    ((self.block_len - 16) * 2 / 3) * 2
                } else {
                    (self.block_len - 4 * (channels as usize)) * 2 / (channels as usize)
                };
            self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), channels, SND_S16P_FORMAT, len);
            self.chmap = NAChannelMap::from_str(if channels == 1 { "C" } else { "L,R" }).unwrap();
            Ok(())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    #[allow(clippy::identity_op)]
    fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
        let info = pkt.get_stream().get_info();
        if let NACodecTypeInfo::Audio(_) = info.get_properties() {
            let pktbuf = pkt.get_buffer();
            validate!(pktbuf.len() > (if self.is_dk3 { 16 } else { 4 * self.chmap.num_channels() }));
            let nblocks = pktbuf.len() / self.block_len;
            let out_block_len = self.ainfo.get_block_len();
            let duration = out_block_len * nblocks;
            let abuf = alloc_audio_buffer(self.ainfo, duration, self.chmap.clone())?;
            let mut adata = abuf.get_abuf_i16().unwrap();
            let mut off0 = adata.get_offset(0);
            let mut off1 = adata.get_offset(1);
            let dst = adata.get_data_mut().unwrap();

            for blk in pktbuf.chunks_exact(self.block_len) {
                let mut mr = MemoryReader::new_read(blk);
                let mut br = ByteReader::new(&mut mr);
                if self.is_dk3 {
                    let _typeid                 = br.read_byte()?;
                    let _version                = br.read_byte()?;
                    let _srate                  = br.read_u32le()?;
                    let samples                 = br.read_u32le()? as usize;
                    let sumpred                 = br.read_u16le()? as i16;
                    let diffpred                = br.read_u16le()? as i16;
                    let sumstep                 = br.read_byte()?;
                    let diffstep                = br.read_byte()?;
                    validate!(sumstep <= IMA_MAX_STEP && diffstep <= IMA_MAX_STEP);
                    validate!(samples <= out_block_len);
                    self.ch_state[0].reset(sumpred,  sumstep);
                    self.ch_state[1].reset(diffpred, diffstep);
                    let mut last_nib = 0;
                    let mut diff_val: i32 = i32::from(diffpred);
                    for x in (0..out_block_len).step_by(2) {
                        let nib0;
                        let nib1;
                        let nib2;
                        if (x & 2) == 0 {
                            let b0              = br.read_byte()?;
                            let b1              = br.read_byte()?;
                            nib0 = b0 & 0xF;
                            nib1 = b0 >> 4;
                            nib2 = b1 & 0xF;
                            last_nib = b1 >> 4;
                        } else {
                            let b0              = br.read_byte()?;
                            nib0 = last_nib;
                            nib1 = b0 & 0xF;
                            nib2 = b0 >> 4;
                        }
                        let sum0 = i32::from(self.ch_state[0].expand_sample(nib0));
                        let diff = i32::from(self.ch_state[1].expand_sample(nib1));
                        let sum1 = i32::from(self.ch_state[0].expand_sample(nib2));
                        diff_val = (diff_val + diff) >> 1;
                        dst[off0 + x + 0] = (sum0 + diff_val) as i16;
                        dst[off1 + x + 0] = (sum0 - diff_val) as i16;
                        diff_val = (diff_val + diff) >> 1;
                        dst[off0 + x + 1] = (sum1 + diff_val) as i16;
                        dst[off1 + x + 1] = (sum1 - diff_val) as i16;
                        diff_val = diff;
                    }
                } else {
                    let nchannels = self.chmap.num_channels();
                    for ch in 0..nchannels {
                        let pred                = br.read_u16le()? as i16;
                        let step                = br.read_byte()?;
                                                  br.read_skip(1)?;
                        validate!(step <= IMA_MAX_STEP);
                        self.ch_state[ch].reset(pred, step);
                    }
                    if nchannels == 2 {
                        for x in 0..out_block_len {
                            let b               = br.read_byte()?;
                            dst[off0 + x] = self.ch_state[0].expand_sample(b >> 4);
                            dst[off1 + x] = self.ch_state[1].expand_sample(b & 0xF);
                        }
                    } else {
                        for x in (0..out_block_len).step_by(2) {
                            let b               = br.read_byte()?;
                            dst[off0 + x + 0] = self.ch_state[0].expand_sample(b >> 4);
                            dst[off0 + x + 1] = self.ch_state[0].expand_sample(b & 0xF);
                        }
                    }
                }
                off0 += out_block_len;
                off1 += out_block_len;
            }
            let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
            frm.set_duration(Some(duration as u64));
            frm.set_keyframe(false);
            Ok(frm.into_ref())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    fn flush(&mut self) {
    }
}

impl NAOptionHandler for DuckADPCMDecoder {
    fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
    fn set_options(&mut self, _options: &[NAOption]) { }
    fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
}

pub fn get_decoder_dk3() -> Box<dyn NADecoder + Send> {
    Box::new(DuckADPCMDecoder::new(true))
}

pub fn get_decoder_dk4() -> Box<dyn NADecoder + Send> {
    Box::new(DuckADPCMDecoder::new(false))
}

#[cfg(test)]
mod test {
    use nihav_core::codecs::RegisteredDecoders;
    use nihav_core::demuxers::RegisteredDemuxers;
    use nihav_codec_support::test::dec_video::*;
    use crate::duck_register_all_decoders;
    use nihav_commonfmt::generic_register_all_demuxers;
    #[test]
    fn test_dk3() {
        let mut dmx_reg = RegisteredDemuxers::new();
        generic_register_all_demuxers(&mut dmx_reg);
        let mut dec_reg = RegisteredDecoders::new();
        duck_register_all_decoders(&mut dec_reg);

        //let file = "assets/Duck/AVI-DUCK-dk3.duk";
        //test_decode_audio("avi", file, Some(100), None/*Some("dk3")*/, &dmx_reg, &dec_reg);
        // sample: https://samples.mplayerhq.hu/V-codecs/DUCK/AVI-DUCK-dk3.duk
        test_decoding("avi", "adpcm-dk3", "assets/Duck/AVI-DUCK-dk3.duk", None, &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5([0xa48fae0a, 0xa536b27f, 0x169ecc19, 0x8436fade]));
    }
    #[test]
    fn test_dk4() {
        let mut dmx_reg = RegisteredDemuxers::new();
        generic_register_all_demuxers(&mut dmx_reg);
        let mut dec_reg = RegisteredDecoders::new();
        duck_register_all_decoders(&mut dec_reg);

//        let file = "assets/Duck/virtuafighter2-opening1.avi";
//        test_decode_audio("avi", file, Some(100), None/*Some("dk4")*/, &dmx_reg, &dec_reg);
        // sample: https://samples.mplayerhq.hu/V-codecs/DUCK/virtuafighter2-opening1.avi
        test_decoding("avi", "adpcm-dk4", "assets/Duck/virtuafighter2-opening1.avi", None, &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5([0x04e40d15, 0xf65b3427, 0x1dd5181f, 0xf321b56f]));
    }
}
Commit	Line	Data
029d2552 KS	1	use nihav_core::codecs::*;
029d2552 KS	2	use nihav_core::io::byteio::*;
e781ccc3	3	use nihav_codec_support::codecs::imaadpcm::*;
029d2552 KS	4	use std::str::FromStr;
029d2552 KS	5
029d2552 KS	6	struct DuckADPCMDecoder {
	7	ainfo: NAAudioInfo,
	8	chmap: NAChannelMap,
	9	is_dk3: bool,
	10	ch_state: [IMAState; 2],
	11	block_len: usize,
	12	}
	13
	14	impl DuckADPCMDecoder {
	15	fn new(is_dk3: bool) -> Self {
	16	Self {
	17	ainfo: NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
	18	chmap: NAChannelMap::new(),
	19	is_dk3,
	20	ch_state: [IMAState::new(), IMAState::new()],
	21	block_len: 0,
	22	}
	23	}
	24	}
	25
	26	impl NADecoder for DuckADPCMDecoder {
01613464	27	fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
029d2552 KS	28	if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
	29	validate!(ainfo.get_block_len() > 16);
	30	self.block_len = ainfo.get_block_len();
	31	let channels = ainfo.get_channels();
	32	validate!(channels == 2 \|\| (!self.is_dk3 && channels == 1));
	33	let len = if self.is_dk3 {
	34	((self.block_len - 16) * 2 / 3) * 2
	35	} else {
	36	(self.block_len - 4 * (channels as usize)) * 2 / (channels as usize)
	37	};
	38	self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), channels, SND_S16P_FORMAT, len);
	39	self.chmap = NAChannelMap::from_str(if channels == 1 { "C" } else { "L,R" }).unwrap();
	40	Ok(())
	41	} else {
	42	Err(DecoderError::InvalidData)
	43	}
	44	}
20b5a55f	45	#[allow(clippy::identity_op)]
01613464	46	fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
029d2552 KS	47	let info = pkt.get_stream().get_info();
	48	if let NACodecTypeInfo::Audio(_) = info.get_properties() {
	49	let pktbuf = pkt.get_buffer();
	50	validate!(pktbuf.len() > (if self.is_dk3 { 16 } else { 4 * self.chmap.num_channels() }));
	51	let nblocks = pktbuf.len() / self.block_len;
	52	let out_block_len = self.ainfo.get_block_len();
	53	let duration = out_block_len * nblocks;
b70cc006	54	let abuf = alloc_audio_buffer(self.ainfo, duration, self.chmap.clone())?;
029d2552 KS	55	let mut adata = abuf.get_abuf_i16().unwrap();
	56	let mut off0 = adata.get_offset(0);
	57	let mut off1 = adata.get_offset(1);
1a967e6b	58	let dst = adata.get_data_mut().unwrap();
029d2552 KS	59
	60	for blk in pktbuf.chunks_exact(self.block_len) {
	61	let mut mr = MemoryReader::new_read(blk);
	62	let mut br = ByteReader::new(&mut mr);
	63	if self.is_dk3 {
	64	let _typeid = br.read_byte()?;
	65	let _version = br.read_byte()?;
	66	let _srate = br.read_u32le()?;
	67	let samples = br.read_u32le()? as usize;
	68	let sumpred = br.read_u16le()? as i16;
	69	let diffpred = br.read_u16le()? as i16;
	70	let sumstep = br.read_byte()?;
	71	let diffstep = br.read_byte()?;
	72	validate!(sumstep <= IMA_MAX_STEP && diffstep <= IMA_MAX_STEP);
	73	validate!(samples <= out_block_len);
	74	self.ch_state[0].reset(sumpred, sumstep);
	75	self.ch_state[1].reset(diffpred, diffstep);
	76	let mut last_nib = 0;
8a7352c0	77	let mut diff_val: i32 = i32::from(diffpred);
029d2552 KS	78	for x in (0..out_block_len).step_by(2) {
	79	let nib0;
	80	let nib1;
	81	let nib2;
	82	if (x & 2) == 0 {
	83	let b0 = br.read_byte()?;
	84	let b1 = br.read_byte()?;
	85	nib0 = b0 & 0xF;
	86	nib1 = b0 >> 4;
	87	nib2 = b1 & 0xF;
	88	last_nib = b1 >> 4;
	89	} else {
	90	let b0 = br.read_byte()?;
	91	nib0 = last_nib;
	92	nib1 = b0 & 0xF;
	93	nib2 = b0 >> 4;
	94	}
8a7352c0 KS	95	let sum0 = i32::from(self.ch_state[0].expand_sample(nib0));
	96	let diff = i32::from(self.ch_state[1].expand_sample(nib1));
	97	let sum1 = i32::from(self.ch_state[0].expand_sample(nib2));
029d2552 KS	98	diff_val = (diff_val + diff) >> 1;
	99	dst[off0 + x + 0] = (sum0 + diff_val) as i16;
	100	dst[off1 + x + 0] = (sum0 - diff_val) as i16;
	101	diff_val = (diff_val + diff) >> 1;
	102	dst[off0 + x + 1] = (sum1 + diff_val) as i16;
	103	dst[off1 + x + 1] = (sum1 - diff_val) as i16;
	104	diff_val = diff;
	105	}
	106	} else {
	107	let nchannels = self.chmap.num_channels();
	108	for ch in 0..nchannels {
	109	let pred = br.read_u16le()? as i16;
	110	let step = br.read_byte()?;
	111	br.read_skip(1)?;
	112	validate!(step <= IMA_MAX_STEP);
	113	self.ch_state[ch].reset(pred, step);
	114	}
	115	if nchannels == 2 {
	116	for x in 0..out_block_len {
	117	let b = br.read_byte()?;
	118	dst[off0 + x] = self.ch_state[0].expand_sample(b >> 4);
	119	dst[off1 + x] = self.ch_state[1].expand_sample(b & 0xF);
	120	}
	121	} else {
	122	for x in (0..out_block_len).step_by(2) {
	123	let b = br.read_byte()?;
	124	dst[off0 + x + 0] = self.ch_state[0].expand_sample(b >> 4);
	125	dst[off0 + x + 1] = self.ch_state[0].expand_sample(b & 0xF);
	126	}
	127	}
	128	}
	129	off0 += out_block_len;
	130	off1 += out_block_len;
	131	}
	132	let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
	133	frm.set_duration(Some(duration as u64));
	134	frm.set_keyframe(false);
171860fc	135	Ok(frm.into_ref())
029d2552 KS	136	} else {
	137	Err(DecoderError::InvalidData)
	138	}
	139	}
f9be4e75 KS	140	fn flush(&mut self) {
f9be4e75 KS	141	}
029d2552 KS	142	}
029d2552 KS	143
7d57ae2f KS	144	impl NAOptionHandler for DuckADPCMDecoder {
	145	fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
	146	fn set_options(&mut self, _options: &[NAOption]) { }
	147	fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
	148	}
	149
08a1fab7	150	pub fn get_decoder_dk3() -> Box<dyn NADecoder + Send> {
029d2552 KS	151	Box::new(DuckADPCMDecoder::new(true))
	152	}
	153
08a1fab7	154	pub fn get_decoder_dk4() -> Box<dyn NADecoder + Send> {
029d2552 KS	155	Box::new(DuckADPCMDecoder::new(false))
	156	}
	157
	158	#[cfg(test)]
	159	mod test {
	160	use nihav_core::codecs::RegisteredDecoders;
	161	use nihav_core::demuxers::RegisteredDemuxers;
ce742854	162	use nihav_codec_support::test::dec_video::*;
78fb6560	163	use crate::duck_register_all_decoders;
e64739f8	164	use nihav_commonfmt::generic_register_all_demuxers;
029d2552 KS	165	#[test]
	166	fn test_dk3() {
	167	let mut dmx_reg = RegisteredDemuxers::new();
	168	generic_register_all_demuxers(&mut dmx_reg);
	169	let mut dec_reg = RegisteredDecoders::new();
78fb6560	170	duck_register_all_decoders(&mut dec_reg);
029d2552	171
16b13997 KS	172	//let file = "assets/Duck/AVI-DUCK-dk3.duk";
16b13997 KS	173	//test_decode_audio("avi", file, Some(100), None/Some("dk3")/, &dmx_reg, &dec_reg);
886cde48	174	// sample: https://samples.mplayerhq.hu/V-codecs/DUCK/AVI-DUCK-dk3.duk
16b13997 KS	175	test_decoding("avi", "adpcm-dk3", "assets/Duck/AVI-DUCK-dk3.duk", None, &dmx_reg, &dec_reg,
16b13997 KS	176	ExpectedTestResult::MD5([0xa48fae0a, 0xa536b27f, 0x169ecc19, 0x8436fade]));
029d2552 KS	177	}
	178	#[test]
	179	fn test_dk4() {
	180	let mut dmx_reg = RegisteredDemuxers::new();
	181	generic_register_all_demuxers(&mut dmx_reg);
	182	let mut dec_reg = RegisteredDecoders::new();
78fb6560	183	duck_register_all_decoders(&mut dec_reg);
029d2552	184
16b13997 KS	185	// let file = "assets/Duck/virtuafighter2-opening1.avi";
16b13997 KS	186	// test_decode_audio("avi", file, Some(100), None/Some("dk4")/, &dmx_reg, &dec_reg);
886cde48	187	// sample: https://samples.mplayerhq.hu/V-codecs/DUCK/virtuafighter2-opening1.avi
16b13997 KS	188	test_decoding("avi", "adpcm-dk4", "assets/Duck/virtuafighter2-opening1.avi", None, &dmx_reg, &dec_reg,
16b13997 KS	189	ExpectedTestResult::MD5([0x04e40d15, 0xf65b3427, 0x1dd5181f, 0xf321b56f]));
029d2552 KS	190	}
029d2552 KS	191	}