nihav-commonfmt/src/demuxers/mov.rs

   1 use nihav_core::demuxers::*;
   2 use nihav_registry::register::*;
   3 use nihav_core::compr::deflate::*;
   4
   5 macro_rules! mktag {
   6     ($a:expr, $b:expr, $c:expr, $d:expr) => ({
   7         (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
   8     });
   9     ($arr:expr) => ({
  10         (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
  11     });
  12 }
  13
  14 trait Skip64 {
  15     fn skip64(&mut self, size: u64) -> ByteIOResult<()>;
  16 }
  17
  18 impl<'a> Skip64 for ByteReader<'a> {
  19     fn skip64(&mut self, size: u64) -> ByteIOResult<()> {
  20         if (size as usize as u64) != size {
  21             self.seek(SeekFrom::Current(size as i64))?;
  22         } else {
  23             self.read_skip(size as usize)?;
  24         }
  25         Ok(())
  26     }
  27 }
  28
  29 fn read_chunk_header(br: &mut ByteReader) -> DemuxerResult<(u32, u64)> {
  30     let size            = br.read_u32be()?;
  31     let ctype           = br.read_u32be()?;
  32     if size == 0 {
  33         Ok((ctype, br.left() as u64))
  34     } else if size == 1 {
  35         let size64      = br.read_u64be()?;
  36         validate!(size64 >= 16);
  37         Ok((ctype, size64 - 16))
  38     } else {
  39         validate!(size >= 8);
  40         Ok((ctype, (size as u64) - 8))
  41     }
  42 }
  43
  44 fn read_palette(br: &mut ByteReader, size: u64, pal: &mut [u8; 1024]) -> DemuxerResult<u64> {
  45     let _seed           = br.read_u32be()?;
  46     let _flags          = br.read_u16be()?;
  47     let palsize         = (br.read_u16be()? as usize) + 1;
  48     validate!(palsize <= 256);
  49     validate!((palsize as u64) * 8 + 8 == size);
  50     for i in 0..palsize {
  51         let a           = br.read_u16be()?;
  52         let r           = br.read_u16be()?;
  53         let g           = br.read_u16be()?;
  54         let b           = br.read_u16be()?;
  55         pal[i * 4]     = (r >> 8) as u8;
  56         pal[i * 4 + 1] = (g >> 8) as u8;
  57         pal[i * 4 + 2] = (b >> 8) as u8;
  58         pal[i * 4 + 3] = (a >> 8) as u8;
  59     }
  60     Ok(size)
  61 }
  62
  63 struct RootChunkHandler {
  64     ctype:  u32,
  65     parse:  fn(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64>,
  66 }
  67
  68 struct TrackChunkHandler {
  69     ctype:  u32,
  70     parse:  fn(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64>,
  71 }
  72
  73 const IGNORED_CHUNKS: &[u32] = &[
  74     mktag!(b"free"), mktag!(b"skip"), mktag!(b"udta"), mktag!(b"wide")
  75 ];
  76
  77 const ROOT_CHUNK_HANDLERS: &[RootChunkHandler] = &[
  78     RootChunkHandler { ctype: mktag!(b"ftyp"), parse: read_ftyp },
  79     RootChunkHandler { ctype: mktag!(b"mdat"), parse: read_mdat },
  80     RootChunkHandler { ctype: mktag!(b"moov"), parse: read_moov },
  81 ];
  82
  83 macro_rules! read_chunk_list {
  84     (root; $name: expr, $fname: ident, $handlers: ident) => {
  85         fn $fname(&mut self, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<()> {
  86             self.depth += 1;
  87             validate!(self.depth < 32);
  88             let list_end = self.src.tell() + size;
  89             while self.src.tell() < list_end {
  90                 let ret = read_chunk_header(&mut self.src);
  91                 if ret.is_err() { break; }
  92                 let (ctype, size) = ret.unwrap();
  93                 if self.src.tell() + size > list_end {
  94                     break;
  95                 }
  96                 if IGNORED_CHUNKS.contains(&ctype) {
  97                     self.src.skip64(size)?;
  98                     continue;
  99                 }
 100                 let handler = $handlers.iter().find(|x| x.ctype == ctype);
 101                 let read_size;
 102                 if let Some(ref handler) = handler {
 103                     read_size = (handler.parse)(self, strmgr, size)?;
 104                 } else {
 105                     println!("skipping unknown chunk {:08X} size {}", ctype, size);
 106                     read_size = 0;
 107                 }
 108                 validate!(read_size <= size);
 109                 self.src.skip64(size - read_size)?;
 110             }
 111             self.depth -= 1;
 112             validate!(self.src.tell() == list_end);
 113             Ok(())
 114         }
 115     };
 116     (track; $name: expr, $fname: ident, $handlers: ident) => {
 117         fn $fname(&mut self, br: &mut ByteReader, size: u64) -> DemuxerResult<()> {
 118             self.depth += 1;
 119             validate!(self.depth < 32);
 120             let list_end = br.tell() + size;
 121             while br.tell() < list_end {
 122                 let ret = read_chunk_header(br);
 123                 if ret.is_err() { break; }
 124                 let (ctype, size) = ret.unwrap();
 125                 if br.tell() + size > list_end {
 126                     break;
 127                 }
 128                 if IGNORED_CHUNKS.contains(&ctype) {
 129                     br.skip64(size)?;
 130                     continue;
 131                 }
 132                 let handler = $handlers.iter().find(|x| x.ctype == ctype);
 133                 let read_size;
 134                 if let Some(ref handler) = handler {
 135                     read_size = (handler.parse)(self, br, size)?;
 136                 } else {
 137                     read_size = 0;
 138                 }
 139                 validate!(read_size <= size);
 140                 br.skip64(size - read_size)?;
 141             }
 142             self.depth -= 1;
 143             validate!(br.tell() == list_end);
 144             Ok(())
 145         }
 146     }
 147 }
 148
 149 fn skip_chunk(_track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 150     br.skip64(size)?;
 151     Ok(size)
 152 }
 153
 154 fn read_ftyp(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
 155     dmx.src.skip64(size)?;
 156     Ok(size)
 157 }
 158
 159 fn read_mdat(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
 160     dmx.mdat_pos  = dmx.src.tell();
 161     dmx.mdat_size = size;
 162     dmx.src.skip64(size)?;
 163     Ok(size)
 164 }
 165
 166 fn read_moov(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
 167     dmx.read_moov(strmgr, size)?;
 168     Ok(size)
 169 }
 170
 171 const MOOV_CHUNK_HANDLERS: &[RootChunkHandler] = &[
 172     RootChunkHandler { ctype: mktag!(b"mvhd"), parse: read_mvhd },
 173     RootChunkHandler { ctype: mktag!(b"cmov"), parse: read_cmov },
 174     RootChunkHandler { ctype: mktag!(b"ctab"), parse: read_ctab },
 175     RootChunkHandler { ctype: mktag!(b"trak"), parse: read_trak },
 176     RootChunkHandler { ctype: mktag!(b"meta"), parse: read_meta },
 177 ];
 178
 179 fn read_mvhd(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
 180     const KNOWN_MVHD_SIZE: u64 = 100;
 181     let br = &mut dmx.src;
 182     validate!(size >= KNOWN_MVHD_SIZE);
 183     let version             = br.read_byte()?;
 184     validate!(version == 0);
 185     let _flags              = br.read_u24be()?;
 186     let _ctime              = br.read_u32be()?;
 187     let _mtime              = br.read_u32be()?;
 188     let tscale              = br.read_u32be()?;
 189     let duration            = br.read_u32be()?;
 190     let _pref_rate          = br.read_u32be()?;
 191     let _pref_volume        = br.read_u16be()?;
 192                               br.read_skip(10)?;
 193                               br.read_skip(36)?; // matrix
 194     let _preview_time       = br.read_u32be()?;
 195     let _preview_duration   = br.read_u32be()?;
 196     let _poster_time        = br.read_u32be()?;
 197     let _sel_time           = br.read_u32be()?;
 198     let _sel_duration       = br.read_u32be()?;
 199     let _cur_time           = br.read_u32be()?;
 200     let _next_track_id      = br.read_u32be()?;
 201     dmx.duration = duration;
 202     dmx.tb_den = tscale;
 203
 204     Ok(KNOWN_MVHD_SIZE)
 205 }
 206
 207 fn read_cmov(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
 208     let br = &mut dmx.src;
 209     validate!(size > 24);
 210     let dcom_size           = br.read_u32be()?;
 211     let dcom_tag            = br.read_tag()?;
 212     let compr_type          = br.read_tag()?;
 213     validate!(&dcom_tag == b"dcom" && dcom_size == 12);
 214     if &compr_type != b"zlib" {
 215         return Err(DemuxerError::NotImplemented);
 216     }
 217     let cmvd_size           = u64::from(br.read_u32be()?);
 218     let cmvd_tag            = br.read_tag()?;
 219     validate!(&cmvd_tag == b"cmvd" && cmvd_size > 14 && cmvd_size == size - 12);
 220     let comp_size = (cmvd_size - 12) as usize;
 221     let uncomp_size         = br.read_u32be()? as usize;
 222     validate!(uncomp_size > 8);
 223     let mut sbuf = vec![0; comp_size];
 224     let mut dbuf = vec![0; uncomp_size];
 225                               br.read_buf(sbuf.as_mut_slice())?;
 226     let ret = Inflate::uncompress(sbuf.as_slice(), dbuf.as_mut_slice());
 227     if ret.is_err() {
 228         return Err(DemuxerError::InvalidData);
 229     }
 230     let len = ret.unwrap();
 231     validate!(len == uncomp_size);
 232     let mut mr = MemoryReader::new_read(dbuf.as_slice());
 233     let mut br = ByteReader::new(&mut mr);
 234     let (ctype, csize) = read_chunk_header(&mut br)?;
 235     validate!(ctype == mktag!(b"moov"));
 236     let mut ddmx = MOVDemuxer::new(&mut br);
 237     ddmx.read_moov(strmgr, csize)?;
 238     std::mem::swap(&mut dmx.tracks, &mut ddmx.tracks);
 239     dmx.duration = ddmx.duration;
 240     dmx.tb_den = ddmx.tb_den;
 241     std::mem::swap(&mut dmx.pal, &mut ddmx.pal);
 242
 243     Ok(size)
 244 }
 245
 246 fn read_ctab(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
 247     let mut pal = [0; 1024];
 248     let size = read_palette(&mut dmx.src, size, &mut pal)?;
 249     dmx.pal = Some(Arc::new(pal));
 250     Ok(size)
 251 }
 252
 253 fn read_meta(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
 254     dmx.src.skip64(size)?;
 255     Ok(size)
 256 }
 257
 258 fn read_trak(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
 259     let mut track = Track::new(dmx.cur_track as u32, dmx.tb_den);
 260     track.read_trak(&mut dmx.src, size)?;
 261     validate!(track.tkhd_found && track.stsd_found);
 262     validate!(strmgr.get_stream_by_id(track.track_id).is_none());
 263     dmx.cur_track += 1;
 264     let mut str = None;
 265     std::mem::swap(&mut track.stream, &mut str);
 266     if let Some(stream) = str {
 267         let str_id = strmgr.add_stream(stream).unwrap();
 268         track.track_str_id = str_id;
 269     }
 270     dmx.tracks.push(track);
 271     Ok(size)
 272 }
 273
 274 const TRAK_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
 275     TrackChunkHandler { ctype: mktag!(b"clip"), parse: skip_chunk },
 276     TrackChunkHandler { ctype: mktag!(b"matt"), parse: skip_chunk },
 277     TrackChunkHandler { ctype: mktag!(b"edts"), parse: skip_chunk },
 278     TrackChunkHandler { ctype: mktag!(b"tref"), parse: skip_chunk },
 279     TrackChunkHandler { ctype: mktag!(b"load"), parse: skip_chunk },
 280     TrackChunkHandler { ctype: mktag!(b"imap"), parse: skip_chunk },
 281     TrackChunkHandler { ctype: mktag!(b"tkhd"), parse: read_tkhd },
 282     TrackChunkHandler { ctype: mktag!(b"mdia"), parse: read_mdia },
 283 ];
 284
 285 fn read_tkhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 286     const KNOWN_TKHD_SIZE: u64 = 84;
 287     validate!(size >= KNOWN_TKHD_SIZE);
 288     let version             = br.read_byte()?;
 289     validate!(version == 0);
 290     let _flags              = br.read_u24be()?;
 291     let _ctime              = br.read_u32be()?;
 292     let _mtime              = br.read_u32be()?;
 293     let track_id            = br.read_u32be()?;
 294                               br.read_skip(4)?;
 295     let _duration           = br.read_u32be()?;
 296                               br.read_skip(8)?;
 297     let _layer              = br.read_u16be()?;
 298     let _alt_group          = br.read_u16be()?;
 299     let _volume             = br.read_u16be()?;
 300                               br.read_skip(2)?;
 301                               br.read_skip(36)?; // matrix
 302     let width               = br.read_u32be()? as usize;
 303     let height              = br.read_u32be()? as usize;
 304     track.width  = width  >> 16;
 305     track.height = height >> 16;
 306     track.track_id = track_id;
 307
 308     track.tkhd_found = true;
 309     Ok(KNOWN_TKHD_SIZE)
 310 }
 311
 312 fn read_mdia(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 313     track.stream_type = StreamType::None;
 314     track.read_mdia(br, size)?;
 315     Ok(size)
 316 }
 317
 318 const MDIA_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
 319     TrackChunkHandler { ctype: mktag!(b"mdhd"), parse: skip_chunk },
 320     TrackChunkHandler { ctype: mktag!(b"hdlr"), parse: read_hdlr },
 321     TrackChunkHandler { ctype: mktag!(b"minf"), parse: read_minf },
 322 ];
 323
 324 fn read_hdlr(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 325     const KNOWN_HDLR_SIZE: u64 = 24;
 326     validate!(size >= KNOWN_HDLR_SIZE);
 327     let version             = br.read_byte()?;
 328     validate!(version == 0);
 329     let flags               = br.read_u24be()?;
 330     validate!(flags == 0);
 331     let comp_type           = br.read_u32be()?;
 332     let comp_subtype        = br.read_u32be()?;
 333     let _comp_manufacturer  = br.read_u32be()?;
 334     let _comp_flags         = br.read_u32be()?;
 335     let _comp_flags_mask    = br.read_u32be()?;
 336
 337     if comp_type == mktag!(b"mhlr") {
 338         if comp_subtype == mktag!(b"vide") {
 339             track.stream_type = StreamType::Video;
 340         } else if comp_subtype == mktag!(b"soun") {
 341             track.stream_type = StreamType::Audio;
 342         } else {
 343             track.stream_type = StreamType::Data;
 344         }
 345     } else if comp_type == mktag!(b"dhlr") {
 346         track.stream_type = StreamType::Data;
 347     } else {
 348         println!("Unknown stream type");
 349         track.stream_type = StreamType::Data;
 350     }
 351
 352     Ok(KNOWN_HDLR_SIZE)
 353 }
 354
 355 fn read_minf(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 356     track.read_minf(br, size)?;
 357     Ok(size)
 358 }
 359
 360 const MINF_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
 361     TrackChunkHandler { ctype: mktag!(b"hdlr"), parse: skip_chunk },
 362     TrackChunkHandler { ctype: mktag!(b"dinf"), parse: skip_chunk },
 363     TrackChunkHandler { ctype: mktag!(b"vmhd"), parse: read_vmhd },
 364     TrackChunkHandler { ctype: mktag!(b"smhd"), parse: read_smhd },
 365     TrackChunkHandler { ctype: mktag!(b"gmhd"), parse: read_gmhd },
 366     TrackChunkHandler { ctype: mktag!(b"gmin"), parse: read_gmin },
 367     TrackChunkHandler { ctype: mktag!(b"stbl"), parse: read_stbl },
 368 ];
 369
 370 fn read_vmhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 371     const KNOWN_VMHD_SIZE: u64 = 12;
 372     validate!(track.stream_type == StreamType::Video);
 373     validate!(size >= KNOWN_VMHD_SIZE);
 374     let version             = br.read_byte()?;
 375     validate!(version == 0);
 376     let _flags              = br.read_u24be()?;
 377                               br.read_skip(2)?; // graphics mode
 378                               br.read_skip(6)?; // opcolor
 379     Ok(KNOWN_VMHD_SIZE)
 380 }
 381
 382 fn read_smhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 383     const KNOWN_SMHD_SIZE: u64 = 8;
 384     validate!(track.stream_type == StreamType::Audio);
 385     validate!(size >= KNOWN_SMHD_SIZE);
 386     let version             = br.read_byte()?;
 387     validate!(version == 0);
 388     let _flags              = br.read_u24be()?;
 389                               br.read_skip(2)?; // balance
 390                               br.read_skip(2)?;
 391     Ok(KNOWN_SMHD_SIZE)
 392 }
 393
 394 fn read_gmhd(track: &mut Track, _br: &mut ByteReader, _size: u64) -> DemuxerResult<u64> {
 395     validate!(track.stream_type == StreamType::Data);
 396     Ok(0)
 397 }
 398
 399 fn read_gmin(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 400     validate!(track.stream_type == StreamType::Data);
 401     const KNOWN_GMIN_SIZE: u64 = 16;
 402     validate!(size >= KNOWN_GMIN_SIZE);
 403     let version             = br.read_byte()?;
 404     validate!(version == 0);
 405     let _flags              = br.read_u24be()?;
 406                               br.read_skip(2)?; // graphics mode
 407                               br.read_skip(6)?; // opcolor
 408                               br.read_skip(2)?; // balance
 409                               br.read_skip(2)?;
 410     Ok(KNOWN_GMIN_SIZE)
 411 }
 412
 413 fn read_stbl(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 414     track.read_stbl(br, size)?;
 415     Ok(size)
 416 }
 417
 418 const STBL_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
 419     TrackChunkHandler { ctype: mktag!(b"stsd"), parse: read_stsd },
 420     TrackChunkHandler { ctype: mktag!(b"stts"), parse: skip_chunk },
 421     TrackChunkHandler { ctype: mktag!(b"stss"), parse: read_stss },
 422     TrackChunkHandler { ctype: mktag!(b"stsc"), parse: read_stsc },
 423     TrackChunkHandler { ctype: mktag!(b"stsz"), parse: read_stsz },
 424     TrackChunkHandler { ctype: mktag!(b"stco"), parse: read_stco },
 425     TrackChunkHandler { ctype: mktag!(b"stsh"), parse: skip_chunk },
 426 ];
 427
 428 fn parse_audio_edata(br: &mut ByteReader, start_pos: u64, size: u64) -> DemuxerResult<Option<Vec<u8>>> {
 429     let read_part = br.tell() - start_pos;
 430     if read_part + 8 < size {
 431         let csize           = br.read_u32be()? as u64;
 432         let ctag            = br.read_u32be()?;
 433         validate!(read_part + csize <= size);
 434         validate!(ctag == mktag!(b"wave"));
 435         if csize == 8 {
 436             return Ok(None);
 437         }
 438         let mut buf = [0; 8];
 439                               br.peek_buf(&mut buf)?;
 440         if &buf[4..8] == b"frma" {
 441                               br.read_skip(12)?;
 442             if csize > 20 {
 443                 let mut buf = vec![0; (csize - 20) as usize];
 444                               br.read_buf(&mut buf)?;
 445                 Ok(Some(buf))
 446             } else {
 447                 Ok(None)
 448             }
 449         } else if csize > 8 {
 450             let mut buf = vec![0; (csize as usize) - 8];
 451                               br.read_buf(&mut buf)?;
 452             Ok(Some(buf))
 453         } else {
 454             Ok(None)
 455         }
 456     } else {
 457         Ok(None)
 458     }
 459 }
 460
 461 fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 462     const KNOWN_STSD_SIZE: u64 = 24;
 463     validate!(size >= KNOWN_STSD_SIZE);
 464     let start_pos = br.tell();
 465     let version             = br.read_byte()?;
 466     validate!(version == 0);
 467     let _flags              = br.read_u24be()?;
 468     let entries             = br.read_u32be()?;
 469     validate!(entries > 0);
 470     let esize               = u64::from(br.read_u32be()?);
 471     validate!(esize + 8 <= size);
 472     let mut fcc = [0u8; 4];
 473                               br.read_buf(&mut fcc)?;
 474                               br.read_skip(6)?;
 475     let _data_ref           = br.read_u16be()?;
 476
 477     track.fcc = fcc;
 478
 479     let codec_info;
 480     match track.stream_type {
 481         StreamType::Video => {
 482             let _ver            = br.read_u16be()?;
 483             let _revision       = br.read_u16le()?;
 484             let _vendor         = br.read_u32be()?;
 485             let _temp_quality   = br.read_u32be()?;
 486             let _spat_quality   = br.read_u32be()?;
 487             let width           = br.read_u16be()? as usize;
 488             let height          = br.read_u16be()? as usize;
 489             let _hor_res        = br.read_u32be()?;
 490             let _vert_res       = br.read_u32be()?;
 491             let data_size       = br.read_u32be()?;
 492             validate!(data_size == 0);
 493             let _frame_count    = br.read_u16be()? as usize;
 494             let _cname_len      = br.read_byte()? as usize;
 495                                   br.read_skip(31)?; // actual compressor name
 496             let depth           = br.read_u16be()?;
 497             let ctable_id       = br.read_u16be()?;
 498             let grayscale = depth > 0x20 || depth == 1;
 499             let depth = if grayscale { depth & 0x1F } else { depth };
 500             validate!(depth <= 8 || (ctable_id == 0xFFFF));
 501             if ctable_id == 0 {
 502                 let max_pal_size = start_pos + size - br.tell();
 503                 let mut pal = [0; 1024];
 504                 read_palette(br, max_pal_size, &mut pal)?;
 505                 track.pal = Some(Arc::new(pal));
 506             } else if (depth <= 8) && !grayscale {
 507                 match depth & 0x1F {
 508                     2 => {
 509                         let mut pal = [0; 1024];
 510                         (&mut pal[..4 * 4]).copy_from_slice(&MOV_DEFAULT_PAL_2BIT);
 511                         track.pal = Some(Arc::new(pal));
 512                     },
 513                     4 => {
 514                         let mut pal = [0; 1024];
 515                         (&mut pal[..16 * 4]).copy_from_slice(&MOV_DEFAULT_PAL_4BIT);
 516                         track.pal = Some(Arc::new(pal));
 517                     },
 518                     8 => {
 519                         track.pal = Some(Arc::new(MOV_DEFAULT_PAL_8BIT));
 520                     },
 521                     _ => {},
 522                 };
 523             } else if grayscale && ctable_id != 0xFFFF {
 524                 let mut pal = [0; 1024];
 525                 let cdepth = depth & 0x1F;
 526                 let size = 1 << cdepth;
 527                 for i in 0..size {
 528                     let mut clr = ((size - 1 - i) as u8) << (8 - cdepth);
 529                     let mut off = 8 - cdepth;
 530                     while off >= cdepth {
 531                         clr |= clr >> (8 - off);
 532                         off -= cdepth;
 533                     }
 534                     if off > 0 {
 535                         clr |= clr >> (8 - off);
 536                     }
 537                     pal[i * 4]     = clr;
 538                     pal[i * 4 + 1] = clr;
 539                     pal[i * 4 + 2] = clr;
 540                 }
 541                 track.pal = Some(Arc::new(pal));
 542             }
 543 // todo other atoms, put as extradata
 544             let cname = if let Some(name) = find_codec_from_mov_video_fourcc(&fcc) {
 545                     name
 546                 } else if let Some(name) = find_codec_from_avi_fourcc(&fcc) {
 547                     name
 548                 } else {
 549                     "unknown"
 550                 };
 551             let format = if depth > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
 552             let mut vhdr = NAVideoInfo::new(width, height, false, format);
 553             vhdr.bits = depth as u8;
 554             let edata = if br.tell() - start_pos + 4 < size {
 555 //todo skip various common atoms
 556                     let edata_size  = br.read_u32be()? as usize;
 557                     let mut buf = vec![0; edata_size];
 558                                   br.read_buf(buf.as_mut_slice())?;
 559                     Some(buf)
 560                 } else {
 561                     None
 562                 };
 563             codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), edata);
 564         },
 565         StreamType::Audio => {
 566             let sver            = br.read_u16be()?;
 567             let _revision       = br.read_u16le()?;
 568             let _vendor         = br.read_u32be()?;
 569             let nchannels       = br.read_u16be()?;
 570             validate!(nchannels <= 64);
 571             let sample_size     = br.read_u16be()?;
 572             validate!(sample_size <= 128);
 573             let _compr_id       = br.read_u16be()?;
 574             let packet_size     = br.read_u16be()? as usize;
 575             validate!(packet_size == 0);
 576             let sample_rate     = br.read_u32be()?;
 577             validate!(sample_rate > 0);
 578             let cname = if let Some(name) = find_codec_from_mov_audio_fourcc(&fcc) {
 579                     name
 580                 } else if let (true, Some(name)) = ((fcc[0] == b'm' && fcc[1] == b's'),  find_codec_from_wav_twocc(u16::from(fcc[2]) * 256 + u16::from(fcc[3]))) {
 581                     name
 582                 } else {
 583                     "unknown"
 584                 };
 585 //todo adjust format for various PCM kinds
 586             let soniton = NASoniton::new(sample_size as u8, SONITON_FLAG_SIGNED | SONITON_FLAG_BE);
 587             let block_align = 1;
 588             if sver == 1 {
 589                 let samples_per_packet      = br.read_u32be()?;
 590                 let _bytes_per_packet       = br.read_u32be()?;
 591                 let bytes_per_frame         = br.read_u32be()?;
 592                 let _bytes_per_sample       = br.read_u32be()?;
 593                 track.bsize = bytes_per_frame as usize;
 594                 track.frame_samples = samples_per_packet as usize;
 595             } else {
 596                 track.bsize = sample_size as usize;
 597             }
 598             let ahdr = NAAudioInfo::new(sample_rate >> 16, nchannels as u8, soniton, block_align);
 599             let edata = parse_audio_edata(br, start_pos, size)?;
 600             codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
 601             track.channels  = nchannels as usize;
 602             track.bits      = sample_size as usize;
 603         },
 604         StreamType::None => {
 605             return Err(DemuxerError::InvalidData);
 606         },
 607         _ => {
 608 //todo put it all into extradata
 609             let edata = None;
 610             codec_info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
 611         },
 612     };
 613     let read_size = br.tell() - start_pos;
 614     validate!(read_size <= size);
 615     track.stream = Some(NAStream::new(track.stream_type, track.track_no, codec_info, 1, track.tb_den));
 616     track.stsd_found = true;
 617     Ok(read_size)
 618 }
 619
 620 fn read_stss(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 621     let version             = br.read_byte()?;
 622     validate!(version == 0);
 623     let _flags              = br.read_u24be()?;
 624     let entries             = br.read_u32be()? as usize;
 625     validate!(entries < ((std::u32::MAX >> 2) - 8) as usize);
 626     validate!((entries * 4 + 8) as u64 == size);
 627     track.keyframes = Vec::with_capacity(entries);
 628     let mut last_sample_no = 0;
 629     for _ in 0..entries {
 630         let sample_no       = br.read_u32be()?;
 631         validate!(sample_no > last_sample_no);
 632         track.keyframes.push(sample_no);
 633         last_sample_no = sample_no;
 634     }
 635     Ok(size)
 636 }
 637
 638 fn read_stsc(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 639     let version             = br.read_byte()?;
 640     validate!(version == 0);
 641     let _flags              = br.read_u24be()?;
 642     let entries             = br.read_u32be()? as usize;
 643     validate!(entries < ((std::u32::MAX / 12) - 8) as usize);
 644     validate!((entries * 12 + 8) as u64 == size);
 645     track.sample_map = Vec::with_capacity(entries);
 646     let mut last_sample_no = 0;
 647     for _i in 0..entries {
 648         let sample_no       = br.read_u32be()?;
 649         validate!(sample_no > last_sample_no);
 650         let nsamples        = br.read_u32be()?;
 651         let _sample_desc    = br.read_u32be()?;
 652         track.sample_map.push((sample_no, nsamples));
 653         last_sample_no = sample_no;
 654     }
 655     Ok(size)
 656 }
 657
 658 fn read_stsz(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 659     let version             = br.read_byte()?;
 660     validate!(version == 0);
 661     let _flags              = br.read_u24be()?;
 662     let sample_size         = br.read_u32be()?;
 663     if sample_size != 0 {
 664         track.sample_size = sample_size;
 665         if track.sample_size != 1 || track.bsize == 0 {
 666             track.bsize = sample_size as usize;
 667         }
 668         Ok(8)
 669     } else {
 670         let entries             = br.read_u32be()? as usize;
 671         validate!((entries * 4 + 12) as u64 == size);
 672         track.chunk_sizes = Vec::with_capacity(entries);
 673         for _ in 0..entries {
 674             let sample_size     = br.read_u32be()?;
 675             track.chunk_sizes.push(sample_size);
 676         }
 677         Ok(size)
 678     }
 679 }
 680
 681 fn read_stco(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
 682     let version             = br.read_byte()?;
 683     validate!(version == 0);
 684     let _flags              = br.read_u24be()?;
 685     let entries             = br.read_u32be()? as usize;
 686     validate!((entries * 4 + 8) as u64 == size);
 687     track.chunk_offsets = Vec::with_capacity(entries);
 688     for _i in 0..entries {
 689         let sample_offset   = br.read_u32be()?;
 690         track.chunk_offsets.push(u64::from(sample_offset));
 691     }
 692     Ok(size)
 693 }
 694
 695 struct MOVDemuxer<'a> {
 696     src:            &'a mut ByteReader<'a>,
 697     depth:          usize,
 698     mdat_pos:       u64,
 699     mdat_size:      u64,
 700     tracks:         Vec<Track>,
 701     cur_track:      usize,
 702     tb_den:         u32,
 703     duration:       u32,
 704     pal:            Option<Arc<[u8; 1024]>>,
 705 }
 706
 707 struct Track {
 708     track_id:       u32,
 709     track_str_id:   usize,
 710     track_no:       u32,
 711     tb_den:         u32,
 712     depth:          u8,
 713     tkhd_found:     bool,
 714     stsd_found:     bool,
 715     stream_type:    StreamType,
 716     width:          usize,
 717     height:         usize,
 718     channels:       usize,
 719     bits:           usize,
 720     bsize:          usize,
 721     fcc:            [u8; 4],
 722     keyframes:      Vec<u32>,
 723     chunk_sizes:    Vec<u32>,
 724     chunk_offsets:  Vec<u64>,
 725     sample_map:     Vec<(u32, u32)>,
 726     sample_size:    u32,
 727     frame_samples:  usize,
 728     stream:         Option<NAStream>,
 729     cur_chunk:      usize,
 730     cur_sample:     usize,
 731     samples_left:   usize,
 732     last_offset:    u64,
 733     pal:            Option<Arc<[u8; 1024]>>,
 734 }
 735
 736 impl Track {
 737     fn new(track_no: u32, tb_den: u32) -> Self {
 738         Self {
 739             tkhd_found:     false,
 740             stsd_found:     false,
 741             track_id:       0,
 742             track_str_id:   0,
 743             track_no,
 744             tb_den,
 745             stream_type:    StreamType::None,
 746             width:          0,
 747             height:         0,
 748             channels:       0,
 749             bits:           0,
 750             bsize:          0,
 751             fcc:            [0; 4],
 752             keyframes:      Vec::new(),
 753             chunk_sizes:    Vec::new(),
 754             chunk_offsets:  Vec::new(),
 755             sample_map:     Vec::new(),
 756             sample_size:    0,
 757             frame_samples:  0,
 758             stream:         None,
 759             depth:          0,
 760             cur_chunk:      0,
 761             cur_sample:     0,
 762             samples_left:   0,
 763             last_offset:    0,
 764             pal:            None,
 765         }
 766     }
 767     read_chunk_list!(track; "trak", read_trak, TRAK_CHUNK_HANDLERS);
 768     read_chunk_list!(track; "mdia", read_mdia, MDIA_CHUNK_HANDLERS);
 769     read_chunk_list!(track; "minf", read_minf, MINF_CHUNK_HANDLERS);
 770     read_chunk_list!(track; "stbl", read_stbl, STBL_CHUNK_HANDLERS);
 771     fn fill_seek_index(&self, seek_index: &mut SeekIndex) {
 772         if !self.keyframes.is_empty() {
 773             seek_index.mode = SeekIndexMode::Present;
 774         }
 775         for kf_time in self.keyframes.iter() {
 776             let pts = u64::from(*kf_time - 1);
 777             let time = NATimeInfo::ts_to_time(pts, 1000, 1, self.tb_den);
 778             let idx = (*kf_time - 1) as usize;
 779             if idx < self.chunk_offsets.len() {
 780                 let pos = self.chunk_offsets[idx];
 781                 seek_index.add_entry(self.track_no as u32, SeekEntry { time, pts, pos });
 782             }
 783         }
 784     }
 785     fn calculate_chunk_size(&self, nsamp: usize) -> usize {
 786         if nsamp == 0 {
 787             self.bsize
 788         } else {
 789             match &self.fcc {
 790                 b"NONE" | b"raw " | b"twos" | b"sowt" => {
 791                     (nsamp * self.bits * self.channels + 7) >> 3
 792                 },
 793                 b"ima4" => {
 794                     let nblocks = (nsamp + 63) >> 6;
 795                     nblocks * 34 * self.channels
 796                 },
 797                 b"MAC3" => {
 798                     (nsamp + 5) / 6 * 2 * self.channels
 799                 },
 800                 b"MAC6" => {
 801                     (nsamp + 5) / 6 * self.channels
 802                 },
 803                 b"in24" => nsamp * 3 * self.channels,
 804                 b"in32" | b"fl32" => nsamp * 4 * self.channels,
 805                 b"fl64" => nsamp * 8 * self.channels,
 806                 b"ulaw" | b"alaw" => nsamp,
 807                 b"ms\x00\x02" => { //MS ADPCM
 808                     ((nsamp - 1) / 2 + 7) * self.channels
 809                 },
 810                 b"ms\x00\x21" => { //IMA ADPCM
 811                     (nsamp / 2 + 4) * self.channels
 812                 },
 813                 _ => self.bsize,
 814             }
 815         }
 816     }
 817     fn get_next_chunk(&mut self) -> Option<(NATimeInfo, u64, usize)> {
 818         let pts = NATimeInfo::new(Some(self.cur_sample as u64), None, None, 1, self.tb_den);
 819 //todo dts decoding
 820         if self.chunk_offsets.len() == self.chunk_sizes.len() { // simple one-to-one mapping
 821             if self.cur_sample >= self.chunk_sizes.len() {
 822                 return None;
 823             }
 824             let offset = self.chunk_offsets[self.cur_sample];
 825             let size   = self.chunk_sizes[self.cur_sample] as usize;
 826             self.cur_sample += 1;
 827             Some((pts, offset, size))
 828         } else {
 829             if self.samples_left == 0 {
 830                 if self.cur_chunk >= self.chunk_offsets.len() {
 831                     return None;
 832                 }
 833                 for (idx, samples) in self.sample_map.iter() {
 834                     if *idx as usize <= self.cur_chunk + 1 {
 835                         self.samples_left = *samples as usize;
 836                     } else {
 837                         break;
 838                     }
 839                 }
 840                 self.last_offset = self.chunk_offsets[self.cur_chunk];
 841                 self.cur_chunk += 1;
 842             }
 843             let offset = self.last_offset;
 844             let size = self.get_size(self.cur_sample);
 845             self.last_offset += size as u64;
 846             if self.stream_type == StreamType::Video {
 847                 self.samples_left -= 1;
 848             } else if self.frame_samples != 0 {
 849                 self.samples_left -= self.frame_samples.min(self.samples_left);
 850             } else {
 851                 self.samples_left = 0;
 852             }
 853             self.cur_sample += 1;
 854             Some((pts, offset, size))
 855         }
 856     }
 857     fn get_size(&self, sample_no: usize) -> usize {
 858         if !self.chunk_sizes.is_empty() {
 859             self.chunk_sizes[sample_no] as usize
 860         } else if !self.sample_map.is_empty() {
 861             let mut nsamp = 0;
 862             for (idx, samples) in self.sample_map.iter() {
 863                 if *idx as usize <= self.cur_chunk {
 864                     nsamp = *samples;
 865                 } else {
 866                     break;
 867                 }
 868             }
 869             self.calculate_chunk_size(nsamp as usize)
 870         } else {
 871             self.bsize
 872         }
 873     }
 874     fn seek(&mut self, pts: u64) {
 875         self.cur_sample = pts as usize;
 876         self.samples_left = 0;
 877         if self.stream_type == StreamType::Audio {
 878             self.cur_chunk = self.cur_sample;
 879         } else if self.chunk_offsets.len() != self.chunk_sizes.len() && !self.sample_map.is_empty() {
 880             let mut csamp = 0;
 881             self.cur_chunk = 0;
 882             let mut cmap = self.sample_map.iter();
 883             let mut cur_samps = 0;
 884             let (mut next_idx, mut next_samples) = cmap.next().unwrap();
 885             loop {
 886                 if self.cur_chunk == next_idx as usize {
 887                     self.samples_left = cur_samps;
 888                     cur_samps = next_samples as usize;
 889                     if let Some((new_idx, new_samples)) = cmap.next() {
 890                         next_idx = *new_idx;
 891                         next_samples = *new_samples;
 892                     }
 893                 }
 894                 csamp += cur_samps;
 895                 if csamp >= self.cur_sample {
 896                     self.last_offset = self.chunk_offsets[self.cur_chunk];
 897                     break;
 898                 }
 899                 self.cur_chunk += 1;
 900             }
 901             csamp -= cur_samps;
 902             for sample_no in csamp..self.cur_chunk {
 903                 self.last_offset += self.get_size(sample_no) as u64;
 904             }
 905             self.samples_left = self.cur_sample - csamp - cur_samps;
 906         }
 907     }
 908 }
 909
 910 impl<'a> DemuxCore<'a> for MOVDemuxer<'a> {
 911     fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
 912         self.read_root(strmgr)?;
 913         validate!(self.mdat_pos > 0);
 914         validate!(!self.tracks.is_empty());
 915         for track in self.tracks.iter() {
 916             track.fill_seek_index(seek_index);
 917         }
 918         self.src.seek(SeekFrom::Start(self.mdat_pos))?;
 919         self.cur_track = 0;
 920         Ok(())
 921     }
 922
 923     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
 924         if self.tracks.is_empty() {
 925             return Err(DemuxerError::EOF);
 926         }
 927         for _ in 0..self.tracks.len() {
 928             if self.cur_track >= self.tracks.len() {
 929                 self.cur_track = 0;
 930             }
 931             let track = &mut self.tracks[self.cur_track];
 932             self.cur_track += 1;
 933             let first = track.cur_sample == 0;
 934             if let Some((pts, offset, size)) = track.get_next_chunk() {
 935                 let str = strmgr.get_stream(track.track_str_id);
 936                 if str.is_none() { return Err(DemuxerError::InvalidData); }
 937                 let stream = str.unwrap();
 938                 self.src.seek(SeekFrom::Start(offset))?;
 939                 let mut pkt = self.src.read_packet(stream, pts, false, size)?;
 940                 if let Some(ref pal) = track.pal {
 941                     let side_data = NASideData::Palette(first, pal.clone());
 942                     pkt.add_side_data(side_data);
 943                 }
 944                 return Ok(pkt);
 945             }
 946         }
 947         Err(DemuxerError::EOF)
 948     }
 949
 950     fn seek(&mut self, time: u64, seek_index: &SeekIndex) -> DemuxerResult<()> {
 951         let ret = seek_index.find_pos(time);
 952         if ret.is_none() {
 953             return Err(DemuxerError::SeekError);
 954         }
 955         let seek_info = ret.unwrap();
 956         for track in self.tracks.iter_mut() {
 957             track.seek(seek_info.pts);
 958         }
 959         Ok(())
 960     }
 961 }
 962
 963 impl<'a> NAOptionHandler for MOVDemuxer<'a> {
 964     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 965     fn set_options(&mut self, _options: &[NAOption]) { }
 966     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 967 }
 968
 969 impl<'a> MOVDemuxer<'a> {
 970     fn new(io: &'a mut ByteReader<'a>) -> Self {
 971         MOVDemuxer {
 972             src:            io,
 973             depth:          0,
 974             mdat_pos:       0,
 975             mdat_size:      0,
 976             tracks:         Vec::with_capacity(2),
 977             cur_track:      0,
 978             tb_den:         0,
 979             duration:       0,
 980             pal:            None,
 981         }
 982     }
 983     fn read_root(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
 984         self.depth = 0;
 985         while self.src.left() != 0 {
 986             let ret = read_chunk_header(&mut self.src);
 987             if ret.is_err() { break; }
 988             let (ctype, size) = ret.unwrap();
 989             if IGNORED_CHUNKS.contains(&ctype) {
 990                 self.src.skip64(size)?;
 991                 continue;
 992             }
 993             let handler = ROOT_CHUNK_HANDLERS.iter().find(|x| x.ctype == ctype);
 994             let read_size;
 995             if let Some(ref handler) = handler {
 996                 read_size = (handler.parse)(self, strmgr, size)?;
 997             } else {
 998                 println!("skipping unknown chunk {:08X} size {}", ctype, size);
 999                 read_size = 0;
1000             }
1001             validate!(read_size <= size);
1002             self.src.skip64(size - read_size)?;
1003         }
1004 //todo check if all needed chunks are found
1005         Ok(())
1006     }
1007     read_chunk_list!(root; "moov", read_moov, MOOV_CHUNK_HANDLERS);
1008 }
1009
1010 pub struct MOVDemuxerCreator { }
1011
1012 impl DemuxerCreator for MOVDemuxerCreator {
1013     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1014         Box::new(MOVDemuxer::new(br))
1015     }
1016     fn get_name(&self) -> &'static str { "mov" }
1017 }
1018
1019 const MOV_DEFAULT_PAL_2BIT: [u8; 4 * 4] = [
1020     0x93, 0x65, 0x5E, 0x00,
1021     0xFF, 0xFF, 0xFF, 0x00,
1022     0xDF, 0xD0, 0xAB, 0x00,
1023     0x00, 0x00, 0x00, 0x00
1024 ];
1025 const MOV_DEFAULT_PAL_4BIT: [u8; 16 * 4] = [
1026     0xFF, 0xFB, 0xFF, 0x00,
1027     0xEF, 0xD9, 0xBB, 0x00,
1028     0xE8, 0xC9, 0xB1, 0x00,
1029     0x93, 0x65, 0x5E, 0x00,
1030     0xFC, 0xDE, 0xE8, 0x00,
1031     0x9D, 0x88, 0x91, 0x00,
1032     0xFF, 0xFF, 0xFF, 0x00,
1033     0xFF, 0xFF, 0xFF, 0x00,
1034     0xFF, 0xFF, 0xFF, 0x00,
1035     0x47, 0x48, 0x37, 0x00,
1036     0x7A, 0x5E, 0x55, 0x00,
1037     0xDF, 0xD0, 0xAB, 0x00,
1038     0xFF, 0xFB, 0xF9, 0x00,
1039     0xE8, 0xCA, 0xC5, 0x00,
1040     0x8A, 0x7C, 0x77, 0x00,
1041     0x00, 0x00, 0x00, 0x00
1042 ];
1043 const MOV_DEFAULT_PAL_8BIT: [u8; 256 * 4] = [
1044     0xFF, 0xFF, 0xFF, 0x00,
1045     0xFF, 0xFF, 0xCC, 0x00,
1046     0xFF, 0xFF, 0x99, 0x00,
1047     0xFF, 0xFF, 0x66, 0x00,
1048     0xFF, 0xFF, 0x33, 0x00,
1049     0xFF, 0xFF, 0x00, 0x00,
1050     0xFF, 0xCC, 0xFF, 0x00,
1051     0xFF, 0xCC, 0xCC, 0x00,
1052     0xFF, 0xCC, 0x99, 0x00,
1053     0xFF, 0xCC, 0x66, 0x00,
1054     0xFF, 0xCC, 0x33, 0x00,
1055     0xFF, 0xCC, 0x00, 0x00,
1056     0xFF, 0x99, 0xFF, 0x00,
1057     0xFF, 0x99, 0xCC, 0x00,
1058     0xFF, 0x99, 0x99, 0x00,
1059     0xFF, 0x99, 0x66, 0x00,
1060     0xFF, 0x99, 0x33, 0x00,
1061     0xFF, 0x99, 0x00, 0x00,
1062     0xFF, 0x66, 0xFF, 0x00,
1063     0xFF, 0x66, 0xCC, 0x00,
1064     0xFF, 0x66, 0x99, 0x00,
1065     0xFF, 0x66, 0x66, 0x00,
1066     0xFF, 0x66, 0x33, 0x00,
1067     0xFF, 0x66, 0x00, 0x00,
1068     0xFF, 0x33, 0xFF, 0x00,
1069     0xFF, 0x33, 0xCC, 0x00,
1070     0xFF, 0x33, 0x99, 0x00,
1071     0xFF, 0x33, 0x66, 0x00,
1072     0xFF, 0x33, 0x33, 0x00,
1073     0xFF, 0x33, 0x00, 0x00,
1074     0xFF, 0x00, 0xFF, 0x00,
1075     0xFF, 0x00, 0xCC, 0x00,
1076     0xFF, 0x00, 0x99, 0x00,
1077     0xFF, 0x00, 0x66, 0x00,
1078     0xFF, 0x00, 0x33, 0x00,
1079     0xFF, 0x00, 0x00, 0x00,
1080     0xCC, 0xFF, 0xFF, 0x00,
1081     0xCC, 0xFF, 0xCC, 0x00,
1082     0xCC, 0xFF, 0x99, 0x00,
1083     0xCC, 0xFF, 0x66, 0x00,
1084     0xCC, 0xFF, 0x33, 0x00,
1085     0xCC, 0xFF, 0x00, 0x00,
1086     0xCC, 0xCC, 0xFF, 0x00,
1087     0xCC, 0xCC, 0xCC, 0x00,
1088     0xCC, 0xCC, 0x99, 0x00,
1089     0xCC, 0xCC, 0x66, 0x00,
1090     0xCC, 0xCC, 0x33, 0x00,
1091     0xCC, 0xCC, 0x00, 0x00,
1092     0xCC, 0x99, 0xFF, 0x00,
1093     0xCC, 0x99, 0xCC, 0x00,
1094     0xCC, 0x99, 0x99, 0x00,
1095     0xCC, 0x99, 0x66, 0x00,
1096     0xCC, 0x99, 0x33, 0x00,
1097     0xCC, 0x99, 0x00, 0x00,
1098     0xCC, 0x66, 0xFF, 0x00,
1099     0xCC, 0x66, 0xCC, 0x00,
1100     0xCC, 0x66, 0x99, 0x00,
1101     0xCC, 0x66, 0x66, 0x00,
1102     0xCC, 0x66, 0x33, 0x00,
1103     0xCC, 0x66, 0x00, 0x00,
1104     0xCC, 0x33, 0xFF, 0x00,
1105     0xCC, 0x33, 0xCC, 0x00,
1106     0xCC, 0x33, 0x99, 0x00,
1107     0xCC, 0x33, 0x66, 0x00,
1108     0xCC, 0x33, 0x33, 0x00,
1109     0xCC, 0x33, 0x00, 0x00,
1110     0xCC, 0x00, 0xFF, 0x00,
1111     0xCC, 0x00, 0xCC, 0x00,
1112     0xCC, 0x00, 0x99, 0x00,
1113     0xCC, 0x00, 0x66, 0x00,
1114     0xCC, 0x00, 0x33, 0x00,
1115     0xCC, 0x00, 0x00, 0x00,
1116     0x99, 0xFF, 0xFF, 0x00,
1117     0x99, 0xFF, 0xCC, 0x00,
1118     0x99, 0xFF, 0x99, 0x00,
1119     0x99, 0xFF, 0x66, 0x00,
1120     0x99, 0xFF, 0x33, 0x00,
1121     0x99, 0xFF, 0x00, 0x00,
1122     0x99, 0xCC, 0xFF, 0x00,
1123     0x99, 0xCC, 0xCC, 0x00,
1124     0x99, 0xCC, 0x99, 0x00,
1125     0x99, 0xCC, 0x66, 0x00,
1126     0x99, 0xCC, 0x33, 0x00,
1127     0x99, 0xCC, 0x00, 0x00,
1128     0x99, 0x99, 0xFF, 0x00,
1129     0x99, 0x99, 0xCC, 0x00,
1130     0x99, 0x99, 0x99, 0x00,
1131     0x99, 0x99, 0x66, 0x00,
1132     0x99, 0x99, 0x33, 0x00,
1133     0x99, 0x99, 0x00, 0x00,
1134     0x99, 0x66, 0xFF, 0x00,
1135     0x99, 0x66, 0xCC, 0x00,
1136     0x99, 0x66, 0x99, 0x00,
1137     0x99, 0x66, 0x66, 0x00,
1138     0x99, 0x66, 0x33, 0x00,
1139     0x99, 0x66, 0x00, 0x00,
1140     0x99, 0x33, 0xFF, 0x00,
1141     0x99, 0x33, 0xCC, 0x00,
1142     0x99, 0x33, 0x99, 0x00,
1143     0x99, 0x33, 0x66, 0x00,
1144     0x99, 0x33, 0x33, 0x00,
1145     0x99, 0x33, 0x00, 0x00,
1146     0x99, 0x00, 0xFF, 0x00,
1147     0x99, 0x00, 0xCC, 0x00,
1148     0x99, 0x00, 0x99, 0x00,
1149     0x99, 0x00, 0x66, 0x00,
1150     0x99, 0x00, 0x33, 0x00,
1151     0x99, 0x00, 0x00, 0x00,
1152     0x66, 0xFF, 0xFF, 0x00,
1153     0x66, 0xFF, 0xCC, 0x00,
1154     0x66, 0xFF, 0x99, 0x00,
1155     0x66, 0xFF, 0x66, 0x00,
1156     0x66, 0xFF, 0x33, 0x00,
1157     0x66, 0xFF, 0x00, 0x00,
1158     0x66, 0xCC, 0xFF, 0x00,
1159     0x66, 0xCC, 0xCC, 0x00,
1160     0x66, 0xCC, 0x99, 0x00,
1161     0x66, 0xCC, 0x66, 0x00,
1162     0x66, 0xCC, 0x33, 0x00,
1163     0x66, 0xCC, 0x00, 0x00,
1164     0x66, 0x99, 0xFF, 0x00,
1165     0x66, 0x99, 0xCC, 0x00,
1166     0x66, 0x99, 0x99, 0x00,
1167     0x66, 0x99, 0x66, 0x00,
1168     0x66, 0x99, 0x33, 0x00,
1169     0x66, 0x99, 0x00, 0x00,
1170     0x66, 0x66, 0xFF, 0x00,
1171     0x66, 0x66, 0xCC, 0x00,
1172     0x66, 0x66, 0x99, 0x00,
1173     0x66, 0x66, 0x66, 0x00,
1174     0x66, 0x66, 0x33, 0x00,
1175     0x66, 0x66, 0x00, 0x00,
1176     0x66, 0x33, 0xFF, 0x00,
1177     0x66, 0x33, 0xCC, 0x00,
1178     0x66, 0x33, 0x99, 0x00,
1179     0x66, 0x33, 0x66, 0x00,
1180     0x66, 0x33, 0x33, 0x00,
1181     0x66, 0x33, 0x00, 0x00,
1182     0x66, 0x00, 0xFF, 0x00,
1183     0x66, 0x00, 0xCC, 0x00,
1184     0x66, 0x00, 0x99, 0x00,
1185     0x66, 0x00, 0x66, 0x00,
1186     0x66, 0x00, 0x33, 0x00,
1187     0x66, 0x00, 0x00, 0x00,
1188     0x33, 0xFF, 0xFF, 0x00,
1189     0x33, 0xFF, 0xCC, 0x00,
1190     0x33, 0xFF, 0x99, 0x00,
1191     0x33, 0xFF, 0x66, 0x00,
1192     0x33, 0xFF, 0x33, 0x00,
1193     0x33, 0xFF, 0x00, 0x00,
1194     0x33, 0xCC, 0xFF, 0x00,
1195     0x33, 0xCC, 0xCC, 0x00,
1196     0x33, 0xCC, 0x99, 0x00,
1197     0x33, 0xCC, 0x66, 0x00,
1198     0x33, 0xCC, 0x33, 0x00,
1199     0x33, 0xCC, 0x00, 0x00,
1200     0x33, 0x99, 0xFF, 0x00,
1201     0x33, 0x99, 0xCC, 0x00,
1202     0x33, 0x99, 0x99, 0x00,
1203     0x33, 0x99, 0x66, 0x00,
1204     0x33, 0x99, 0x33, 0x00,
1205     0x33, 0x99, 0x00, 0x00,
1206     0x33, 0x66, 0xFF, 0x00,
1207     0x33, 0x66, 0xCC, 0x00,
1208     0x33, 0x66, 0x99, 0x00,
1209     0x33, 0x66, 0x66, 0x00,
1210     0x33, 0x66, 0x33, 0x00,
1211     0x33, 0x66, 0x00, 0x00,
1212     0x33, 0x33, 0xFF, 0x00,
1213     0x33, 0x33, 0xCC, 0x00,
1214     0x33, 0x33, 0x99, 0x00,
1215     0x33, 0x33, 0x66, 0x00,
1216     0x33, 0x33, 0x33, 0x00,
1217     0x33, 0x33, 0x00, 0x00,
1218     0x33, 0x00, 0xFF, 0x00,
1219     0x33, 0x00, 0xCC, 0x00,
1220     0x33, 0x00, 0x99, 0x00,
1221     0x33, 0x00, 0x66, 0x00,
1222     0x33, 0x00, 0x33, 0x00,
1223     0x33, 0x00, 0x00, 0x00,
1224     0x00, 0xFF, 0xFF, 0x00,
1225     0x00, 0xFF, 0xCC, 0x00,
1226     0x00, 0xFF, 0x99, 0x00,
1227     0x00, 0xFF, 0x66, 0x00,
1228     0x00, 0xFF, 0x33, 0x00,
1229     0x00, 0xFF, 0x00, 0x00,
1230     0x00, 0xCC, 0xFF, 0x00,
1231     0x00, 0xCC, 0xCC, 0x00,
1232     0x00, 0xCC, 0x99, 0x00,
1233     0x00, 0xCC, 0x66, 0x00,
1234     0x00, 0xCC, 0x33, 0x00,
1235     0x00, 0xCC, 0x00, 0x00,
1236     0x00, 0x99, 0xFF, 0x00,
1237     0x00, 0x99, 0xCC, 0x00,
1238     0x00, 0x99, 0x99, 0x00,
1239     0x00, 0x99, 0x66, 0x00,
1240     0x00, 0x99, 0x33, 0x00,
1241     0x00, 0x99, 0x00, 0x00,
1242     0x00, 0x66, 0xFF, 0x00,
1243     0x00, 0x66, 0xCC, 0x00,
1244     0x00, 0x66, 0x99, 0x00,
1245     0x00, 0x66, 0x66, 0x00,
1246     0x00, 0x66, 0x33, 0x00,
1247     0x00, 0x66, 0x00, 0x00,
1248     0x00, 0x33, 0xFF, 0x00,
1249     0x00, 0x33, 0xCC, 0x00,
1250     0x00, 0x33, 0x99, 0x00,
1251     0x00, 0x33, 0x66, 0x00,
1252     0x00, 0x33, 0x33, 0x00,
1253     0x00, 0x33, 0x00, 0x00,
1254     0x00, 0x00, 0xFF, 0x00,
1255     0x00, 0x00, 0xCC, 0x00,
1256     0x00, 0x00, 0x99, 0x00,
1257     0x00, 0x00, 0x66, 0x00,
1258     0x00, 0x00, 0x33, 0x00,
1259     0xEE, 0x00, 0x00, 0x00,
1260     0xDD, 0x00, 0x00, 0x00,
1261     0xBB, 0x00, 0x00, 0x00,
1262     0xAA, 0x00, 0x00, 0x00,
1263     0x88, 0x00, 0x00, 0x00,
1264     0x77, 0x00, 0x00, 0x00,
1265     0x55, 0x00, 0x00, 0x00,
1266     0x44, 0x00, 0x00, 0x00,
1267     0x22, 0x00, 0x00, 0x00,
1268     0x11, 0x00, 0x00, 0x00,
1269     0x00, 0xEE, 0x00, 0x00,
1270     0x00, 0xDD, 0x00, 0x00,
1271     0x00, 0xBB, 0x00, 0x00,
1272     0x00, 0xAA, 0x00, 0x00,
1273     0x00, 0x88, 0x00, 0x00,
1274     0x00, 0x77, 0x00, 0x00,
1275     0x00, 0x55, 0x00, 0x00,
1276     0x00, 0x44, 0x00, 0x00,
1277     0x00, 0x22, 0x00, 0x00,
1278     0x00, 0x11, 0x00, 0x00,
1279     0x00, 0x00, 0xEE, 0x00,
1280     0x00, 0x00, 0xDD, 0x00,
1281     0x00, 0x00, 0xBB, 0x00,
1282     0x00, 0x00, 0xAA, 0x00,
1283     0x00, 0x00, 0x88, 0x00,
1284     0x00, 0x00, 0x77, 0x00,
1285     0x00, 0x00, 0x55, 0x00,
1286     0x00, 0x00, 0x44, 0x00,
1287     0x00, 0x00, 0x22, 0x00,
1288     0x00, 0x00, 0x11, 0x00,
1289     0xEE, 0xEE, 0xEE, 0x00,
1290     0xDD, 0xDD, 0xDD, 0x00,
1291     0xBB, 0xBB, 0xBB, 0x00,
1292     0xAA, 0xAA, 0xAA, 0x00,
1293     0x88, 0x88, 0x88, 0x00,
1294     0x77, 0x77, 0x77, 0x00,
1295     0x55, 0x55, 0x55, 0x00,
1296     0x44, 0x44, 0x44, 0x00,
1297     0x22, 0x22, 0x22, 0x00,
1298     0x11, 0x11, 0x11, 0x00,
1299     0x00, 0x00, 0x00, 0x00
1300 ];
1301
1302 #[cfg(test)]
1303 mod test {
1304     use super::*;
1305     use std::fs::File;
1306
1307     #[test]
1308     fn test_mov_demux() {
1309         let mut file = File::open("assets/Indeo/cubes.mov").unwrap();
1310         let mut fr = FileReader::new_read(&mut file);
1311         let mut br = ByteReader::new(&mut fr);
1312         let mut dmx = MOVDemuxer::new(&mut br);
1313         let mut sm = StreamManager::new();
1314         let mut si = SeekIndex::new();
1315         dmx.open(&mut sm, &mut si).unwrap();
1316
1317         loop {
1318             let pktres = dmx.get_frame(&mut sm);
1319             if let Err(e) = pktres {
1320                 if e == DemuxerError::EOF { break; }
1321                 panic!("error");
1322             }
1323             let pkt = pktres.unwrap();
1324             println!("Got {}", pkt);
1325         }
1326     }
1327 }