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

use nihav_core::codecs::*;
use nihav_core::io::byteio::*;

const WIDTH:  usize = 320;
const HEIGHT: usize = 200;
const FRAME_HEADER: usize = 24;

struct SequenceDecoder {
    info:       NACodecInfoRef,
    pal:        [u8; 768],
    frame:      [u8; WIDTH * HEIGHT],
}

impl SequenceDecoder {
    fn new() -> Self {
        Self {
            info:       NACodecInfoRef::default(),
            pal:        [0; 768],
            frame:      [0; WIDTH * HEIGHT],
        }
    }
}

impl NADecoder for SequenceDecoder {
    fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
        if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
            if let Some(ref edata) = info.get_extradata() {
                validate!(edata.len() > 32);
                let pal_start = read_u16le(&edata[25..])? as usize;
                let pal_len   = read_u16le(&edata[29..])? as usize;
                validate!(pal_len > 0 && pal_start + pal_len <= 256);
                match edata[32] {
                    0 => {
                        let dpal = self.pal[pal_start * 3..].chunks_exact_mut(3);
                        for (dst, quad) in dpal.zip(edata[37..].chunks_exact(4)) {
                            dst.copy_from_slice(&quad[1..]);
                        }
                    },
                    1 => self.pal[pal_start * 3..][..pal_len * 3].copy_from_slice(&edata[37..][..pal_len * 3]),
                    _ => return Err(DecoderError::NotImplemented),
                }
            } else {
                return Err(DecoderError::InvalidData);
            }
            let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(WIDTH, HEIGHT, false, PAL8_FORMAT));
            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() > FRAME_HEADER);

        let mut mr = MemoryReader::new_read(&src);
        let mut br = ByteReader::new(&mut mr);

        let width       = br.read_u16le()? as usize;
        let height      = br.read_u16le()? as usize;
        let xoff        = br.read_u16le()? as usize;
        let yoff        = br.read_u16le()? as usize;
        validate!(width + xoff <= WIDTH && height + yoff <= HEIGHT);

        let _ckey       = br.read_byte()?;
        let frm_type    = br.read_byte()?;
                          br.read_skip(6)?;
        let opcode_size = br.read_u16le()? as usize;
        validate!(opcode_size <= src.len() - FRAME_HEADER);

        let opcodes = &src[FRAME_HEADER..][..opcode_size];
        let clr_data = &src[FRAME_HEADER + opcode_size..];
        match frm_type {
            0 => {
                validate!(opcodes.is_empty());
                validate!(clr_data.len() == width * height);

                let dst = &mut self.frame[xoff + yoff * WIDTH..];
                for (dline, sline) in dst.chunks_mut(WIDTH).zip(clr_data.chunks(width)) {
                    dline[..width].copy_from_slice(sline);
                }
            },
            1 | 11 => {
                validate!(!opcodes.is_empty());
                let mut mr = MemoryReader::new_read(opcodes);
                let mut ops = ByteReader::new(&mut mr);
                let mut mr = MemoryReader::new_read(clr_data);
                let mut clr = ByteReader::new(&mut mr);

                let mut x = xoff;
                let mut y = yoff;
                while y < yoff + height {
                    let op = ops.read_byte()?;
                    let mut len = (op & 0x3F) as usize;
                    if len == 0 {
                        len = width + xoff - x;
                    }
                    match op >> 6 {
                        3 => x += len,
                        2 => {
                            clr.read_buf(&mut self.frame[x + y * WIDTH..][..len])?;
                            x += len;
                        },
                        _ => {
                            let len = ((u16::from(op & 0x7) << 8) | u16::from(ops.read_byte()?)) as usize;
                            match op >> 3 {
                                2 => x += len,
                                3 => {
                                    for _ in 0..len {
                                        validate!(y < height + yoff);
                                        self.frame[x + y * WIDTH] = clr.read_byte()?;
                                        x += 1;
                                        if x == width + xoff {
                                            y += 1;
                                            x = xoff;
                                        }
                                    }
                                },
                                6 => {
                                    let len = if len != 0 { len } else { height + yoff - y };
                                    for _ in 0..(len * width) {
                                        validate!(y < height + yoff);
                                        self.frame[x + y * WIDTH] = clr.read_byte()?;
                                        x += 1;
                                        if x == width + xoff {
                                            y += 1;
                                            x = xoff;
                                        }
                                    }
                                },
                                7 => {
                                    if len > 0 {
                                        y += len;
                                    } else {
                                        y = height + yoff;
                                    }
                                },
                                _ => return Err(DecoderError::NotImplemented),
                            }
                        },
                    }
                    if x == width + xoff {
                        x = xoff;
                        y += 1;
                    }
                }
            },
            _ => return Err(DecoderError::InvalidData),
        }


        let buf = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
        let mut vbuf = buf.get_vbuf().unwrap();
        let paloff = vbuf.get_offset(1);
        let stride = vbuf.get_stride(0);
        let data = vbuf.get_data_mut().unwrap();

        for (drow, srow) in data.chunks_mut(stride).zip(self.frame.chunks_exact(WIDTH)) {
            drow[..WIDTH].copy_from_slice(srow);
        }
        data[paloff..][..768].copy_from_slice(&self.pal);

        let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buf);
        let ftype = if pkt.keyframe { FrameType::I } else { FrameType::P };
        frm.set_frame_type(ftype);
        Ok(frm.into_ref())
    }
    fn flush(&mut self) {
    }
}

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

#[cfg(test)]
mod test {
    use nihav_core::codecs::RegisteredDecoders;
    use nihav_core::demuxers::RegisteredDemuxers;
    use nihav_codec_support::test::dec_video::*;
    use crate::*;
    #[test]
    fn test_seq1() {
        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 King's Quest VI
        test_decoding("sierra-seq", "seq-video", "assets/Game/sierra/FS1.SEQ",
                      Some(2), &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5Frames(vec![
                            [0x5a7472da, 0xa9e242fd, 0x867efa52, 0x9625f05c],
                            [0x720ab982, 0x704970a0, 0xf854af8b, 0x3b86bed9],
                            [0xaa1426e1, 0x79750652, 0x87b7a727, 0xc582a561]]));
    }
    #[test]
    fn test_seq2() {
        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 Gabriel Knight
        test_decoding("sierra-seq", "seq-video", "assets/Game/sierra/blood.seq",
                      Some(2), &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5Frames(vec![
                            [0x989422ee, 0x5892beae, 0x0ca9db17, 0xe25ab710],
                            [0x0d5f395e, 0x2eeac229, 0x1504ece0, 0xa7d3401e],
                            [0x988d3fa6, 0x68be4639, 0x7ab7137c, 0x72e69e26]]));
    }
}
Commit	Line	Data
f9fc73be KS	1	use nihav_core::codecs::*;
	2	use nihav_core::io::byteio::*;
	3
	4	const WIDTH: usize = 320;
	5	const HEIGHT: usize = 200;
	6	const FRAME_HEADER: usize = 24;
	7
	8	struct SequenceDecoder {
	9	info: NACodecInfoRef,
	10	pal: [u8; 768],
	11	frame: [u8; WIDTH * HEIGHT],
	12	}
	13
	14	impl SequenceDecoder {
	15	fn new() -> Self {
	16	Self {
	17	info: NACodecInfoRef::default(),
	18	pal: [0; 768],
	19	frame: [0; WIDTH * HEIGHT],
	20	}
	21	}
	22	}
	23
	24	impl NADecoder for SequenceDecoder {
	25	fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
	26	if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
	27	if let Some(ref edata) = info.get_extradata() {
	28	validate!(edata.len() > 32);
	29	let pal_start = read_u16le(&edata[25..])? as usize;
	30	let pal_len = read_u16le(&edata[29..])? as usize;
	31	validate!(pal_len > 0 && pal_start + pal_len <= 256);
	32	match edata[32] {
	33	0 => {
	34	let dpal = self.pal[pal_start * 3..].chunks_exact_mut(3);
	35	for (dst, quad) in dpal.zip(edata[37..].chunks_exact(4)) {
	36	dst.copy_from_slice(&quad[1..]);
	37	}
	38	},
	39	1 => self.pal[pal_start * 3..][..pal_len * 3].copy_from_slice(&edata[37..][..pal_len * 3]),
	40	_ => return Err(DecoderError::NotImplemented),
	41	}
	42	} else {
	43	return Err(DecoderError::InvalidData);
	44	}
	45	let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(WIDTH, HEIGHT, false, PAL8_FORMAT));
	46	self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
	47
	48	Ok(())
	49	} else {
	50	Err(DecoderError::InvalidData)
	51	}
	52	}
	53	fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
	54	let src = pkt.get_buffer();
	55	validate!(src.len() > FRAME_HEADER);
	56
	57	let mut mr = MemoryReader::new_read(&src);
	58	let mut br = ByteReader::new(&mut mr);
	59
	60	let width = br.read_u16le()? as usize;
	61	let height = br.read_u16le()? as usize;
	62	let xoff = br.read_u16le()? as usize;
	63	let yoff = br.read_u16le()? as usize;
	64	validate!(width + xoff <= WIDTH && height + yoff <= HEIGHT);
65
66	let _ckey = br.read_byte()?;
67	let frm_type = br.read_byte()?;
68	br.read_skip(6)?;
69	let opcode_size = br.read_u16le()? as usize;
70	validate!(opcode_size <= src.len() - FRAME_HEADER);
71
72	let opcodes = &src[FRAME_HEADER..][..opcode_size];
73	let clr_data = &src[FRAME_HEADER + opcode_size..];
74	match frm_type {
75	0 => {
76	validate!(opcodes.is_empty());
77	validate!(clr_data.len() == width * height);
78
79	let dst = &mut self.frame[xoff + yoff * WIDTH..];
80	for (dline, sline) in dst.chunks_mut(WIDTH).zip(clr_data.chunks(width)) {
81	dline[..width].copy_from_slice(sline);
82	}
83	},
84	1 \| 11 => {
85	validate!(!opcodes.is_empty());
86	let mut mr = MemoryReader::new_read(opcodes);
87	let mut ops = ByteReader::new(&mut mr);
88	let mut mr = MemoryReader::new_read(clr_data);
89	let mut clr = ByteReader::new(&mut mr);
90
91	let mut x = xoff;
92	let mut y = yoff;
93	while y < yoff + height {
94	let op = ops.read_byte()?;
95	let mut len = (op & 0x3F) as usize;
96	if len == 0 {
97	len = width + xoff - x;
98	}
99	match op >> 6 {
100	3 => x += len,
101	2 => {
102	clr.read_buf(&mut self.frame[x + y * WIDTH..][..len])?;
103	x += len;
104	},
105	_ => {
106	let len = ((u16::from(op & 0x7) << 8) \| u16::from(ops.read_byte()?)) as usize;
107	match op >> 3 {
108	2 => x += len,
109	3 => {
110	for _ in 0..len {
111	validate!(y < height + yoff);
112	self.frame[x + y * WIDTH] = clr.read_byte()?;
113	x += 1;
114	if x == width + xoff {
115	y += 1;
116	x = xoff;
117	}
118	}
119	},
120	6 => {
121	let len = if len != 0 { len } else { height + yoff - y };
122	for _ in 0..(len * width) {
123	validate!(y < height + yoff);
124	self.frame[x + y * WIDTH] = clr.read_byte()?;
125	x += 1;
126	if x == width + xoff {
127	y += 1;
128	x = xoff;
129	}
130	}
131	},
132	7 => {
133	if len > 0 {
134	y += len;
135	} else {
136	y = height + yoff;
137	}
138	},
139	_ => return Err(DecoderError::NotImplemented),
140	}
141	},
142	}
143	if x == width + xoff {
144	x = xoff;
145	y += 1;
146	}
147	}
148	},
149	_ => return Err(DecoderError::InvalidData),
150	}
151
152
153	let buf = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
154	let mut vbuf = buf.get_vbuf().unwrap();
155	let paloff = vbuf.get_offset(1);
156	let stride = vbuf.get_stride(0);
157	let data = vbuf.get_data_mut().unwrap();
158
159	for (drow, srow) in data.chunks_mut(stride).zip(self.frame.chunks_exact(WIDTH)) {
160	drow[..WIDTH].copy_from_slice(srow);
161	}
162	data[paloff..][..768].copy_from_slice(&self.pal);
163
164	let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buf);
165	let ftype = if pkt.keyframe { FrameType::I } else { FrameType::P };
166	frm.set_frame_type(ftype);
167	Ok(frm.into_ref())
168	}
169	fn flush(&mut self) {
170	}
171	}
172
173	impl NAOptionHandler for SequenceDecoder {
174	fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
175	fn set_options(&mut self, _options: &[NAOption]) { }
176	fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
177	}
178
179	pub fn get_decoder() -> Box<dyn NADecoder + Send> {
180	Box::new(SequenceDecoder::new())
181	}
182
183	#[cfg(test)]
184	mod test {
185	use nihav_core::codecs::RegisteredDecoders;
186	use nihav_core::demuxers::RegisteredDemuxers;
187	use nihav_codec_support::test::dec_video::*;
188	use crate::*;
189	#[test]
190	fn test_seq1() {
191	let mut dmx_reg = RegisteredDemuxers::new();
192	game_register_all_demuxers(&mut dmx_reg);
193	let mut dec_reg = RegisteredDecoders::new();
194	game_register_all_decoders(&mut dec_reg);
195
196	// sample from King's Quest VI
197	test_decoding("sierra-seq", "seq-video", "assets/Game/sierra/FS1.SEQ",
198	Some(2), &dmx_reg, &dec_reg,
199	ExpectedTestResult::MD5Frames(vec![
200	[0x5a7472da, 0xa9e242fd, 0x867efa52, 0x9625f05c],
201	[0x720ab982, 0x704970a0, 0xf854af8b, 0x3b86bed9],
202	[0xaa1426e1, 0x79750652, 0x87b7a727, 0xc582a561]]));
203	}
204	#[test]
205	fn test_seq2() {
206	let mut dmx_reg = RegisteredDemuxers::new();
207	game_register_all_demuxers(&mut dmx_reg);
208	let mut dec_reg = RegisteredDecoders::new();
209	game_register_all_decoders(&mut dec_reg);
210
211	// sample from Gabriel Knight
212	test_decoding("sierra-seq", "seq-video", "assets/Game/sierra/blood.seq",
213	Some(2), &dmx_reg, &dec_reg,
214	ExpectedTestResult::MD5Frames(vec![
215	[0x989422ee, 0x5892beae, 0x0ca9db17, 0xe25ab710],
216	[0x0d5f395e, 0x2eeac229, 0x1504ece0, 0xa7d3401e],
217	[0x988d3fa6, 0x68be4639, 0x7ab7137c, 0x72e69e26]]));
218	}
219	}