1 use nihav_core::codecs::*;
2 use nihav_core::io::byteio::*;
3 use nihav_codec_support::codecs::HAMShuffler;
18 fn decode_8bit(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<FrameType> {
19 let mut has_skips = false;
21 if (br.left() as usize) == self.width * self.height {
22 for line in frm.data.chunks_mut(frm.stride[0]).take(self.height) {
23 br.read_buf(&mut line[..self.width])?;
25 return Ok(FrameType::I);
31 let a = br.read_byte()?;
32 let b = br.read_byte()?;
35 validate!(y < self.height);
36 validate!(x + len <= self.width);
52 if x != 0 || y != self.height {
58 let xoff = br.read_byte()? as usize;
59 let yoff = br.read_byte()? as usize;
60 validate!(x + xoff <= self.width);
61 validate!(y + yoff <= self.height);
68 validate!(y < self.height);
69 validate!(x + len <= self.width);
71 frm.data[doff] = br.read_byte()?;
76 br.read_byte()?; // padding
81 doff = x + y * frm.stride[0];
87 Ok(if has_skips { FrameType::P } else { FrameType::I })
89 fn decode_4bit(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<FrameType> {
90 let mut has_skips = false;
92 if (br.left() as usize) == (self.width + 1) / 2 * self.height {
93 for line in frm.data.chunks_mut(frm.stride[0]).take(self.height) {
94 for i in 0..self.width/2 {
95 let clr = br.read_byte()?;
96 line[i * 2] = clr >> 4;
97 line[i * 2 + 1] = clr & 0xF;
99 if (self.width & 1) == 1 {
100 let clr = br.read_byte()?;
101 line[self.width - 1] = clr >> 4;
104 return Ok(FrameType::I);
110 let a = br.read_byte()?;
111 let b = br.read_byte()?;
113 let len = a as usize;
114 validate!(y < self.height);
115 validate!(x + len <= self.width);
116 for _ in 0..len / 2 {
117 frm.data[doff] = b >> 4;
119 frm.data[doff] = b & 0xF;
123 frm.data[doff] = b >> 4;
137 if x != 0 || y != self.height {
143 let xoff = br.read_byte()? as usize;
144 let yoff = br.read_byte()? as usize;
145 validate!(x + xoff <= self.width);
146 validate!(y + yoff <= self.height);
152 let len = b as usize;
153 validate!(y < self.height);
154 validate!(x + len <= self.width);
155 for _ in 0..len / 2 {
156 let clr = br.read_byte()?;
157 frm.data[doff] = clr >> 4;
159 frm.data[doff] = clr & 0xF;
163 let clr = br.read_byte()?;
164 frm.data[doff] = clr >> 4;
168 if ((len + 1) & 2) != 0 {
169 br.read_byte()?; // padding
174 doff = x + y * frm.stride[0];
180 Ok(if has_skips { FrameType::P } else { FrameType::I })
184 impl NADecoder for RleDecoder {
185 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
186 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
187 self.width = vinfo.get_width();
188 self.height = vinfo.get_height();
189 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(self.width, self.height, true, PAL8_FORMAT));
190 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
191 self.is_4bit = vinfo.bits == 4;
195 Err(DecoderError::InvalidData)
198 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
199 let src = pkt.get_buffer();
200 validate!(src.len() >= 2);
201 let mut mr = MemoryReader::new_read(src.as_slice());
202 let mut br = ByteReader::new(&mut mr);
205 let bufret = self.hams.clone_ref();
207 if let Some(bbuf) = bufret {
210 let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
211 buf = bufinfo.get_vbuf().unwrap();
212 self.hams.add_frame(buf);
213 buf = self.hams.get_output_frame().unwrap();
215 let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
217 ftype = self.decode_8bit(&mut br, &mut frm)?;
219 ftype = self.decode_4bit(&mut br, &mut frm)?;
221 let paloff = frm.offset[1];
222 let dpal = &mut frm.data[paloff..];
223 for sd in pkt.side_data.iter() {
225 NASideData::Palette(_, ref pal) => {
226 for (dst, src) in dpal.chunks_mut(3).zip(pal.chunks(4)) {
236 let buftype = NABufferType::Video(buf);
238 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype);
239 frm.set_keyframe(ftype == FrameType::I);
240 frm.set_frame_type(ftype);
243 fn flush(&mut self) {
248 impl NAOptionHandler for RleDecoder {
249 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
250 fn set_options(&mut self, _options: &[NAOption]) { }
251 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
254 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
255 Box::new(RleDecoder::new())
260 use nihav_core::codecs::RegisteredDecoders;
261 use nihav_core::demuxers::RegisteredDemuxers;
262 use nihav_codec_support::test::dec_video::*;
263 use crate::ms_register_all_codecs;
264 use nihav_commonfmt::generic_register_all_demuxers;
266 fn test_ms_rle_8bit() {
267 let mut dmx_reg = RegisteredDemuxers::new();
268 generic_register_all_demuxers(&mut dmx_reg);
269 let mut dec_reg = RegisteredDecoders::new();
270 ms_register_all_codecs(&mut dec_reg);
272 test_decoding("avi", "msrle", "assets/MS/workcycl-64color.avi", Some(6), &dmx_reg, &dec_reg,
273 ExpectedTestResult::MD5Frames(vec![
274 [0xdd030d70, 0x0b6140ff, 0xdd01823e, 0x27c18f12],
275 [0xd592aa63, 0x97bafa10, 0x380787ed, 0x71da30c4],
276 [0x78596af1, 0x8c21fa09, 0xd914131b, 0x04e3e176],
277 [0xcfe091d7, 0xccd513d5, 0x5bd3caa3, 0xcc388e4a],
278 [0xbea60252, 0x1e493c7d, 0x9996b50c, 0x8f7a1c24],
279 [0xfab23365, 0xe8070819, 0xa2ce974e, 0x15dcabba],
280 [0xd1cdf200, 0x9c2e6d33, 0xbe3270d1, 0x1dede547]]));
283 fn test_ms_rle_8bit_raw() {
284 let mut dmx_reg = RegisteredDemuxers::new();
285 generic_register_all_demuxers(&mut dmx_reg);
286 let mut dec_reg = RegisteredDecoders::new();
287 ms_register_all_codecs(&mut dec_reg);
289 test_decoding("avi", "msrle", "assets/MS/suzie_appl_rle8.avi", Some(2), &dmx_reg, &dec_reg,
290 ExpectedTestResult::MD5Frames(vec![
291 [0xe4d5ad8d, 0x50e8bd7e, 0x0d602ece, 0x3631a8b4],
292 [0x3301ba0e, 0x281c3e54, 0xbd961d44, 0xc352845b],
293 [0x3ed7881d, 0x86acadf7, 0x2922d8bc, 0x8ec9b17e]]));
296 fn test_ms_rle_4bit() {
297 let mut dmx_reg = RegisteredDemuxers::new();
298 generic_register_all_demuxers(&mut dmx_reg);
299 let mut dec_reg = RegisteredDecoders::new();
300 ms_register_all_codecs(&mut dec_reg);
302 test_decoding("avi", "msrle", "assets/MS/mplayer-msrle-4bit.avi", Some(2), &dmx_reg, &dec_reg,
303 ExpectedTestResult::MD5Frames(vec![
304 [0x9898c473, 0x80362654, 0xdb40513a, 0xb0c60fd9],
305 [0x281e1531, 0x368a71cb, 0x9dd02f8d, 0xdfe630d9],
306 [0x6faac693, 0x1856d0fd, 0x47933bb2, 0xb2fb02b0]]));
309 fn test_ms_rle_4bit_raw() {
310 let mut dmx_reg = RegisteredDemuxers::new();
311 generic_register_all_demuxers(&mut dmx_reg);
312 let mut dec_reg = RegisteredDecoders::new();
313 ms_register_all_codecs(&mut dec_reg);
315 test_decoding("avi", "msrle", "assets/MS/suzie_appl_rle4.avi", Some(2), &dmx_reg, &dec_reg,
316 ExpectedTestResult::MD5([0xb5d38296, 0xdae25407, 0x985973f0, 0xb1da9c94]));