nihav-commonfmt/src/codecs/cinepak.rs

   1 use nihav_core::io::byteio::{ByteReader,MemoryReader};
   2 use nihav_core::formats::YUV420_FORMAT;
   3 use nihav_core::codecs::*;
   4 use nihav_codec_support::codecs::HAMShuffler;
   5 use std::io::SeekFrom;
   6
   7 #[derive(Clone,Copy,PartialEq)]
   8 enum DecodeMode {
   9     YUV,
  10     Gray,
  11     Palette,
  12     Unknown,
  13 }
  14
  15 struct CinepakDecoder {
  16     info:   NACodecInfoRef,
  17     frmmgr: HAMShuffler,
  18     cb_v1:  [[u8; 6]; 256],
  19     cb_v4:  [[u8; 6]; 256],
  20     mode:   DecodeMode,
  21 }
  22
  23 fn put_block(block: &[u8; 24], x: usize, y: usize, frm: &mut NASimpleVideoFrame<u8>) {
  24     let mut yoff = frm.offset[0] + x + y * frm.stride[0];
  25     for i in 0..4 {
  26         for j in 0..4 {
  27             frm.data[yoff + j] = block[j + i * 4];
  28         }
  29         yoff += frm.stride[0];
  30     }
  31     let mut uoff = frm.offset[1] + x / 2 + y / 2 * frm.stride[1];
  32     for i in 0..2 {
  33         for j in 0..2 {
  34             frm.data[uoff + j] = block[j + i * 2 + 16];
  35         }
  36         uoff += frm.stride[1];
  37     }
  38     let mut voff = frm.offset[2] + x / 2 + y / 2 * frm.stride[2];
  39     for i in 0..2 {
  40         for j in 0..2 {
  41             frm.data[voff + j] = block[j + i * 2 + 20];
  42         }
  43         voff += frm.stride[2];
  44     }
  45 }
  46
  47 fn put_block_gray(block: &[u8; 24], x: usize, y: usize, frm: &mut NASimpleVideoFrame<u8>) {
  48     let mut yoff = frm.offset[0] + x + y * frm.stride[0];
  49     for i in 0..4 {
  50         for j in 0..4 {
  51             frm.data[yoff + j] = block[j + i * 4];
  52         }
  53         yoff += frm.stride[0];
  54     }
  55 }
  56
  57 impl CinepakDecoder {
  58     fn new() -> Self {
  59         CinepakDecoder {
  60             info:   NACodecInfo::new_dummy(),
  61             frmmgr: HAMShuffler::new(),
  62             cb_v1:  [[0; 6]; 256],
  63             cb_v4:  [[0; 6]; 256],
  64             mode:   DecodeMode::Unknown,
  65         }
  66     }
  67     fn read_cb(br: &mut ByteReader, size: usize, cb: &mut [[u8; 6]; 256], is_yuv: bool) -> DecoderResult<()> {
  68         let cb_elem = if is_yuv { 6 } else { 4 };
  69         let cb_size = (size - 4) / cb_elem;
  70         validate!(size - 4 == cb_size * cb_elem);
  71         validate!(cb_size <= 256);
  72         for i in 0..cb_size {
  73                                           br.read_buf(&mut cb[i][..cb_elem])?;
  74             if !is_yuv {
  75                 cb[i][4] = 0x80;
  76                 cb[i][5] = 0x80;
  77             } else {
  78                 cb[i][4] ^= 0x80;
  79                 cb[i][5] ^= 0x80;
  80             }
  81         }
  82         Ok(())
  83     }
  84     fn read_cb_upd(br: &mut ByteReader, size: usize, cb: &mut [[u8; 6]; 256], is_yuv: bool) -> DecoderResult<()> {
  85         let cb_elem = if is_yuv { 6 } else { 4 };
  86         let end = br.tell() + (size as u64) - 4;
  87         for i in (0..256).step_by(32) {
  88             if br.tell() >= end {
  89                 break;
  90             }
  91             let upd                     = br.read_u32be()?;
  92             for j in 0..32 {
  93                 if ((upd >> (31 - j)) & 1) != 0 {
  94                                           br.read_buf(&mut cb[i + j][..cb_elem])?;
  95                     if !is_yuv {
  96                         cb[i + j][4] = 0x80;
  97                         cb[i + j][5] = 0x80;
  98                     } else {
  99                         cb[i + j][4] ^= 0x80;
 100                         cb[i + j][5] ^= 0x80;
 101                     }
 102                 }
 103             }
 104         }
 105         validate!(br.tell() == end);
 106         Ok(())
 107     }
 108     fn decode_strip(&mut self, src: &[u8], is_intra: bool, is_intra_strip: bool, xoff: usize, yoff: usize, xend: usize, yend: usize, frm: &mut NASimpleVideoFrame<u8>) -> DecoderResult<()> {
 109         let mut mr = MemoryReader::new_read(src);
 110         let mut br = ByteReader::new(&mut mr);
 111         let mut idx_pos = 0;
 112         let mut idx_size = 0;
 113         let mut v1_only = false;
 114         while br.left() > 0 {
 115             let id                      = br.read_byte()?;
 116             if (id & 0xF0) == 0x20 && is_intra_strip {
 117                 validate!((id & 1) == 0);
 118             }
 119             let size                    = br.read_u24be()? as usize;
 120             validate!(size >= 4 && (size - 4 <= (br.left() as usize)));
 121             match id {
 122                 0x20 => Self::read_cb    (&mut br, size, &mut self.cb_v4, true)?,
 123                 0x21 => Self::read_cb_upd(&mut br, size, &mut self.cb_v4, true)?,
 124                 0x22 => Self::read_cb    (&mut br, size, &mut self.cb_v1, true)?,
 125                 0x23 => Self::read_cb_upd(&mut br, size, &mut self.cb_v1, true)?,
 126                 0x24 => Self::read_cb    (&mut br, size, &mut self.cb_v4, false)?,
 127                 0x25 => Self::read_cb_upd(&mut br, size, &mut self.cb_v4, false)?,
 128                 0x26 => Self::read_cb    (&mut br, size, &mut self.cb_v1, false)?,
 129                 0x27 => Self::read_cb_upd(&mut br, size, &mut self.cb_v1, false)?,
 130                 0x30 => { // intra indices
 131                     validate!(idx_pos == 0);
 132                     idx_pos = br.tell() as usize;
 133                     idx_size = size - 4;
 134                                           br.read_skip(idx_size)?;
 135                 },
 136                 0x31 => { // inter indices
 137                     validate!(!is_intra);
 138                     validate!(idx_pos == 0);
 139                     idx_pos = br.tell() as usize;
 140                     idx_size = size - 4;
 141                                           br.read_skip(idx_size)?;
 142                 },
 143                 0x32 => { // V1-only blocks
 144                     validate!(idx_pos == 0);
 145                     idx_pos = br.tell() as usize;
 146                     idx_size = size - 4;
 147                     v1_only = true;
 148                                           br.read_skip(idx_size)?;
 149                 },
 150                 _ => return Err(DecoderError::InvalidData),
 151             };
 152         }
 153         validate!(idx_pos != 0);
 154         let mut mr = MemoryReader::new_read(&src[idx_pos..][..idx_size]);
 155         let mut br = ByteReader::new(&mut mr);
 156
 157         let mut x = xoff;
 158         let mut y = yoff;
 159         let mut block = [0u8; 24];
 160         while br.left() > 0 {
 161             let mut flags = if !v1_only { br.read_u32be()? } else { 0x00000000 };
 162             let mut mask = 1 << 31;
 163             while mask > 0 {
 164                 if !is_intra {
 165                     let skip = (flags & mask) == 0;
 166                     mask >>= 1;
 167                     if skip {
 168                         x += 4;
 169                         if x >= xend {
 170                             x = xoff;
 171                             y += 4;
 172                             if y == yend {
 173                                 return Ok(());
 174                             }
 175                         }
 176                         continue;
 177                     }
 178                     if mask == 0 {
 179                         flags           = br.read_u32be()?;
 180                         mask = 1 << 31;
 181                     }
 182                 }
 183                 if (flags & mask) == 0 {
 184                     let idx         = br.read_byte()? as usize;
 185                     let cb = &self.cb_v1[idx];
 186                     block[ 0] = cb[0]; block[ 1] = cb[0]; block[ 2] = cb[1]; block[ 3] = cb[1];
 187                     block[ 4] = cb[0]; block[ 5] = cb[0]; block[ 6] = cb[1]; block[ 7] = cb[1];
 188                     block[ 8] = cb[2]; block[ 9] = cb[2]; block[10] = cb[3]; block[11] = cb[3];
 189                     block[12] = cb[2]; block[13] = cb[2]; block[14] = cb[3]; block[15] = cb[3];
 190                     block[16] = cb[4]; block[17] = cb[4];
 191                     block[18] = cb[4]; block[19] = cb[4];
 192                     block[20] = cb[5]; block[21] = cb[5];
 193                     block[22] = cb[5]; block[23] = cb[5];
 194                 } else {
 195                     let idx0        = br.read_byte()? as usize;
 196                     let cb0 = &self.cb_v4[idx0];
 197                     let idx1        = br.read_byte()? as usize;
 198                     let cb1 = &self.cb_v4[idx1];
 199                     let idx2        = br.read_byte()? as usize;
 200                     let cb2 = &self.cb_v4[idx2];
 201                     let idx3        = br.read_byte()? as usize;
 202                     let cb3 = &self.cb_v4[idx3];
 203                     block[ 0] = cb0[0]; block[ 1] = cb0[1]; block[ 2] = cb1[0]; block[ 3] = cb1[1];
 204                     block[ 4] = cb0[2]; block[ 5] = cb0[3]; block[ 6] = cb1[2]; block[ 7] = cb1[3];
 205                     block[ 8] = cb2[0]; block[ 9] = cb2[1]; block[10] = cb3[0]; block[11] = cb3[1];
 206                     block[12] = cb2[2]; block[13] = cb2[3]; block[14] = cb3[2]; block[15] = cb3[3];
 207                     block[16] = cb0[4]; block[17] = cb1[4];
 208                     block[18] = cb2[4]; block[19] = cb3[4];
 209                     block[20] = cb0[5]; block[21] = cb1[5];
 210                     block[22] = cb2[5]; block[23] = cb3[5];
 211                 }
 212                 mask >>= 1;
 213                 if self.mode == DecodeMode::YUV {
 214                     put_block(&block, x, y, frm);
 215                 } else {
 216                     put_block_gray(&block, x, y, frm);
 217                 }
 218                 x += 4;
 219                 if x >= xend {
 220                     x = xoff;
 221                     y += 4;
 222                     if y == yend {
 223                         return Ok(());
 224                     }
 225                 }
 226             }
 227         }
 228         Ok(())
 229     }
 230 }
 231
 232 impl NADecoder for CinepakDecoder {
 233     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 234         if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
 235             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 236             self.info = NACodecInfo::new_ref(info.get_name(), myinfo, None).into_ref();
 237             self.frmmgr.clear();
 238             Ok(())
 239         } else {
 240             Err(DecoderError::InvalidData)
 241         }
 242     }
 243     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 244         let src = pkt.get_buffer();
 245         if src.len() <= 10 { return Err(DecoderError::ShortData); }
 246
 247         let mut mr = MemoryReader::new_read(src.as_slice());
 248         let mut br = ByteReader::new(&mut mr);
 249
 250         let flags                       = br.read_byte()?;
 251         let size                        = br.read_u24be()? as usize;
 252         validate!(src.len() >= size);
 253         let width                       = br.read_u16be()? as usize;
 254         let height                      = br.read_u16be()? as usize;
 255         let nstrips                     = br.read_u16be()? as usize;
 256
 257         let is_intra = (flags & 1) == 0;
 258
 259         let mut mode = DecodeMode::Unknown;
 260                                           br.read_skip(1)?;
 261         let mut stripsize               = br.read_u24be()?;
 262                                           br.read_skip(8)?;
 263         while stripsize > 0 {
 264             let ctype                   = br.read_byte()?;
 265             let csize                   = br.read_u24be()?;
 266             match ctype {
 267                 0x20 | 0x21 | 0x22 | 0x23 => {
 268                     mode = DecodeMode::YUV;
 269                     break;
 270                 },
 271                 0x24 | 0x25 | 0x26 | 0x27 => {
 272                     mode = DecodeMode::Gray;
 273                     break;
 274                 },
 275                 _ => {
 276                                           br.read_skip(csize as usize)?;
 277                     validate!(stripsize >= csize);
 278                     stripsize -= csize;
 279                 },
 280             };
 281         }
 282         validate!(mode != DecodeMode::Unknown);
 283         br.seek(SeekFrom::Start(10))?;
 284         for sd in pkt.side_data.iter() {
 285             match *sd {
 286                 NASideData::Palette(_, _) => {
 287                     mode = DecodeMode::Palette;
 288                     break;
 289                 },
 290                 _ => {},
 291             };
 292         }
 293
 294         if let Some(ref vinfo) = self.info.get_properties().get_video_info() {
 295             if vinfo.width != width || vinfo.height != height || self.mode != mode {
 296                 validate!(is_intra);
 297                 let fmt = match mode {
 298                         DecodeMode::YUV     => YUV420_FORMAT,
 299                         DecodeMode::Gray    => NAPixelFormaton {
 300                                 model: ColorModel::YUV(YUVSubmodel::YUVJ),
 301                                 components: 1,
 302                                 comp_info: [Some(NAPixelChromaton{h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 0, next_elem: 1}), None, None, None, None],
 303                                 elem_size: 1,
 304                                 be: true,
 305                                 alpha: false,
 306                                 palette: false,
 307                             },
 308                         DecodeMode::Palette => PAL8_FORMAT,
 309                         _ => unreachable!(),
 310                     };
 311                 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(width, height, false, fmt));
 312                 self.info = NACodecInfo::new_ref(self.info.get_name(), myinfo, None).into_ref();
 313                 self.frmmgr.clear();
 314             }
 315         }
 316         let mut buf;
 317         if is_intra {
 318             let vinfo = self.info.get_properties().get_video_info().unwrap();
 319             let bufinfo = alloc_video_buffer(vinfo, 2)?;
 320             buf = bufinfo.get_vbuf().unwrap();
 321             self.mode = mode;
 322         } else {
 323             validate!(self.mode == mode);
 324             let bufret = self.frmmgr.clone_ref();
 325             if let Some(vbuf) = bufret {
 326                 buf = vbuf;
 327             } else {
 328                 return Err(DecoderError::MissingReference);
 329             }
 330         }
 331         if self.mode == DecodeMode::Palette {
 332             let paloff = buf.get_offset(1);
 333             let data = buf.get_data_mut().unwrap();
 334             let dpal = &mut data[paloff..];
 335             for sd in pkt.side_data.iter() {
 336                 match *sd {
 337                     NASideData::Palette(_, ref pal) => {
 338                         for (dst, src) in dpal.chunks_mut(3).zip(pal.chunks(4)) {
 339                             dst[0] = src[0];
 340                             dst[1] = src[1];
 341                             dst[2] = src[2];
 342                         }
 343                         break;
 344                     },
 345                     _ => {},
 346                 };
 347             }
 348         }
 349         let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap();
 350
 351         let mut last_y = 0;
 352         for i in 0..nstrips {
 353             let flags                   = br.read_byte()?;
 354             validate!(flags == 0x10 || flags == 0x11);
 355             let is_intra_strip = (flags & 1) == 0;
 356             let size                    = br.read_u24be()? as usize;
 357             validate!(size > 12 && (size - 4) <= (br.left() as usize));
 358             let yoff                    = br.read_u16be()? as usize;
 359             let xoff                    = br.read_u16be()? as usize;
 360             if xoff != 0 || yoff != 0 {
 361                 return Err(DecoderError::NotImplemented);
 362             }
 363             let yend                    = br.read_u16be()? as usize;
 364             let xend                    = br.read_u16be()? as usize;
 365             if i == 0 && is_intra && !is_intra_strip {
 366                 return Err(DecoderError::InvalidData);
 367             }
 368             let start = br.tell() as usize;
 369             let end = start + size - 12;
 370             let strip_data = &src[start..end];
 371             self.decode_strip(strip_data, is_intra, is_intra_strip, 0, last_y, xend, last_y + yend, &mut frm)?;
 372                                           br.read_skip(size - 12)?;
 373             last_y += yend;
 374         }
 375
 376         self.frmmgr.add_frame(buf.clone());
 377         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::Video(buf));
 378         frm.set_keyframe(is_intra);
 379         frm.set_frame_type(if is_intra { FrameType::I } else { FrameType::P });
 380         Ok(frm.into_ref())
 381     }
 382     fn flush(&mut self) {
 383         self.frmmgr.clear();
 384     }
 385 }
 386
 387 impl NAOptionHandler for CinepakDecoder {
 388     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 389     fn set_options(&mut self, _options: &[NAOption]) { }
 390     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 391 }
 392
 393 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
 394     Box::new(CinepakDecoder::new())
 395 }
 396
 397 #[cfg(test)]
 398 mod test {
 399     use nihav_core::codecs::RegisteredDecoders;
 400     use nihav_core::demuxers::RegisteredDemuxers;
 401     use nihav_codec_support::test::dec_video::*;
 402     use crate::generic_register_all_codecs;
 403     use crate::generic_register_all_demuxers;
 404     #[test]
 405     fn test_cinepak() {
 406         let mut dmx_reg = RegisteredDemuxers::new();
 407         generic_register_all_demuxers(&mut dmx_reg);
 408         let mut dec_reg = RegisteredDecoders::new();
 409         generic_register_all_codecs(&mut dec_reg);
 410         test_decoding("avi", "cinepak", "assets/Misc/ot171.avi", Some(10), &dmx_reg,
 411                      &dec_reg, ExpectedTestResult::MD5Frames(vec![
 412                         [0xd58326b0, 0xdbfc1dcc, 0x6d66a04c, 0x08a21bbb],
 413                         [0x9b2cb5c5, 0x69b5f261, 0xcaccaaaf, 0xff2a807d],
 414                         [0x55c322d5, 0xf76f81ce, 0x923ada8c, 0x4925a5c8],
 415                         [0x2d1a537a, 0x62233cb6, 0xc1d39c2f, 0xeec9ccf3],
 416                         [0xf3cc841d, 0x56603c01, 0x34f521cf, 0x61f8a0c9],
 417                         [0xd75c0802, 0x9e786186, 0xc7a05cdf, 0x52ddc59d],
 418                         [0xde19733b, 0x29633d17, 0x507e9f82, 0x94c09158],
 419                         [0x1ea11919, 0x133a282c, 0x8cee485c, 0x150cb3f4],
 420                         [0x55a6d8fb, 0x2ea287c0, 0x36b3083b, 0x954cfc64],
 421                         [0xfb8be1fb, 0x84ad10aa, 0xa00ee55c, 0x9e191e5b],
 422                         [0x9c090a08, 0x43071726, 0x26236b5a, 0x79595848]]));
 423     }
 424     #[test]
 425     fn test_cinepak_gray() {
 426         let mut dmx_reg = RegisteredDemuxers::new();
 427         generic_register_all_demuxers(&mut dmx_reg);
 428         let mut dec_reg = RegisteredDecoders::new();
 429         generic_register_all_codecs(&mut dec_reg);
 430         test_decoding("mov", "cinepak", "assets/Misc/dday.mov", Some(10), &dmx_reg,
 431                      &dec_reg, ExpectedTestResult::MD5Frames(vec![
 432                         [0x2ab229bc, 0xb71308aa, 0x979511c6, 0xcef3ea92],
 433                         [0x94f227d5, 0xbaa646ef, 0xab78f751, 0x8e1f50da],
 434                         [0x555de93a, 0x625e77f0, 0x95611bae, 0xbd715e9d],
 435                         [0xb31b9ba7, 0xba6327f8, 0x5698954f, 0xc16fad2a],
 436                         [0xda86ffb6, 0x58deb79d, 0x59f62c5b, 0x1bd2a2c5],
 437                         [0x2f46c7eb, 0x8950ac76, 0xbc68c470, 0x12e3247a],
 438                         [0x77d73950, 0xf76b28b0, 0x3552bb52, 0x38900a51],
 439                         [0xf4f45bef, 0x91146af2, 0xdcf4d44e, 0x713bf36e],
 440                         [0x8e06d350, 0x787f245e, 0x32426903, 0xf35f7dd3],
 441                         [0x0e35ebc1, 0xfdb6c520, 0x2bf484dc, 0xcec78b63],
 442                         [0xb8411fa4, 0x3a35f646, 0x85e8e04a, 0xfff58785]]));
 443     }
 444     #[test]
 445     fn test_cinepak_pal() {
 446         let mut dmx_reg = RegisteredDemuxers::new();
 447         generic_register_all_demuxers(&mut dmx_reg);
 448         let mut dec_reg = RegisteredDecoders::new();
 449         generic_register_all_codecs(&mut dec_reg);
 450         test_decoding("mov", "cinepak", "assets/Misc/catfight Tag team DT.mov", Some(10), &dmx_reg,
 451                      &dec_reg, ExpectedTestResult::MD5Frames(vec![
 452                         [0x3f7ec8ea, 0x873a2bc6, 0xcc58336e, 0xe88c4ffd],
 453                         [0x9665feab, 0xc035fb92, 0x5e4b8718, 0xd1c68877],
 454                         [0x804f8838, 0x7f4b126e, 0x9efab284, 0xee62d451],
 455                         [0xbb1930dd, 0x62d4a5d1, 0xca34d891, 0x31236269],
 456                         [0xc23ec739, 0xbe683ffd, 0xecbc337b, 0x73a96b63],
 457                         [0xa2fa75f2, 0x1dd937a8, 0x44e2074e, 0x1ac24467],
 458                         [0x9ba0f1e5, 0xadbe5357, 0x4cfa785b, 0x16181d41],
 459                         [0xe126c340, 0x6ceaac41, 0x64992bff, 0x8d4bc3c4],
 460                         [0xba6b2510, 0xc40c2b85, 0x1c7d0199, 0x333d4860],
 461                         [0x293fe1c2, 0x9f358a7e, 0x4fef6450, 0x8477a4ff],
 462                         [0x4509095a, 0x65575fdd, 0x3a17ecc4, 0x37821bf9]]));
 463     }
 464 }
 465