[nihav.git] / nihav-game / src / codecs / smush / iact.rs

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

struct IACTDecoder {
    ainfo:      NAAudioInfo,
    chmap:      NAChannelMap,
    bits:       u8,
    tot_size:   u32,
    old:        bool,
    queued:     Vec<u8>,
}

impl IACTDecoder {
    fn new() -> Self {
        Self {
            ainfo:      NAAudioInfo::new(0, 1, SND_S16_FORMAT, 0),
            chmap:      NAChannelMap::new(),
            bits:       0,
            tot_size:   0,
            old:        false,
            queued:     Vec::new(),
        }
    }
}

impl NADecoder for IACTDecoder {
    fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
        if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
            self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), SND_S16_FORMAT, 1);
            self.chmap = NAChannelMap::from_str(if ainfo.get_channels() == 1 { "C" } else { "L,R" }).unwrap();
            self.bits  = ainfo.get_format().bits;
            Ok(())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    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 src = pkt.get_buffer();
            validate!(src.len() > 18);

            let code  = read_u16le(&src[0..])?;
            let flags = read_u16le(&src[2..])?;
            if code != 8 || flags != 0x2E {
                let mut frm = NAFrame::new_from_pkt(pkt, info, NABufferType::None);
                frm.set_duration(Some(0));
                frm.set_keyframe(true);
                return Ok(frm.into_ref());
            }
            let _left = read_u32le(&src[14..])?;
            let offset = if self.tot_size == 0 {
                    let mut mr = MemoryReader::new_read(&src[18..]);
                    let mut br = ByteReader::new(&mut mr);
                    let tag             = br.read_tag()?;
                    if &tag == b"iMUS" {
                        self.tot_size   = br.read_u32be()?;
                        validate!(self.tot_size != 0);
                        loop {
                            let tag     = br.read_tag()?;
                            let size    = br.read_u32be()?;
                            match &tag {
                                b"DATA" => {
                                    break;
                                },
                                _ =>      br.read_skip(size as usize)?,
                            };
                        }
                        br.tell() as usize
                    } else {
                        self.tot_size = 1;
                        self.old = true;
                        self.bits = 8;
                        0
                    }
                } else { 0 };

            let data = &src[offset + 18..];
            if self.old {
                self.queued.extend_from_slice(data);
            }
            let nsamples = (match self.bits {
                    _ if self.old => {
                        let mut mr = MemoryReader::new_read(&self.queued);
                        let mut br = ByteReader::new(&mut mr);
                        let mut nblocks = 0;
                        while br.left() > 0 {
                            let len     = br.read_u16be()? as usize;
                            if br.left() < (len as i64) {
                                break;
                            }
                            nblocks += 1;
                                          br.read_skip(len)?;
                        }
                        nblocks * 1024 * self.chmap.num_channels()
                    },
                     8 => data.len(),
                    12 => data.len() * 2 / 3,
                    16 => data.len() / 2,
                    _ => unimplemented!(),
                }) / self.chmap.num_channels();

            let abuf = alloc_audio_buffer(self.ainfo, nsamples, self.chmap.clone())?;
            let mut adata = abuf.get_abuf_i16().unwrap();
            let adata = adata.get_data_mut().unwrap();
            match self.bits {
                _ if self.old => {
                    let mut mr = MemoryReader::new_read(&self.queued);
                    let mut br = ByteReader::new(&mut mr);
                    for dst in adata.chunks_exact_mut(1024 * 2) {
                        let len         = br.read_u16be()? as usize;
                        let end = br.tell() + (len as u64);
                        let b           = br.read_byte()?;
                        let scale1 = b >> 4;
                        let scale2 = b & 0xF;
                        for pair in dst.chunks_exact_mut(2) {
                            if br.left() < 2 {
                                break;
                            }
                            let b       = br.read_byte()? as i8;
                            if b != -0x80 {
                                pair[0] = i16::from(b) << scale1;
                            } else {
                                pair[0] = br.read_u16be()? as i16;
                            }
                            let b       = br.read_byte()? as i8;
                            if b != -0x80 {
                                pair[1] = i16::from(b) << scale2;
                            } else {
                                pair[1] = br.read_u16be()? as i16;
                            }
                        }
                        validate!(br.tell() <= end);
                                          br.seek(SeekFrom::Start(end))?;
                    }
                    let consumed = br.tell() as usize;
                    self.queued.drain(..consumed);
                },
                8 => {
                    for (dst, &src) in adata.iter_mut().zip(data.iter()) {
                        *dst = (u16::from(src) << 8) as i16;
                    }
                },
                12 => {
                    for (dst, src) in adata.chunks_exact_mut(2).zip(data.chunks_exact(3)) {
                        dst[0] = (((u16::from(src[1] << 4) << 8) | (u16::from(src[0]) << 4)) ^ 0x8000) as i16;
                        dst[1] = (((u16::from(src[1] & 0xF0) << 8) | (u16::from(src[2]) << 4)) ^ 0x8000) as i16;
                    }
                },
                16 => {
                    for (dst, src) in adata.iter_mut().zip(data.chunks_exact(2)) {
                        *dst = read_u16le(src)? as i16;
                    }
                },
                _ => unreachable!(),
            }

            let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
            frm.set_duration(Some(nsamples as u64));
            frm.set_keyframe(true);
            Ok(frm.into_ref())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    fn flush(&mut self) {
    }
}

impl NAOptionHandler for IACTDecoder {
    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_iact() -> Box<dyn NADecoder + Send> {
    Box::new(IACTDecoder::new())
}

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

        // sample from The Dig
        test_decoding("smush", "smush-iact", "assets/Game/smush/PIGOUT.SAN", None, &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5([0x7d731a75, 0x9869cb8f, 0xded5b893, 0xb507b17a]));
    }
    #[test]
    fn test_smush_iact_raw() {
        let mut dmx_reg = RegisteredDemuxers::new();
        game_register_all_demuxers(&mut dmx_reg);
        let mut dec_reg = RegisteredDecoders::new();
        game_register_all_decoders(&mut dec_reg);

        // sample from Curse of Monkey Island
        test_decoding("smush", "smush-iact", "assets/Game/smush/ZAP010.SAN", None, &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5([0xecf88bc6, 0x5c89ce94, 0x8e40a22a, 0xfc4ba86c]));
    }
}
Commit	Line	Data
c17769db KS	1	use nihav_core::codecs::*;
	2	use nihav_core::io::byteio::*;
	3	use std::str::FromStr;
	4
	5	struct IACTDecoder {
	6	ainfo: NAAudioInfo,
	7	chmap: NAChannelMap,
	8	bits: u8,
	9	tot_size: u32,
	10	old: bool,
	11	queued: Vec<u8>,
	12	}
	13
	14	impl IACTDecoder {
	15	fn new() -> Self {
	16	Self {
	17	ainfo: NAAudioInfo::new(0, 1, SND_S16_FORMAT, 0),
	18	chmap: NAChannelMap::new(),
	19	bits: 0,
	20	tot_size: 0,
	21	old: false,
	22	queued: Vec::new(),
	23	}
	24	}
	25	}
	26
	27	impl NADecoder for IACTDecoder {
	28	fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
	29	if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
	30	self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), SND_S16_FORMAT, 1);
	31	self.chmap = NAChannelMap::from_str(if ainfo.get_channels() == 1 { "C" } else { "L,R" }).unwrap();
	32	self.bits = ainfo.get_format().bits;
	33	Ok(())
	34	} else {
	35	Err(DecoderError::InvalidData)
	36	}
	37	}
	38	fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
	39	let info = pkt.get_stream().get_info();
	40	if let NACodecTypeInfo::Audio(_) = info.get_properties() {
	41	let src = pkt.get_buffer();
	42	validate!(src.len() > 18);
	43
	44	let code = read_u16le(&src[0..])?;
	45	let flags = read_u16le(&src[2..])?;
	46	if code != 8 \|\| flags != 0x2E {
	47	let mut frm = NAFrame::new_from_pkt(pkt, info, NABufferType::None);
	48	frm.set_duration(Some(0));
	49	frm.set_keyframe(true);
	50	return Ok(frm.into_ref());
	51	}
	52	let _left = read_u32le(&src[14..])?;
	53	let offset = if self.tot_size == 0 {
	54	let mut mr = MemoryReader::new_read(&src[18..]);
	55	let mut br = ByteReader::new(&mut mr);
	56	let tag = br.read_tag()?;
	57	if &tag == b"iMUS" {
	58	self.tot_size = br.read_u32be()?;
	59	validate!(self.tot_size != 0);
	60	loop {
	61	let tag = br.read_tag()?;
	62	let size = br.read_u32be()?;
	63	match &tag {
	64	b"DATA" => {
65	break;
66	},
67	_ => br.read_skip(size as usize)?,
68	};
69	}
70	br.tell() as usize
71	} else {
72	self.tot_size = 1;
73	self.old = true;
74	self.bits = 8;
75	0
76	}
77	} else { 0 };
78
79	let data = &src[offset + 18..];
80	if self.old {
81	self.queued.extend_from_slice(data);
82	}
83	let nsamples = (match self.bits {
84	_ if self.old => {
85	let mut mr = MemoryReader::new_read(&self.queued);
86	let mut br = ByteReader::new(&mut mr);
87	let mut nblocks = 0;
88	while br.left() > 0 {
89	let len = br.read_u16be()? as usize;
90	if br.left() < (len as i64) {
91	break;
92	}
93	nblocks += 1;
94	br.read_skip(len)?;
95	}
96	nblocks * 1024 * self.chmap.num_channels()
97	},
98	8 => data.len(),
99	12 => data.len() * 2 / 3,
100	16 => data.len() / 2,
101	_ => unimplemented!(),
102	}) / self.chmap.num_channels();
103
104	let abuf = alloc_audio_buffer(self.ainfo, nsamples, self.chmap.clone())?;
105	let mut adata = abuf.get_abuf_i16().unwrap();
106	let adata = adata.get_data_mut().unwrap();
107	match self.bits {
108	_ if self.old => {
109	let mut mr = MemoryReader::new_read(&self.queued);
110	let mut br = ByteReader::new(&mut mr);
111	for dst in adata.chunks_exact_mut(1024 * 2) {
112	let len = br.read_u16be()? as usize;
113	let end = br.tell() + (len as u64);
114	let b = br.read_byte()?;
115	let scale1 = b >> 4;
116	let scale2 = b & 0xF;
117	for pair in dst.chunks_exact_mut(2) {
118	if br.left() < 2 {
119	break;
120	}
121	let b = br.read_byte()? as i8;
122	if b != -0x80 {
123	pair[0] = i16::from(b) << scale1;
124	} else {
125	pair[0] = br.read_u16be()? as i16;
126	}
127	let b = br.read_byte()? as i8;
128	if b != -0x80 {
129	pair[1] = i16::from(b) << scale2;
130	} else {
131	pair[1] = br.read_u16be()? as i16;
132	}
133	}
134	validate!(br.tell() <= end);
135	br.seek(SeekFrom::Start(end))?;
136	}
137	let consumed = br.tell() as usize;
138	self.queued.drain(..consumed);
139	},
140	8 => {
141	for (dst, &src) in adata.iter_mut().zip(data.iter()) {
142	*dst = (u16::from(src) << 8) as i16;
143	}
144	},
145	12 => {
146	for (dst, src) in adata.chunks_exact_mut(2).zip(data.chunks_exact(3)) {
147	dst[0] = (((u16::from(src[1] << 4) << 8) \| (u16::from(src[0]) << 4)) ^ 0x8000) as i16;
148	dst[1] = (((u16::from(src[1] & 0xF0) << 8) \| (u16::from(src[2]) << 4)) ^ 0x8000) as i16;
149	}
150	},
151	16 => {
152	for (dst, src) in adata.iter_mut().zip(data.chunks_exact(2)) {
153	*dst = read_u16le(src)? as i16;
154	}
155	},
156	_ => unreachable!(),
157	}
158
159	let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
160	frm.set_duration(Some(nsamples as u64));
161	frm.set_keyframe(true);
162	Ok(frm.into_ref())
163	} else {
164	Err(DecoderError::InvalidData)
165	}
166	}
167	fn flush(&mut self) {
168	}
169	}
170
171	impl NAOptionHandler for IACTDecoder {
172	fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
173	fn set_options(&mut self, _options: &[NAOption]) { }
174	fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
175	}
176
177	pub fn get_decoder_iact() -> Box<dyn NADecoder + Send> {
178	Box::new(IACTDecoder::new())
179	}
180
181	#[cfg(test)]
182	mod test {
183	use nihav_core::codecs::RegisteredDecoders;
184	use nihav_core::demuxers::RegisteredDemuxers;
185	use nihav_codec_support::test::dec_video::*;
186	use crate::game_register_all_decoders;
187	use crate::game_register_all_demuxers;
188	#[test]
189	fn test_smush_iact_imuse() {
190	let mut dmx_reg = RegisteredDemuxers::new();
191	game_register_all_demuxers(&mut dmx_reg);
192	let mut dec_reg = RegisteredDecoders::new();
193	game_register_all_decoders(&mut dec_reg);
194
195	// sample from The Dig
196	test_decoding("smush", "smush-iact", "assets/Game/smush/PIGOUT.SAN", None, &dmx_reg, &dec_reg,
197	ExpectedTestResult::MD5([0x7d731a75, 0x9869cb8f, 0xded5b893, 0xb507b17a]));
198	}
199	#[test]
200	fn test_smush_iact_raw() {
201	let mut dmx_reg = RegisteredDemuxers::new();
202	game_register_all_demuxers(&mut dmx_reg);
203	let mut dec_reg = RegisteredDecoders::new();
204	game_register_all_decoders(&mut dec_reg);
205
206	// sample from Curse of Monkey Island
207	test_decoding("smush", "smush-iact", "assets/Game/smush/ZAP010.SAN", None, &dmx_reg, &dec_reg,
208	ExpectedTestResult::MD5([0xecf88bc6, 0x5c89ce94, 0x8e40a22a, 0xfc4ba86c]));
209	}
210	}
211