[nihav.git] / nihav-qt / src / codecs / rpza.rs

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

const RGB555_FORMAT: NAPixelFormaton = NAPixelFormaton {
        model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
        comp_info: [
            Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 10, comp_offs: 0, next_elem: 2 }),
            Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift:  5, comp_offs: 0, next_elem: 2 }),
            Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift:  0, comp_offs: 0, next_elem: 2 }),
            None, None],
        elem_size: 2, be: false, alpha: false, palette: false };

#[derive(Default)]
struct RpzaDecoder {
    info:       NACodecInfoRef,
    hams:       HAMShuffler<u16>,
    width:      usize,
    height:     usize,
}

impl RpzaDecoder {
    fn new() -> Self {
        Self::default()
    }
    fn put_block(dst: &mut [u16], dstride: usize, block: &[u16; 16]) {
        for (line, src) in dst.chunks_mut(dstride).take(4).zip(block.chunks(4)) {
            (&mut line[..4]).copy_from_slice(src);
        }
    }
}

fn div3(a: u16, b: u16) -> u16 {
    let r0 = (a >> 10) & 0x1F;
    let g0 = (a >>  5) & 0x1F;
    let b0 =  a        & 0x1F;
    let r1 = (b >> 10) & 0x1F;
    let g1 = (b >>  5) & 0x1F;
    let b1 =  b        & 0x1F;

    let r = (r0 * 21 + r1 * 11) / 32;
    let g = (g0 * 21 + g1 * 11) / 32;
    let b = (b0 * 21 + b1 * 11) / 32;

    (r << 10) | (g << 5) | b
}

impl NADecoder for RpzaDecoder {
    fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
        if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
            self.width  = (vinfo.get_width()  + 3) & !3;
            self.height = (vinfo.get_height() + 3) & !3;
            let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(self.width, self.height, false, RGB555_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() >= 2);
        let mut mr = MemoryReader::new_read(src.as_slice());
        let mut br = ByteReader::new(&mut mr);

        let id                          = br.read_byte()?;
        validate!(id == 0xE1);
        let length                      = br.read_u24be()? as usize;
        validate!(length == src.len());

        let bufret = self.hams.clone_ref();
        let mut buf;
        if let Some(bbuf) = bufret {
            buf = bbuf;
        } else {
            let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 2)?;
            buf = bufinfo.get_vbuf16().unwrap();
            self.hams.add_frame(buf);
            buf = self.hams.get_output_frame().unwrap();
        }
        let frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
        let stride = frm.stride[0];
        let mut doff = frm.offset[0];

        let mut x = 0;
        let nblocks = (self.width / 4) * (self.height / 4);
        let mut blockpos = 0;
        let mut has_skips = false;
        let mut block = [0u16; 16];
        while blockpos < nblocks {
            let opcode                  = br.read_byte()?;
            if (opcode & 0x80) == 0 {
                let b2                  = br.read_byte()?;
                let clr0 = u16::from(opcode) * 256 + u16::from(b2);
                if (br.peek_byte()? & 0x80) == 0 {
                    block[0] = clr0;
                    for el in block.iter_mut().skip(1) {
                        *el             = br.read_u16be()?;
                    }
                } else {
                    let clr3            = br.read_u16be()?;
                    let clr1 = div3(clr0, clr3);
                    let clr2 = div3(clr3, clr0);
                    let clr = [clr3, clr2, clr1, clr0];
                    let flags       = br.read_u32be()? as usize;
                    for i in 0..16 {
                        block[i] = clr[(flags >> (30 - i * 2)) & 3];
                    }
                }
                Self::put_block(&mut frm.data[doff + x..], stride, &block);
                x += 4;
                if x == self.width {
                    x = 0;
                    doff += stride * 4;
                }
                blockpos += 1;
                continue;
            }
            let len = ((opcode & 0x1F) as usize) + 1;
            validate!(blockpos + len <= nblocks);
            match opcode >> 5 {
                4 => {
                    has_skips = true;
                    for _ in 0..len {
                        x += 4;
                        if x == self.width {
                            x = 0;
                            doff += stride * 4;
                        }
                    }
                },
                5 => {
                    let clr             = br.read_u16be()?;
                    block = [clr; 16];
                    for _ in 0..len {
                        Self::put_block(&mut frm.data[doff + x..], stride, &block);
                        x += 4;
                        if x == self.width {
                            x = 0;
                            doff += stride * 4;
                        }
                    }
                },
                6 => {
                    let clr0            = br.read_u16be()?;
                    let clr3            = br.read_u16be()?;
                    let clr1 = div3(clr0, clr3);
                    let clr2 = div3(clr3, clr0);
                    let clr = [clr3, clr2, clr1, clr0];
                    for _ in 0..len {
                        let flags       = br.read_u32be()? as usize;
                        for i in 0..16 {
                            block[i] = clr[(flags >> (30 - i * 2)) & 3];
                        }
                        Self::put_block(&mut frm.data[doff + x..], stride, &block);
                        x += 4;
                        if x == self.width {
                            x = 0;
                            doff += stride * 4;
                        }
                    }
                },
                _ => {
                    return Err(DecoderError::InvalidData);
                },
            };
            blockpos += len;
        }

        let buftype = NABufferType::Video16(buf);

        let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype);
        frm.set_keyframe(!has_skips);
        frm.set_frame_type(if !has_skips { FrameType::I } else { FrameType::P });
        Ok(frm.into_ref())
    }
    fn flush(&mut self) {
        self.hams.clear();
    }
}

impl NAOptionHandler for RpzaDecoder {
    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(RpzaDecoder::new())
}

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

        // sample: https://samples.mplayerhq.hu/V-codecs/RPZA/aletrek-rpza.mov
        test_decoding("mov", "apple-video", "assets/QT/aletrek-rpza.mov", Some(6), &dmx_reg &dec_reg,
                      ExpectedTestResult::MD5Frames(vec![
                            [0xe7cfc941, 0xa448841b, 0x75afc888, 0x94aa064b],
                            [0xadaaec50, 0xff7319ff, 0xa1f3f64a, 0xc40c2985],
                            [0xdfa5c4b9, 0xdac2d22b, 0x14f9f281, 0x7295eae7],
                            [0x3f3420b9, 0xbe48b885, 0x91b0fb51, 0xd71462ac],
                            [0xcaae1580, 0x16eecce3, 0x2ca0dd4b, 0x7f9c62e3],
                            [0xb51fc759, 0xe1cfc171, 0xda854767, 0x878f6e17],
                            [0x8d3abf6d, 0xeecec7a2, 0x5832e5d6, 0x86145fc9]]));
    }
}
Commit	Line	Data
4c1582cf KS	1	use nihav_core::codecs::*;
	2	use nihav_core::io::byteio::*;
	3	use nihav_codec_support::codecs::HAMShuffler;
	4
	5	const RGB555_FORMAT: NAPixelFormaton = NAPixelFormaton {
	6	model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
	7	comp_info: [
	8	Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 10, comp_offs: 0, next_elem: 2 }),
	9	Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 5, comp_offs: 0, next_elem: 2 }),
	10	Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 0, comp_offs: 0, next_elem: 2 }),
	11	None, None],
	12	elem_size: 2, be: false, alpha: false, palette: false };
	13
	14	#[derive(Default)]
	15	struct RpzaDecoder {
	16	info: NACodecInfoRef,
	17	hams: HAMShuffler<u16>,
	18	width: usize,
	19	height: usize,
	20	}
	21
	22	impl RpzaDecoder {
	23	fn new() -> Self {
	24	Self::default()
	25	}
	26	fn put_block(dst: &mut [u16], dstride: usize, block: &[u16; 16]) {
	27	for (line, src) in dst.chunks_mut(dstride).take(4).zip(block.chunks(4)) {
	28	(&mut line[..4]).copy_from_slice(src);
	29	}
	30	}
	31	}
	32
	33	fn div3(a: u16, b: u16) -> u16 {
	34	let r0 = (a >> 10) & 0x1F;
	35	let g0 = (a >> 5) & 0x1F;
	36	let b0 = a & 0x1F;
	37	let r1 = (b >> 10) & 0x1F;
	38	let g1 = (b >> 5) & 0x1F;
	39	let b1 = b & 0x1F;
	40
	41	let r = (r0 * 21 + r1 * 11) / 32;
	42	let g = (g0 * 21 + g1 * 11) / 32;
	43	let b = (b0 * 21 + b1 * 11) / 32;
	44
	45	(r << 10) \| (g << 5) \| b
	46	}
	47
	48	impl NADecoder for RpzaDecoder {
	49	fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
	50	if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
	51	self.width = (vinfo.get_width() + 3) & !3;
	52	self.height = (vinfo.get_height() + 3) & !3;
	53	let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(self.width, self.height, false, RGB555_FORMAT));
	54	self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
	55
	56	Ok(())
	57	} else {
	58	Err(DecoderError::InvalidData)
	59	}
	60	}
	61	fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
	62	let src = pkt.get_buffer();
	63	validate!(src.len() >= 2);
	64	let mut mr = MemoryReader::new_read(src.as_slice());
65	let mut br = ByteReader::new(&mut mr);
66
67	let id = br.read_byte()?;
68	validate!(id == 0xE1);
69	let length = br.read_u24be()? as usize;
70	validate!(length == src.len());
71
72	let bufret = self.hams.clone_ref();
73	let mut buf;
74	if let Some(bbuf) = bufret {
75	buf = bbuf;
76	} else {
77	let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 2)?;
78	buf = bufinfo.get_vbuf16().unwrap();
79	self.hams.add_frame(buf);
80	buf = self.hams.get_output_frame().unwrap();
81	}
82	let frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
83	let stride = frm.stride[0];
84	let mut doff = frm.offset[0];
85
86	let mut x = 0;
87	let nblocks = (self.width / 4) * (self.height / 4);
88	let mut blockpos = 0;
89	let mut has_skips = false;
90	let mut block = [0u16; 16];
91	while blockpos < nblocks {
92	let opcode = br.read_byte()?;
93	if (opcode & 0x80) == 0 {
94	let b2 = br.read_byte()?;
95	let clr0 = u16::from(opcode) * 256 + u16::from(b2);
96	if (br.peek_byte()? & 0x80) == 0 {
97	block[0] = clr0;
98	for el in block.iter_mut().skip(1) {
99	*el = br.read_u16be()?;
100	}
101	} else {
102	let clr3 = br.read_u16be()?;
103	let clr1 = div3(clr0, clr3);
104	let clr2 = div3(clr3, clr0);
105	let clr = [clr3, clr2, clr1, clr0];
106	let flags = br.read_u32be()? as usize;
107	for i in 0..16 {
108	block[i] = clr[(flags >> (30 - i * 2)) & 3];
109	}
110	}
111	Self::put_block(&mut frm.data[doff + x..], stride, &block);
112	x += 4;
113	if x == self.width {
114	x = 0;
115	doff += stride * 4;
116	}
117	blockpos += 1;
118	continue;
119	}
120	let len = ((opcode & 0x1F) as usize) + 1;
121	validate!(blockpos + len <= nblocks);
122	match opcode >> 5 {
123	4 => {
124	has_skips = true;
125	for _ in 0..len {
126	x += 4;
127	if x == self.width {
128	x = 0;
129	doff += stride * 4;
130	}
131	}
132	},
133	5 => {
134	let clr = br.read_u16be()?;
135	block = [clr; 16];
136	for _ in 0..len {
137	Self::put_block(&mut frm.data[doff + x..], stride, &block);
138	x += 4;
139	if x == self.width {
140	x = 0;
141	doff += stride * 4;
142	}
143	}
144	},
145	6 => {
146	let clr0 = br.read_u16be()?;
147	let clr3 = br.read_u16be()?;
148	let clr1 = div3(clr0, clr3);
149	let clr2 = div3(clr3, clr0);
150	let clr = [clr3, clr2, clr1, clr0];
151	for _ in 0..len {
152	let flags = br.read_u32be()? as usize;
153	for i in 0..16 {
154	block[i] = clr[(flags >> (30 - i * 2)) & 3];
155	}
156	Self::put_block(&mut frm.data[doff + x..], stride, &block);
157	x += 4;
158	if x == self.width {
159	x = 0;
160	doff += stride * 4;
161	}
162	}
163	},
164	_ => {
165	return Err(DecoderError::InvalidData);
166	},
167	};
168	blockpos += len;
169	}
170
171	let buftype = NABufferType::Video16(buf);
172
173	let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype);
174	frm.set_keyframe(!has_skips);
175	frm.set_frame_type(if !has_skips { FrameType::I } else { FrameType::P });
176	Ok(frm.into_ref())
177	}
178	fn flush(&mut self) {
179	self.hams.clear();
180	}
181	}
182
183	impl NAOptionHandler for RpzaDecoder {
184	fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
185	fn set_options(&mut self, _options: &[NAOption]) { }
186	fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
187	}
188
189	pub fn get_decoder() -> Box<dyn NADecoder + Send> {
190	Box::new(RpzaDecoder::new())
191	}
192
193	#[cfg(test)]
194	mod test {
195	use nihav_core::codecs::RegisteredDecoders;
196	use nihav_core::demuxers::RegisteredDemuxers;
197	use nihav_codec_support::test::dec_video::*;
78fb6560	198	use crate::qt_register_all_decoders;
4c1582cf KS	199	use nihav_commonfmt::generic_register_all_demuxers;
	200	#[test]
	201	fn test_rpza() {
	202	let mut dmx_reg = RegisteredDemuxers::new();
	203	generic_register_all_demuxers(&mut dmx_reg);
	204	let mut dec_reg = RegisteredDecoders::new();
78fb6560	205	qt_register_all_decoders(&mut dec_reg);
4c1582cf	206
886cde48 KS	207	// sample: https://samples.mplayerhq.hu/V-codecs/RPZA/aletrek-rpza.mov
886cde48 KS	208	test_decoding("mov", "apple-video", "assets/QT/aletrek-rpza.mov", Some(6), &dmx_reg &dec_reg,
4c1582cf KS	209	ExpectedTestResult::MD5Frames(vec![
	210	[0xe7cfc941, 0xa448841b, 0x75afc888, 0x94aa064b],
	211	[0xadaaec50, 0xff7319ff, 0xa1f3f64a, 0xc40c2985],
	212	[0xdfa5c4b9, 0xdac2d22b, 0x14f9f281, 0x7295eae7],
	213	[0x3f3420b9, 0xbe48b885, 0x91b0fb51, 0xd71462ac],
	214	[0xcaae1580, 0x16eecce3, 0x2ca0dd4b, 0x7f9c62e3],
	215	[0xb51fc759, 0xe1cfc171, 0xda854767, 0x878f6e17],
	216	[0x8d3abf6d, 0xeecec7a2, 0x5832e5d6, 0x86145fc9]]));
	217	}
	218	}