[nihav.git] / nihav-game / src / codecs / bmv.rs

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

const FRAME_W: usize = 640;
const FRAME_H: usize = 429;

const BMV_INTRA:    u8 = 0x03;
const BMV_SCROLL:   u8 = 0x04;
const BMV_PAL:      u8 = 0x08;
const BMV_COMMAND:  u8 = 0x10;
const BMV_PRINT:    u8 = 0x80;

struct BMVReader<'a> {
    src:        &'a [u8],
    pos:        usize,
    fwd:        bool,
    nibble:     u8,
    saved:      bool,
}

impl<'a> BMVReader<'a> {
    fn new(src: &'a [u8], fwd: bool) -> Self {
        let pos = if fwd { 0 } else { src.len() - 1 };
        Self { src, pos, fwd, nibble: 0, saved: false }
    }
    #[allow(clippy::collapsible_else_if)]
    fn advance(&mut self) {
        if self.fwd {
            if self.pos < self.src.len() - 1 { self.pos += 1; }
        } else {
            if self.pos > 0 { self.pos -= 1; }
        }
    }
    fn get_byte(&mut self) -> u8 {
        let ret = self.src[self.pos];
        self.advance();
        ret
    }
    fn get_nibble(&mut self) -> u8 {
        if self.saved {
            self.saved = false;
            self.nibble
        } else {
            let val = self.get_byte();
            self.saved = true;
            self.nibble = val >> 4;
            val & 0xF
        }
    }
}

struct BMVWriter<'a> {
    data:       &'a mut [u8],
    pos:        usize,
    fwd:        bool,
    off:        isize,
}

impl<'a> BMVWriter<'a> {
    fn new(data: &'a mut [u8], fwd: bool, off: isize) -> Self {
        let pos = if fwd { 0 } else { data.len() - 1 };
        Self { data, pos, fwd, off }
    }
    fn is_at_end(&self) -> bool {
        if self.fwd {
            self.pos == self.data.len() - 1
        } else {
            self.pos == 0
        }
    }
    #[allow(clippy::collapsible_else_if)]
    fn advance(&mut self) {
        if self.fwd {
            if self.pos < self.data.len() - 1 { self.pos += 1; }
        } else {
            if self.pos > 0 { self.pos -= 1; }
        }
    }
    fn put_byte(&mut self, val: u8) {
        self.data[self.pos] = val;
        self.advance();
    }
    fn copy(&mut self, len: usize) {
        for _ in 0..len {
            let saddr = (self.pos as isize) + self.off;
            if saddr < 0 { continue; }
            self.data[self.pos] = self.data[saddr as usize];
            self.advance();
        }
    }
    fn repeat(&mut self, len: usize) {
        let last = if self.fwd { self.data[self.pos - 1] } else { self.data[self.pos + 1] };
        for _ in 0..len {
            self.put_byte(last);
        }
    }
}

struct BMVVideoDecoder {
    info:       NACodecInfoRef,
    pal:        [u8; 768],
    frame:      [u8; FRAME_W * FRAME_H],
}

impl BMVVideoDecoder {
    fn new() -> Self {
        Self {
            info: NACodecInfoRef::default(), pal: [0; 768], frame: [0; FRAME_W * FRAME_H],
        }
    }
    fn decode_frame(&mut self, src: &[u8], bufinfo: &mut NABufferType, line: i16) -> DecoderResult<()> {
        let bufo = bufinfo.get_vbuf();
        let mut buf = bufo.unwrap();
        let paloff = buf.get_offset(1);
        let stride = buf.get_stride(0);
        let data = buf.get_data_mut().unwrap();
        let dst = data.as_mut_slice();

        let fwd = (line <= -640) || (line >= 0);

        let mut br = BMVReader::new(src, fwd);
        let mut bw = BMVWriter::new(&mut self.frame, fwd, line as isize);
        let mut mode = 0;
        while !bw.is_at_end() {
            let mut val = 0;
            let mut shift = 0;
            loop {
                let nib = br.get_nibble() as usize;
                if (nib & 0xC) != 0 {
                    val |= nib << shift;
                    break;
                }
                val |= nib << shift;
                shift += 2;
            }
            if (val & 1) != 0 {
                mode += 1;
            }
            mode += 1;
            if mode >= 4 {
                mode -= 3;
            }
            validate!(val >= 2);
            let len = (val >> 1) - 1;

            match mode {
                1 => bw.copy(len),
                2 => for _ in 0..len { bw.put_byte(br.get_byte()); },
                3 => bw.repeat(len),
                _ => unreachable!(),
            };
        }

        for y in 0..FRAME_H {
            for x in 0..FRAME_W {
                dst[y * stride + x] = self.frame[y * FRAME_W + x];
            }
        }

        let dpal = &mut dst[paloff..][..768];
        dpal.copy_from_slice(&self.pal[0..]);

        Ok(())
    }
}

impl NADecoder for BMVVideoDecoder {
    fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
        if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
            let fmt = NAPixelFormaton::new(ColorModel::RGB(RGBSubmodel::RGB),
                                           Some(NAPixelChromaton::new(0, 0, true, 8, 0, 0, 3)),
                                           Some(NAPixelChromaton::new(0, 0, true, 8, 0, 1, 3)),
                                           Some(NAPixelChromaton::new(0, 0, true, 8, 0, 2, 3)),
                                           None, None,
                                           FORMATON_FLAG_PALETTE, 3);
            let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(FRAME_W, FRAME_H, false, fmt));
            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

            Ok(())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
        let src = pkt.get_buffer();
        validate!(src.len() > 1);

        let mut mr = MemoryReader::new_read(&src);
        let mut br = ByteReader::new(&mut mr);
        let flags                               = br.read_byte()?;

        if (flags & BMV_COMMAND) != 0 {
            let size = if (flags & BMV_PRINT) != 0 { 8 } else { 10 };
            br.read_skip(size)?;
        }
        if (flags & BMV_PAL) != 0 {
            br.read_buf(&mut self.pal)?;
        }
        let line;
        if (flags & BMV_SCROLL) != 0 {
            line                                = br.read_u16le()? as i16;
        } else if (flags & BMV_INTRA) == BMV_INTRA {
            line = -640;
        } else {
            line = 0;
        }
        let pos = br.tell() as usize;

        let mut bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;

        self.decode_frame(&src[pos..], &mut bufinfo, line)?;

        let is_intra = (flags & BMV_INTRA) == BMV_INTRA;
        let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
        frm.set_keyframe(is_intra);
        frm.set_frame_type(if is_intra { FrameType::I } else { FrameType::P });
        Ok(frm.into_ref())
    }
    fn flush(&mut self) {
    }
}

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

struct BMVAudioDecoder {
    ainfo:      NAAudioInfo,
    chmap:      NAChannelMap,
}

const BMV_AUD_SCALES: [i32; 16] = [ 16512, 8256, 4128, 2064, 1032, 516, 258, 192, 129, 88, 64, 56, 48, 40, 36, 32 ];

impl BMVAudioDecoder {
    fn new() -> Self {
        Self {
            ainfo:  NAAudioInfo::new(0, 1, formats::SND_S16P_FORMAT, 0),
            chmap:  NAChannelMap::new(),
        }
    }
}

fn scale_sample(samp: u8, scale: i32) -> i16 {
    let val = (i32::from(samp as i8) * scale) >> 5;
    if val < -32768 {
        -32768
    } else if val > 32767 {
        32767
    } else {
        val as i16
    }
}

impl NADecoder for BMVAudioDecoder {
    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(), formats::SND_S16P_FORMAT, 32);
            self.chmap = NAChannelMap::from_str("L,R").unwrap();
            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 pktbuf = pkt.get_buffer();
            validate!(pktbuf.len() > 1);
            let nblocks = pktbuf[0] as usize;
            validate!(pktbuf.len() == 1 + 65 * nblocks);
            let samples = nblocks * 32;
            let abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
            let mut adata = abuf.get_abuf_i16().unwrap();
            let off1 = adata.get_offset(1);
            let dst = adata.get_data_mut().unwrap();
            let psrc = &pktbuf[1..];
            for (n, src) in psrc.chunks_exact(65).enumerate() {
                let code = src[0].rotate_right(1);
                let scale0 = BMV_AUD_SCALES[(code & 0xF) as usize];
                let scale1 = BMV_AUD_SCALES[(code >>  4) as usize];
                let aoff0 = n * 32;
                let aoff1 = aoff0 + off1;
                let data = &src[1..];
                for (i, samp) in data.chunks_exact(2).enumerate() {
                    dst[aoff0 + i] = scale_sample(samp[0], scale0);
                    dst[aoff1 + i] = scale_sample(samp[1], scale1);
                }
            }
            let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
            frm.set_duration(Some(samples as u64));
            frm.set_keyframe(false);
            Ok(frm.into_ref())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    fn flush(&mut self) {
    }
}

impl NAOptionHandler for BMVAudioDecoder {
    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_audio() -> Box<dyn NADecoder + Send> {
    Box::new(BMVAudioDecoder::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;
    // samples from: https://samples.mplayerhq.hu/game-formats/bmv/
    #[test]
    fn test_bmv_video() {
        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);

        test_decoding("bmv", "bmv-video", "assets/Game/WILDCAT.BMV", Some(40), &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5([0x9e91bb16, 0xc1edafc9, 0x4ef3171f, 0x0f3f6181]));
    }
    #[test]
    fn test_bmv_audio() {
        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);

        test_decoding("bmv", "bmv-audio", "assets/Game/PERFECT.BMV", None, &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5([0x90b9ace4, 0x5fc19938, 0x7f534560, 0x32589cdf]));
    }
}
Commit	Line	Data
9067c1f8 KS	1	use nihav_core::formats;
	2	use nihav_core::codecs::*;
	3	use nihav_core::io::byteio::*;
	4	use std::str::FromStr;
	5
	6	const FRAME_W: usize = 640;
	7	const FRAME_H: usize = 429;
	8
	9	const BMV_INTRA: u8 = 0x03;
	10	const BMV_SCROLL: u8 = 0x04;
	11	const BMV_PAL: u8 = 0x08;
	12	const BMV_COMMAND: u8 = 0x10;
	13	const BMV_PRINT: u8 = 0x80;
	14
	15	struct BMVReader<'a> {
	16	src: &'a [u8],
	17	pos: usize,
	18	fwd: bool,
	19	nibble: u8,
	20	saved: bool,
	21	}
	22
	23	impl<'a> BMVReader<'a> {
	24	fn new(src: &'a [u8], fwd: bool) -> Self {
	25	let pos = if fwd { 0 } else { src.len() - 1 };
	26	Self { src, pos, fwd, nibble: 0, saved: false }
	27	}
cb56d166	28	#[allow(clippy::collapsible_else_if)]
9067c1f8 KS	29	fn advance(&mut self) {
	30	if self.fwd {
	31	if self.pos < self.src.len() - 1 { self.pos += 1; }
	32	} else {
	33	if self.pos > 0 { self.pos -= 1; }
	34	}
	35	}
	36	fn get_byte(&mut self) -> u8 {
	37	let ret = self.src[self.pos];
	38	self.advance();
	39	ret
	40	}
	41	fn get_nibble(&mut self) -> u8 {
	42	if self.saved {
	43	self.saved = false;
	44	self.nibble
	45	} else {
	46	let val = self.get_byte();
	47	self.saved = true;
	48	self.nibble = val >> 4;
	49	val & 0xF
	50	}
	51	}
	52	}
	53
	54	struct BMVWriter<'a> {
	55	data: &'a mut [u8],
	56	pos: usize,
	57	fwd: bool,
	58	off: isize,
	59	}
	60
	61	impl<'a> BMVWriter<'a> {
	62	fn new(data: &'a mut [u8], fwd: bool, off: isize) -> Self {
	63	let pos = if fwd { 0 } else { data.len() - 1 };
	64	Self { data, pos, fwd, off }
	65	}
	66	fn is_at_end(&self) -> bool {
	67	if self.fwd {
	68	self.pos == self.data.len() - 1
	69	} else {
	70	self.pos == 0
	71	}
	72	}
cb56d166	73	#[allow(clippy::collapsible_else_if)]
9067c1f8 KS	74	fn advance(&mut self) {
	75	if self.fwd {
	76	if self.pos < self.data.len() - 1 { self.pos += 1; }
	77	} else {
	78	if self.pos > 0 { self.pos -= 1; }
	79	}
	80	}
	81	fn put_byte(&mut self, val: u8) {
	82	self.data[self.pos] = val;
	83	self.advance();
	84	}
	85	fn copy(&mut self, len: usize) {
	86	for _ in 0..len {
	87	let saddr = (self.pos as isize) + self.off;
	88	if saddr < 0 { continue; }
da736dbd	89	self.data[self.pos] = self.data[saddr as usize];
9067c1f8 KS	90	self.advance();
	91	}
	92	}
	93	fn repeat(&mut self, len: usize) {
	94	let last = if self.fwd { self.data[self.pos - 1] } else { self.data[self.pos + 1] };
	95	for _ in 0..len {
	96	self.put_byte(last);
	97	}
	98	}
	99	}
	100
	101	struct BMVVideoDecoder {
2422d969	102	info: NACodecInfoRef,
9067c1f8 KS	103	pal: [u8; 768],
	104	frame: [u8; FRAME_W * FRAME_H],
	105	}
	106
	107	impl BMVVideoDecoder {
	108	fn new() -> Self {
9067c1f8	109	Self {
2422d969	110	info: NACodecInfoRef::default(), pal: [0; 768], frame: [0; FRAME_W * FRAME_H],
9067c1f8 KS	111	}
	112	}
	113	fn decode_frame(&mut self, src: &[u8], bufinfo: &mut NABufferType, line: i16) -> DecoderResult<()> {
	114	let bufo = bufinfo.get_vbuf();
	115	let mut buf = bufo.unwrap();
	116	let paloff = buf.get_offset(1);
	117	let stride = buf.get_stride(0);
1a967e6b	118	let data = buf.get_data_mut().unwrap();
9067c1f8 KS	119	let dst = data.as_mut_slice();
	120
	121	let fwd = (line <= -640) \|\| (line >= 0);
	122
	123	let mut br = BMVReader::new(src, fwd);
	124	let mut bw = BMVWriter::new(&mut self.frame, fwd, line as isize);
	125	let mut mode = 0;
	126	while !bw.is_at_end() {
	127	let mut val = 0;
	128	let mut shift = 0;
	129	loop {
	130	let nib = br.get_nibble() as usize;
	131	if (nib & 0xC) != 0 {
	132	val \|= nib << shift;
	133	break;
	134	}
	135	val \|= nib << shift;
	136	shift += 2;
	137	}
	138	if (val & 1) != 0 {
	139	mode += 1;
	140	}
	141	mode += 1;
	142	if mode >= 4 {
	143	mode -= 3;
	144	}
	145	validate!(val >= 2);
	146	let len = (val >> 1) - 1;
d24468d9	147
9067c1f8 KS	148	match mode {
	149	1 => bw.copy(len),
	150	2 => for _ in 0..len { bw.put_byte(br.get_byte()); },
	151	3 => bw.repeat(len),
	152	_ => unreachable!(),
	153	};
	154	}
	155
	156	for y in 0..FRAME_H {
	157	for x in 0..FRAME_W {
	158	dst[y * stride + x] = self.frame[y * FRAME_W + x];
	159	}
	160	}
	161
	162	let dpal = &mut dst[paloff..][..768];
	163	dpal.copy_from_slice(&self.pal[0..]);
	164
	165	Ok(())
	166	}
	167	}
	168
	169	impl NADecoder for BMVVideoDecoder {
01613464	170	fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
9067c1f8 KS	171	if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
	172	let fmt = NAPixelFormaton::new(ColorModel::RGB(RGBSubmodel::RGB),
	173	Some(NAPixelChromaton::new(0, 0, true, 8, 0, 0, 3)),
	174	Some(NAPixelChromaton::new(0, 0, true, 8, 0, 1, 3)),
	175	Some(NAPixelChromaton::new(0, 0, true, 8, 0, 2, 3)),
	176	None, None,
	177	FORMATON_FLAG_PALETTE, 3);
	178	let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(FRAME_W, FRAME_H, false, fmt));
2422d969	179	self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
9067c1f8 KS	180
	181	Ok(())
	182	} else {
	183	Err(DecoderError::InvalidData)
	184	}
	185	}
01613464	186	fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
9067c1f8 KS	187	let src = pkt.get_buffer();
	188	validate!(src.len() > 1);
	189
	190	let mut mr = MemoryReader::new_read(&src);
	191	let mut br = ByteReader::new(&mut mr);
	192	let flags = br.read_byte()?;
	193
	194	if (flags & BMV_COMMAND) != 0 {
	195	let size = if (flags & BMV_PRINT) != 0 { 8 } else { 10 };
	196	br.read_skip(size)?;
	197	}
	198	if (flags & BMV_PAL) != 0 {
	199	br.read_buf(&mut self.pal)?;
	200	}
	201	let line;
	202	if (flags & BMV_SCROLL) != 0 {
	203	line = br.read_u16le()? as i16;
	204	} else if (flags & BMV_INTRA) == BMV_INTRA {
	205	line = -640;
	206	} else {
	207	line = 0;
	208	}
	209	let pos = br.tell() as usize;
	210
e69b1148	211	let mut bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
9067c1f8 KS	212
	213	self.decode_frame(&src[pos..], &mut bufinfo, line)?;
	214
	215	let is_intra = (flags & BMV_INTRA) == BMV_INTRA;
	216	let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
	217	frm.set_keyframe(is_intra);
	218	frm.set_frame_type(if is_intra { FrameType::I } else { FrameType::P });
171860fc	219	Ok(frm.into_ref())
9067c1f8	220	}
f9be4e75 KS	221	fn flush(&mut self) {
f9be4e75 KS	222	}
9067c1f8 KS	223	}
9067c1f8 KS	224
7d57ae2f KS	225	impl NAOptionHandler for BMVVideoDecoder {
	226	fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
	227	fn set_options(&mut self, _options: &[NAOption]) { }
	228	fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
	229	}
	230
9067c1f8	231
08a1fab7	232	pub fn get_decoder_video() -> Box<dyn NADecoder + Send> {
9067c1f8 KS	233	Box::new(BMVVideoDecoder::new())
	234	}
	235
	236	struct BMVAudioDecoder {
	237	ainfo: NAAudioInfo,
	238	chmap: NAChannelMap,
	239	}
	240
	241	const BMV_AUD_SCALES: [i32; 16] = [ 16512, 8256, 4128, 2064, 1032, 516, 258, 192, 129, 88, 64, 56, 48, 40, 36, 32 ];
	242
	243	impl BMVAudioDecoder {
	244	fn new() -> Self {
	245	Self {
	246	ainfo: NAAudioInfo::new(0, 1, formats::SND_S16P_FORMAT, 0),
	247	chmap: NAChannelMap::new(),
	248	}
	249	}
	250	}
	251
	252	fn scale_sample(samp: u8, scale: i32) -> i16 {
e69b1148	253	let val = (i32::from(samp as i8) * scale) >> 5;
9067c1f8 KS	254	if val < -32768 {
	255	-32768
	256	} else if val > 32767 {
	257	32767
	258	} else {
	259	val as i16
	260	}
	261	}
	262
	263	impl NADecoder for BMVAudioDecoder {
01613464	264	fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
9067c1f8 KS	265	if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
	266	self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), formats::SND_S16P_FORMAT, 32);
	267	self.chmap = NAChannelMap::from_str("L,R").unwrap();
	268	Ok(())
	269	} else {
	270	Err(DecoderError::InvalidData)
	271	}
	272	}
01613464	273	fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
9067c1f8 KS	274	let info = pkt.get_stream().get_info();
	275	if let NACodecTypeInfo::Audio(_) = info.get_properties() {
	276	let pktbuf = pkt.get_buffer();
	277	validate!(pktbuf.len() > 1);
	278	let nblocks = pktbuf[0] as usize;
	279	validate!(pktbuf.len() == 1 + 65 * nblocks);
	280	let samples = nblocks * 32;
b70cc006	281	let abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
9067c1f8 KS	282	let mut adata = abuf.get_abuf_i16().unwrap();
9067c1f8 KS	283	let off1 = adata.get_offset(1);
1a967e6b	284	let dst = adata.get_data_mut().unwrap();
9067c1f8 KS	285	let psrc = &pktbuf[1..];
	286	for (n, src) in psrc.chunks_exact(65).enumerate() {
	287	let code = src[0].rotate_right(1);
	288	let scale0 = BMV_AUD_SCALES[(code & 0xF) as usize];
	289	let scale1 = BMV_AUD_SCALES[(code >> 4) as usize];
	290	let aoff0 = n * 32;
	291	let aoff1 = aoff0 + off1;
	292	let data = &src[1..];
	293	for (i, samp) in data.chunks_exact(2).enumerate() {
	294	dst[aoff0 + i] = scale_sample(samp[0], scale0);
	295	dst[aoff1 + i] = scale_sample(samp[1], scale1);
	296	}
	297	}
	298	let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
	299	frm.set_duration(Some(samples as u64));
	300	frm.set_keyframe(false);
171860fc	301	Ok(frm.into_ref())
9067c1f8 KS	302	} else {
	303	Err(DecoderError::InvalidData)
	304	}
	305	}
f9be4e75 KS	306	fn flush(&mut self) {
f9be4e75 KS	307	}
9067c1f8 KS	308	}
9067c1f8 KS	309
7d57ae2f KS	310	impl NAOptionHandler for BMVAudioDecoder {
	311	fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
	312	fn set_options(&mut self, _options: &[NAOption]) { }
	313	fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
	314	}
	315
08a1fab7	316	pub fn get_decoder_audio() -> Box<dyn NADecoder + Send> {
9067c1f8 KS	317	Box::new(BMVAudioDecoder::new())
	318	}
	319
	320	#[cfg(test)]
	321	mod test {
	322	use nihav_core::codecs::RegisteredDecoders;
	323	use nihav_core::demuxers::RegisteredDemuxers;
ce742854	324	use nihav_codec_support::test::dec_video::*;
78fb6560	325	use crate::game_register_all_decoders;
e64739f8	326	use crate::game_register_all_demuxers;
886cde48	327	// samples from: https://samples.mplayerhq.hu/game-formats/bmv/
9067c1f8 KS	328	#[test]
	329	fn test_bmv_video() {
	330	let mut dmx_reg = RegisteredDemuxers::new();
	331	game_register_all_demuxers(&mut dmx_reg);
	332	let mut dec_reg = RegisteredDecoders::new();
78fb6560	333	game_register_all_decoders(&mut dec_reg);
9067c1f8	334
951d4be7 KS	335	test_decoding("bmv", "bmv-video", "assets/Game/WILDCAT.BMV", Some(40), &dmx_reg, &dec_reg,
951d4be7 KS	336	ExpectedTestResult::MD5([0x9e91bb16, 0xc1edafc9, 0x4ef3171f, 0x0f3f6181]));
9067c1f8 KS	337	}
	338	#[test]
	339	fn test_bmv_audio() {
	340	let mut dmx_reg = RegisteredDemuxers::new();
	341	game_register_all_demuxers(&mut dmx_reg);
	342	let mut dec_reg = RegisteredDecoders::new();
78fb6560	343	game_register_all_decoders(&mut dec_reg);
9067c1f8	344
951d4be7 KS	345	test_decoding("bmv", "bmv-audio", "assets/Game/PERFECT.BMV", None, &dmx_reg, &dec_reg,
951d4be7 KS	346	ExpectedTestResult::MD5([0x90b9ace4, 0x5fc19938, 0x7f534560, 0x32589cdf]));
9067c1f8 KS	347	}
9067c1f8 KS	348	}