1 use nihav_core::codecs::*;
2 use nihav_core::io::byteio::*;
3 use nihav_codec_support::codecs::HAMShuffler;
5 const RGB555_FORMAT: NAPixelFormaton = NAPixelFormaton {
6 model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
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 }),
12 elem_size: 2, be: false, alpha: false, palette: false };
14 pub const ARGB_FORMAT: NAPixelFormaton = NAPixelFormaton {
15 model: ColorModel::RGB(RGBSubmodel::RGB), components: 4,
17 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 4 }),
18 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 4 }),
19 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 3, next_elem: 4 }),
20 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 4 }),
22 elem_size: 4, be: false, alpha: true, palette: false };
27 hams: HAMShuffler<u8>,
28 hams16: HAMShuffler<u16>,
34 #[allow(clippy::needless_range_loop)]
35 fn unpack_mono(src: u16, dst: &mut [u8; 16]) {
37 dst[i] = ((src >> (15 - i)) & 1) as u8;
41 #[allow(clippy::needless_range_loop)]
42 fn unpack_pixels(src: u32, dst: &mut [u8; 16], depth: u8) {
43 let depth = depth as usize;
44 let mask = (1 << depth) - 1;
45 for i in 0..32 / depth {
46 dst[i] = ((src >> (32 - depth - i * depth)) & mask) as u8;
54 fn decode_mono(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u8>, start_line: usize, end_line: usize) -> DecoderResult<bool> {
55 let mut has_skips = false;
56 let mut pix_buf = [0u8; 16];
59 let stride = frm.stride[0];
60 let mut doff = frm.offset[0] + start_line * stride;
61 let mut y = start_line;
64 while x < self.width {
65 let skip_code = br.read_byte()?;
66 let rle_code = br.read_byte()? as i8;
68 validate!((skip_code & 0x80) != 0);
73 if x != 0 && (skip_code & 0x80) != 0 {
76 validate!(y < end_line);
80 let skip = (skip_code & 0x1F) as usize;
84 validate!(x + skip * npixels <= self.width);
87 let len = (-i16::from(rle_code)) as usize;
88 validate!(x + len * npixels <= self.width);
89 let val = br.read_u16be()?;
90 unpack_mono(val, &mut pix_buf);
92 for el in pix_buf.iter() {
93 frm.data[doff + x] = *el;
98 let len = rle_code as usize;
99 validate!(x + len * npixels <= self.width);
101 let val = br.read_u16be()?;
102 unpack_mono(val, &mut pix_buf);
103 for el in pix_buf.iter() {
104 frm.data[doff + x] = *el;
116 fn decode_pal(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u8>, start_line: usize, end_line: usize) -> DecoderResult<bool> {
117 let mut has_skips = false;
118 let mut pix_buf = [0u8; 16];
119 let npixels = match self.depth {
123 _ => return Err(DecoderError::InvalidData),
126 let stride = frm.stride[0];
127 let mut doff = frm.offset[0] + start_line * stride;
128 for _ in start_line..end_line {
130 let mut skip_mode = true;
131 while x < self.width {
133 let skip_code = br.read_byte()?;
137 let skip = (skip_code - 1) as usize;
138 validate!(x + skip * npixels <= self.width);
144 let rle_code = br.read_byte()? as i8;
147 } else if rle_code == -1 {
152 } else if rle_code < 0 {
153 let len = (-i16::from(rle_code)) as usize;
154 validate!(x + len * npixels <= self.width);
155 let val = br.read_u32be()?;
156 unpack_pixels(val, &mut pix_buf, self.depth);
158 for el in pix_buf.iter().take(npixels) {
159 frm.data[doff + x] = *el;
164 let len = rle_code as usize;
165 validate!(x + len * npixels <= self.width);
167 let val = br.read_u32be()?;
168 unpack_pixels(val, &mut pix_buf, self.depth);
169 for el in pix_buf.iter().take(npixels) {
170 frm.data[doff + x] = *el;
178 let eol = br.read_byte()? as i8;
179 validate!(eol == -1);
186 fn decode_16bit(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u16>, start_line: usize, end_line: usize) -> DecoderResult<bool> {
187 let mut has_skips = false;
189 let stride = frm.stride[0];
190 let mut doff = frm.offset[0] + start_line * stride;
191 for _ in start_line..end_line {
193 let mut skip_mode = true;
194 while x < self.width {
196 let skip_code = br.read_byte()?;
200 let skip = (skip_code - 1) as usize;
201 validate!(x + skip <= self.width);
207 let rle_code = br.read_byte()? as i8;
210 } else if rle_code == -1 {
215 } else if rle_code < 0 {
216 let len = (-i16::from(rle_code)) as usize;
217 validate!(x + len <= self.width);
218 let pix = br.read_u16be()?;
220 frm.data[doff + x] = pix;
224 let len = rle_code as usize;
225 validate!(x + len <= self.width);
227 frm.data[doff + x] = br.read_u16be()?;
234 let eol = br.read_byte()? as i8;
235 validate!(eol == -1);
242 fn decode_24bit(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u8>, start_line: usize, end_line: usize) -> DecoderResult<bool> {
243 let mut has_skips = false;
244 let mut rgb = [0u8; 3];
246 let stride = frm.stride[0];
247 let mut doff = frm.offset[0] + start_line * stride;
248 for _ in start_line..end_line {
250 let mut skip_mode = true;
251 while x < self.width {
253 let skip_code = br.read_byte()?;
257 let skip = (skip_code - 1) as usize;
258 validate!(x + skip <= self.width);
264 let rle_code = br.read_byte()? as i8;
267 } else if rle_code == -1 {
272 } else if rle_code < 0 {
273 let len = (-i16::from(rle_code)) as usize;
274 validate!(x + len <= self.width);
275 br.read_buf(&mut rgb)?;
277 frm.data[doff + x * 3] = rgb[0];
278 frm.data[doff + x * 3 + 1] = rgb[1];
279 frm.data[doff + x * 3 + 2] = rgb[2];
283 let len = rle_code as usize;
284 validate!(x + len <= self.width);
285 br.read_buf(&mut frm.data[doff + x * 3..][..len * 3])?;
291 let eol = br.read_byte()? as i8;
292 validate!(eol == -1);
299 fn decode_32bit(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u8>, start_line: usize, end_line: usize) -> DecoderResult<bool> {
300 let mut has_skips = false;
301 let mut rgb = [0u8; 4];
303 let stride = frm.stride[0];
304 let mut doff = frm.offset[0] + start_line * stride;
305 for _ in start_line..end_line {
307 let mut skip_mode = true;
308 while x < self.width {
310 let skip_code = br.read_byte()?;
314 let skip = (skip_code - 1) as usize;
315 validate!(x + skip <= self.width);
321 let rle_code = br.read_byte()? as i8;
324 } else if rle_code == -1 {
329 } else if rle_code < 0 {
330 let len = (-i16::from(rle_code)) as usize;
331 validate!(x + len <= self.width);
332 br.read_buf(&mut rgb)?;
334 frm.data[doff + x * 4] = rgb[0];
335 frm.data[doff + x * 4 + 1] = rgb[1];
336 frm.data[doff + x * 4 + 2] = rgb[2];
337 frm.data[doff + x * 4 + 3] = rgb[3];
341 let len = rle_code as usize;
342 validate!(x + len <= self.width);
343 br.read_buf(&mut frm.data[doff + x * 4..][..len * 4])?;
349 let eol = br.read_byte()? as i8;
350 validate!(eol == -1);
359 impl NADecoder for RleDecoder {
360 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
361 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
362 self.width = vinfo.get_width();
363 self.height = vinfo.get_height();
364 self.depth = vinfo.bits;
365 let fmt = match self.depth {
366 1 | 2 | 4 | 8 => PAL8_FORMAT,
367 15 | 16 => RGB555_FORMAT,
370 _ => return Err(DecoderError::InvalidData),
372 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(self.width, self.height, false, fmt));
373 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
377 Err(DecoderError::InvalidData)
380 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
381 let src = pkt.get_buffer();
382 validate!(src.len() >= 2);
383 let mut mr = MemoryReader::new_read(src.as_slice());
384 let mut br = ByteReader::new(&mut mr);
386 let id = br.read_byte()?;
387 validate!(id == 0x40 || id == 0x00);
388 let length = br.read_u24be()? as usize;
389 validate!(length == src.len());
391 let flags = br.read_u16be()?;
392 let (start_line, end_line) = if (flags & 0x8) != 0 {
393 let start = br.read_u16be()? as usize;
395 let h = br.read_u16be()? as usize;
397 validate!(start + h <= self.height);
406 let bufret = self.hams.clone_ref();
408 if let Some(bbuf) = bufret {
411 let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
412 buf = bufinfo.get_vbuf().unwrap();
413 self.hams.add_frame(buf);
414 buf = self.hams.get_output_frame().unwrap();
416 let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
418 has_skips = self.decode_pal(&mut br, &mut frm, start_line, end_line)?;
420 has_skips = self.decode_mono(&mut br, &mut frm, start_line, end_line)?;
423 let paloff = frm.offset[1];
424 let dpal = &mut frm.data[paloff..];
425 for sd in pkt.side_data.iter() {
427 NASideData::Palette(_, ref pal) => {
428 for (dst, src) in dpal.chunks_mut(3).zip(pal.chunks(4)) {
438 buftype = NABufferType::Video(buf);
439 } else if self.depth == 16 {
440 let bufret = self.hams16.clone_ref();
442 if let Some(bbuf) = bufret {
445 let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
446 buf = bufinfo.get_vbuf16().unwrap();
447 self.hams16.add_frame(buf);
448 buf = self.hams16.get_output_frame().unwrap();
450 let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
451 has_skips = self.decode_16bit(&mut br, &mut frm, start_line, end_line)?;
452 buftype = NABufferType::Video16(buf);
453 } else if self.depth == 24 {
454 let bufret = self.hams.clone_ref();
456 if let Some(bbuf) = bufret {
459 let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
460 buf = bufinfo.get_vbuf().unwrap();
461 self.hams.add_frame(buf);
462 buf = self.hams.get_output_frame().unwrap();
464 let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
465 has_skips = self.decode_24bit(&mut br, &mut frm, start_line, end_line)?;
466 buftype = NABufferType::Video(buf);
467 } else if self.depth == 32 {
468 let bufret = self.hams.clone_ref();
470 if let Some(bbuf) = bufret {
473 let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
474 buf = bufinfo.get_vbuf().unwrap();
475 self.hams.add_frame(buf);
476 buf = self.hams.get_output_frame().unwrap();
478 let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
479 has_skips = self.decode_32bit(&mut br, &mut frm, start_line, end_line)?;
480 buftype = NABufferType::Video(buf);
482 return Err(DecoderError::InvalidData);
484 if (start_line != 0) || (end_line != self.height) {
488 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype);
489 frm.set_keyframe(!has_skips);
490 frm.set_frame_type(if !has_skips { FrameType::I } else { FrameType::P });
493 fn flush(&mut self) {
499 impl NAOptionHandler for RleDecoder {
500 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
501 fn set_options(&mut self, _options: &[NAOption]) { }
502 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
505 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
506 Box::new(RleDecoder::new())
511 use nihav_core::codecs::RegisteredDecoders;
512 use nihav_core::demuxers::RegisteredDemuxers;
513 use nihav_codec_support::test::dec_video::*;
514 use crate::qt_register_all_decoders;
515 use nihav_commonfmt::generic_register_all_demuxers;
517 fn test_qt_rle_1bit() {
518 let mut dmx_reg = RegisteredDemuxers::new();
519 generic_register_all_demuxers(&mut dmx_reg);
520 let mut dec_reg = RegisteredDecoders::new();
521 qt_register_all_decoders(&mut dec_reg);
523 //test_file_decoding("mov", "assets/QT/Animation-Monochrome.mov", Some(6), true, false, Some("qtrle-mono"), &dmx_reg, &dec_reg);
524 test_decoding("mov", "qt-rle", "assets/QT/Animation-Monochrome.mov", Some(6), &dmx_reg, &dec_reg,
525 ExpectedTestResult::MD5Frames(vec![
526 [0xc5b6fd2b, 0x87aae95c, 0xc32d0aaa, 0x4ed21592],
527 [0xe13aa599, 0x2ec6421e, 0xfcfdcc81, 0x8c2ee2ef],
528 [0xd835547b, 0xe2ffd6c9, 0xe24135c1, 0x7d2bb64f],
529 [0x6176e812, 0xb637444c, 0x71b1cbe5, 0xfc98905f],
530 [0x53a6b414, 0xbbf266c0, 0x859c3d10, 0x179a2252],
531 [0x56bc8cdd, 0x6438ba4d, 0x056e79c1, 0xb851e767],
532 [0xc25b9fec, 0xfc93233a, 0x30301b6d, 0xb290f5d7]]));
535 fn test_qt_rle_4bit() {
536 let mut dmx_reg = RegisteredDemuxers::new();
537 generic_register_all_demuxers(&mut dmx_reg);
538 let mut dec_reg = RegisteredDecoders::new();
539 qt_register_all_decoders(&mut dec_reg);
541 test_decoding("mov", "qt-rle", "assets/QT/Animation-16Greys.mov", Some(6), &dmx_reg, &dec_reg,
542 ExpectedTestResult::MD5Frames(vec![
543 [0x280c82aa, 0xa8bd11a6, 0x5b5babda, 0xeff58dd9],
544 [0x5c732231, 0x81d20be3, 0x41249639, 0xab2a9841],
545 [0xb689268d, 0x26de8510, 0x506e0a06, 0xb0dcfc40],
546 [0x09dced38, 0xbd0f5482, 0x3803efc9, 0x84bcaac4],
547 [0x5c49f8cc, 0xc1e2bd17, 0x1c22b849, 0x8f09afd5],
548 [0xe9f7b847, 0x13a4e429, 0x1b8af943, 0x82766ed2],
549 [0x2833c41a, 0x53781343, 0xce083e07, 0xdc3b24e9]]));
552 fn test_qt_rle_8bit() {
553 let mut dmx_reg = RegisteredDemuxers::new();
554 generic_register_all_demuxers(&mut dmx_reg);
555 let mut dec_reg = RegisteredDecoders::new();
556 qt_register_all_decoders(&mut dec_reg);
558 test_decoding("mov", "qt-rle", "assets/QT/Animation-256Greys.mov", Some(6), &dmx_reg, &dec_reg,
559 ExpectedTestResult::MD5Frames(vec![
560 [0x3c439212, 0x419944a5, 0xb274d9f5, 0xf3c53b12],
561 [0xd2a51886, 0xfbd37c2e, 0x899806c6, 0x465a66e0],
562 [0xbd59029e, 0x9de8766c, 0xd681bf0c, 0xa7fe4dfe],
563 [0x6150d380, 0xe8d67e0b, 0x0beb8455, 0xfcfd899d],
564 [0xba0f6b50, 0xba253267, 0xb727c5d7, 0x10dbf0c7],
565 [0x4f93f1aa, 0x2f10aa86, 0xfa97b35f, 0x687065df],
566 [0x730270e2, 0x3a3e02f1, 0xb906f478, 0xdb42af87]]));
569 fn test_qt_rle_16bit() {
570 let mut dmx_reg = RegisteredDemuxers::new();
571 generic_register_all_demuxers(&mut dmx_reg);
572 let mut dec_reg = RegisteredDecoders::new();
573 qt_register_all_decoders(&mut dec_reg);
575 test_decoding("mov", "qt-rle", "assets/QT/Animation-Highcolour.mov", Some(6), &dmx_reg, &dec_reg,
576 ExpectedTestResult::MD5Frames(vec![
577 [0x8fa5361b, 0xd36d6def, 0x33b250e9, 0xab98a41c],
578 [0xdd253ce0, 0xbc5fd3a1, 0x51fe2394, 0x950f18e4],
579 [0xbf34ca8d, 0x1faa24ee, 0x8d70af09, 0x742a4056],
580 [0x9feca59b, 0xdca7dc1d, 0xb6fe14f1, 0xd88c8b67],
581 [0x2e1544b8, 0x89a7e788, 0x0efcde09, 0xec4e7995],
582 [0x1e28b2a8, 0xd53495ca, 0x405a9b6e, 0x59338cad],
583 [0xe90156a4, 0xb64bca4a, 0x5cdf6681, 0xc32945fb]]));
586 fn test_qt_rle_24bit() {
587 let mut dmx_reg = RegisteredDemuxers::new();
588 generic_register_all_demuxers(&mut dmx_reg);
589 let mut dec_reg = RegisteredDecoders::new();
590 qt_register_all_decoders(&mut dec_reg);
592 test_decoding("mov", "qt-rle", "assets/QT/Animation-Truecolour.mov", Some(6), &dmx_reg, &dec_reg,
593 ExpectedTestResult::MD5Frames(vec![
594 [0x84d00c89, 0xf92c7f81, 0x6c1bd9e7, 0x35dd8f57],
595 [0x5ff0a7c9, 0xb589a484, 0xecc230b3, 0xe4e53bd3],
596 [0xbb394f7b, 0x2591b6c6, 0x12b0070c, 0xfa0952fc],
597 [0x380c1756, 0x72be8b16, 0xa7bbff48, 0x106017d4],
598 [0x27d8cc7c, 0x43ee384d, 0x542b95b1, 0x0a3ee031],
599 [0xa29529de, 0xcb53d03b, 0x4f2b6ec5, 0x4ea5d738],
600 [0x181d471b, 0x90d389e7, 0xc627b263, 0xa9d42323]]));
603 fn test_qt_rle_32bit() {
604 let mut dmx_reg = RegisteredDemuxers::new();
605 generic_register_all_demuxers(&mut dmx_reg);
606 let mut dec_reg = RegisteredDecoders::new();
607 qt_register_all_decoders(&mut dec_reg);
609 test_decoding("mov", "qt-rle", "assets/QT/Jag-finder-renaming.mov", Some(10), &dmx_reg, &dec_reg,
610 ExpectedTestResult::MD5Frames(vec![
611 [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125],
612 [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125],
613 [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125],
614 [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125],
615 [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125],
616 [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125],
617 [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125],
618 [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125],
619 [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125],
620 [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125],
621 [0xe67d4be5, 0xe41ce60e, 0x4e6912c3, 0xc96dc521]]));