1 use nihav_core::demuxers::*;
2 use nihav_registry::register::*;
3 use nihav_core::compr::deflate::*;
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)
10 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
15 fn skip64(&mut self, size: u64) -> ByteIOResult<()>;
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))?;
23 self.read_skip(size as usize)?;
29 fn read_chunk_header(br: &mut ByteReader) -> DemuxerResult<(u32, u64)> {
30 let size = br.read_u32be()?;
31 let ctype = br.read_u32be()?;
33 Ok((ctype, br.left() as u64))
35 let size64 = br.read_u64be()?;
36 validate!(size64 >= 16);
37 Ok((ctype, size64 - 16))
40 Ok((ctype, (size as u64) - 8))
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!(flags == 0 || flags == 0x4000 || flags == 0x8000);
50 validate!((palsize as u64) * 8 + 8 <= size);
52 let a = br.read_u16be()?;
53 let r = br.read_u16be()?;
54 let g = br.read_u16be()?;
55 let b = br.read_u16be()?;
56 pal[i * 4] = (r >> 8) as u8;
57 pal[i * 4 + 1] = (g >> 8) as u8;
58 pal[i * 4 + 2] = (b >> 8) as u8;
60 pal[i * 4 + 3] = (a >> 8) as u8;
69 struct RootChunkHandler {
71 parse: fn(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64>,
74 struct TrackChunkHandler {
76 parse: fn(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64>,
79 const IGNORED_CHUNKS: &[u32] = &[
80 mktag!(b"free"), mktag!(b"skip"), mktag!(b"udta"), mktag!(b"wide")
83 const ROOT_CHUNK_HANDLERS: &[RootChunkHandler] = &[
84 RootChunkHandler { ctype: mktag!(b"ftyp"), parse: read_ftyp },
85 RootChunkHandler { ctype: mktag!(b"mdat"), parse: read_mdat },
86 RootChunkHandler { ctype: mktag!(b"moov"), parse: read_moov },
87 RootChunkHandler { ctype: mktag!(b"moof"), parse: read_moof },
88 RootChunkHandler { ctype: mktag!(b"sidx"), parse: read_sidx },
91 fn print_cname(ctype: u32, size: u64, off: u64, depth: u8) {
92 for _ in 0..depth { print!(" "); }
93 let tag = [(ctype >> 24) as u8, (ctype >> 16) as u8, (ctype >> 8) as u8, ctype as u8];
94 let mut printable = true;
95 for ch in tag.iter() {
96 if !(0x20..=0x7F).contains(ch) {
102 print!(" '{}{}{}{}'", tag[0] as char, tag[1] as char, tag[2] as char, tag[3] as char);
104 print!(" {:08X}", ctype);
106 println!(" size {} @ {:X}", size, off);
109 macro_rules! read_chunk_list {
110 (root; $name: expr, $fname: ident, $handlers: ident) => {
111 fn $fname(&mut self, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<()> {
113 validate!(self.depth < 32);
114 let list_end = self.src.tell() + size;
115 while self.src.tell() < list_end {
116 let ret = read_chunk_header(self.src);
117 if ret.is_err() { break; }
118 let (ctype, size) = ret.unwrap();
119 if self.print_chunks {
120 print_cname(ctype, size, self.src.tell(), self.depth as u8);
122 if self.src.tell() + size > list_end {
125 if IGNORED_CHUNKS.contains(&ctype) {
126 self.src.skip64(size)?;
129 let handler = $handlers.iter().find(|x| x.ctype == ctype);
131 if let Some(ref handler) = handler {
132 read_size = (handler.parse)(self, strmgr, size)?;
134 println!("skipping unknown chunk {:08X} size {}", ctype, size);
137 validate!(read_size <= size);
138 self.src.skip64(size - read_size)?;
141 validate!(self.src.tell() == list_end);
145 (track; $name: expr, $fname: ident, $handlers: ident) => {
146 fn $fname(&mut self, br: &mut ByteReader, size: u64) -> DemuxerResult<()> {
148 validate!(self.depth < 32);
149 let list_end = br.tell() + size;
150 while br.tell() < list_end {
151 let ret = read_chunk_header(br);
152 if ret.is_err() { break; }
153 let (ctype, size) = ret.unwrap();
154 if self.print_chunks {
155 print_cname(ctype, size, br.tell(), self.depth + 1);
157 if br.tell() + size > list_end {
160 if IGNORED_CHUNKS.contains(&ctype) {
164 let handler = $handlers.iter().find(|x| x.ctype == ctype);
166 if let Some(ref handler) = handler {
167 read_size = (handler.parse)(self, br, size)?;
171 validate!(read_size <= size);
172 br.skip64(size - read_size)?;
175 validate!(br.tell() == list_end);
181 fn skip_chunk(_track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
186 fn read_ftyp(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
187 dmx.src.skip64(size)?;
191 fn read_mdat(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
192 dmx.mdat_pos = dmx.src.tell();
193 dmx.mdat_size = size;
194 dmx.src.skip64(size)?;
198 fn read_sidx(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64) -> DemuxerResult<u64> {
202 fn read_moov(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
203 dmx.read_moov(strmgr, size)?;
207 const MOOV_CHUNK_HANDLERS: &[RootChunkHandler] = &[
208 RootChunkHandler { ctype: mktag!(b"mvhd"), parse: read_mvhd },
209 RootChunkHandler { ctype: mktag!(b"cmov"), parse: read_cmov },
210 RootChunkHandler { ctype: mktag!(b"ctab"), parse: read_ctab },
211 RootChunkHandler { ctype: mktag!(b"trak"), parse: read_trak },
212 RootChunkHandler { ctype: mktag!(b"meta"), parse: read_meta },
213 RootChunkHandler { ctype: mktag!(b"mvex"), parse: read_mvex },
214 RootChunkHandler { ctype: mktag!(b"iods"), parse: skip_chunk_mov },
217 fn read_mvhd(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
218 const KNOWN_MVHD_SIZE: u64 = 100;
219 let br = &mut dmx.src;
220 validate!(size >= KNOWN_MVHD_SIZE);
221 let version = br.read_byte()?;
222 validate!(version == 0);
223 let _flags = br.read_u24be()?;
224 let _ctime = br.read_u32be()?;
225 let _mtime = br.read_u32be()?;
226 let tscale = br.read_u32be()?;
227 let duration = br.read_u32be()?;
228 let _pref_rate = br.read_u32be()?;
229 let _pref_volume = br.read_u16be()?;
231 br.read_skip(36)?; // matrix
232 let _preview_time = br.read_u32be()?;
233 let _preview_duration = br.read_u32be()?;
234 let _poster_time = br.read_u32be()?;
235 let _sel_time = br.read_u32be()?;
236 let _sel_duration = br.read_u32be()?;
237 let _cur_time = br.read_u32be()?;
238 let _next_track_id = br.read_u32be()?;
239 dmx.duration = duration;
245 fn read_cmov(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
246 let br = &mut dmx.src;
247 validate!(size > 24);
248 let dcom_size = br.read_u32be()?;
249 let dcom_tag = br.read_tag()?;
250 let compr_type = br.read_tag()?;
251 validate!(&dcom_tag == b"dcom" && dcom_size == 12);
252 if &compr_type != b"zlib" {
253 return Err(DemuxerError::NotImplemented);
255 let cmvd_size = u64::from(br.read_u32be()?);
256 let cmvd_tag = br.read_tag()?;
257 validate!(&cmvd_tag == b"cmvd" && cmvd_size > 14 && cmvd_size == size - 12);
258 let comp_size = (cmvd_size - 12) as usize;
259 let uncomp_size = br.read_u32be()? as usize;
260 validate!(uncomp_size > 8);
261 let mut sbuf = vec![0; comp_size];
262 let mut dbuf = vec![0; uncomp_size];
263 br.read_buf(sbuf.as_mut_slice())?;
264 let ret = Inflate::uncompress(sbuf.as_slice(), dbuf.as_mut_slice());
266 return Err(DemuxerError::InvalidData);
268 let len = ret.unwrap();
269 validate!(len == uncomp_size);
270 let mut mr = MemoryReader::new_read(dbuf.as_slice());
271 let mut br = ByteReader::new(&mut mr);
272 let (ctype, csize) = read_chunk_header(&mut br)?;
273 validate!(ctype == mktag!(b"moov"));
274 let mut ddmx = MOVDemuxer::new(&mut br);
275 ddmx.print_chunks = dmx.print_chunks;
276 ddmx.read_moov(strmgr, csize)?;
277 std::mem::swap(&mut dmx.tracks, &mut ddmx.tracks);
278 dmx.duration = ddmx.duration;
279 dmx.tb_den = ddmx.tb_den;
280 std::mem::swap(&mut dmx.pal, &mut ddmx.pal);
285 fn read_ctab(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
286 let mut pal = [0; 1024];
287 let size = read_palette(dmx.src, size, &mut pal)?;
288 dmx.pal = Some(Arc::new(pal));
292 fn read_meta(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
293 dmx.src.skip64(size)?;
297 fn read_mvex(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64) -> DemuxerResult<u64> {
301 fn skip_chunk_mov(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64) -> DemuxerResult<u64> {
305 fn read_trak(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
306 let mut track = Track::new(dmx.cur_track as u32, dmx.tb_den);
307 track.print_chunks = dmx.print_chunks;
308 track.read_trak(dmx.src, size)?;
309 validate!(track.tkhd_found && track.stsd_found);
310 validate!(strmgr.get_stream_by_id(track.track_id).is_none());
312 dmx.tracks.push(track);
316 fn read_moof(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
317 dmx.moof_off = dmx.src.tell() - 8;
318 dmx.read_moof(strmgr, size)?;
322 const MOOF_CHUNK_HANDLERS: &[RootChunkHandler] = &[
323 RootChunkHandler { ctype: mktag!(b"mfhd"), parse: read_mfhd },
324 RootChunkHandler { ctype: mktag!(b"traf"), parse: read_traf },
325 RootChunkHandler { ctype: mktag!(b"meta"), parse: read_meta },
328 fn read_mfhd(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
329 const KNOWN_MFHD_SIZE: u64 = 8;
330 validate!(size >= KNOWN_MFHD_SIZE);
331 let version = dmx.src.read_byte()?;
332 validate!(version == 0);
333 let flags = dmx.src.read_u24be()?;
334 validate!(flags == 0);
335 let _seq_no = dmx.src.read_u32be()?;
340 fn read_traf(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
341 let mut buf = [0u8; 16];
342 dmx.src.peek_buf(&mut buf)?;
343 validate!(&buf[4..8] == b"tfhd");
344 let track_id = read_u32be(&buf[12..16])?;
345 let mut track = None;
346 for trk in dmx.tracks.iter_mut() {
347 if trk.track_id == track_id {
352 if let Some(track) = track {
353 track.moof_off = dmx.moof_off;
354 track.read_traf(dmx.src, size)?;
361 const TRAK_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
362 TrackChunkHandler { ctype: mktag!(b"clip"), parse: skip_chunk },
363 TrackChunkHandler { ctype: mktag!(b"matt"), parse: skip_chunk },
364 TrackChunkHandler { ctype: mktag!(b"edts"), parse: skip_chunk },
365 TrackChunkHandler { ctype: mktag!(b"tref"), parse: skip_chunk },
366 TrackChunkHandler { ctype: mktag!(b"load"), parse: skip_chunk },
367 TrackChunkHandler { ctype: mktag!(b"imap"), parse: skip_chunk },
368 TrackChunkHandler { ctype: mktag!(b"tkhd"), parse: read_tkhd },
369 TrackChunkHandler { ctype: mktag!(b"mdia"), parse: read_mdia },
372 fn read_tkhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
373 const KNOWN_TKHD_SIZE: u64 = 84;
374 validate!(size >= KNOWN_TKHD_SIZE);
375 let version = br.read_byte()?;
376 validate!(version == 0);
377 let _flags = br.read_u24be()?;
378 let _ctime = br.read_u32be()?;
379 let _mtime = br.read_u32be()?;
380 let track_id = br.read_u32be()?;
382 let duration = br.read_u32be()?;
384 let _layer = br.read_u16be()?;
385 let _alt_group = br.read_u16be()?;
386 let _volume = br.read_u16be()?;
388 br.read_skip(36)?; // matrix
389 let width = br.read_u32be()? as usize;
390 let height = br.read_u32be()? as usize;
391 track.width = width >> 16;
392 track.height = height >> 16;
393 track.track_id = track_id;
394 track.duration = duration;
396 track.tkhd_found = true;
400 fn read_mdia(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
401 track.stream_type = StreamType::None;
402 track.read_mdia(br, size)?;
406 const MDIA_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
407 TrackChunkHandler { ctype: mktag!(b"mdhd"), parse: read_mdhd },
408 TrackChunkHandler { ctype: mktag!(b"hdlr"), parse: read_hdlr },
409 TrackChunkHandler { ctype: mktag!(b"minf"), parse: read_minf },
412 fn read_mdhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
413 const KNOWN_MDHD_SIZE: u64 = 24;
414 validate!(size >= KNOWN_MDHD_SIZE);
415 let version = br.read_byte()?;
416 validate!(version == 0);
417 let flags = br.read_u24be()?;
418 validate!(flags == 0);
419 let _ctime = br.read_u32be()?;
420 let _mtime = br.read_u32be()?;
421 track.tb_den = br.read_u32be()?;
422 validate!(track.tb_den != 0);
423 track.duration = br.read_u32be()?;
424 let _language = br.read_u16be()?;
425 let _quality = br.read_u16be()?;
430 fn read_hdlr(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
431 const KNOWN_HDLR_SIZE: u64 = 24;
432 validate!(size >= KNOWN_HDLR_SIZE);
433 let version = br.read_byte()?;
434 validate!(version == 0);
435 let flags = br.read_u24be()?;
436 validate!(flags == 0);
437 let comp_type = br.read_u32be()?;
438 let comp_subtype = br.read_u32be()?;
439 let _comp_manufacturer = br.read_u32be()?;
440 let _comp_flags = br.read_u32be()?;
441 let _comp_flags_mask = br.read_u32be()?;
443 if comp_type == mktag!(b"mhlr") || comp_type == 0 {
444 if comp_subtype == mktag!(b"vide") {
445 track.stream_type = StreamType::Video;
446 } else if comp_subtype == mktag!(b"soun") {
447 track.stream_type = StreamType::Audio;
449 track.stream_type = StreamType::Data;
451 } else if comp_type == mktag!(b"dhlr") {
452 track.stream_type = StreamType::Data;
454 println!("Unknown stream type");
455 track.stream_type = StreamType::Data;
461 fn read_minf(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
462 track.read_minf(br, size)?;
466 const MINF_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
467 TrackChunkHandler { ctype: mktag!(b"hdlr"), parse: skip_chunk },
468 TrackChunkHandler { ctype: mktag!(b"dinf"), parse: skip_chunk },
469 TrackChunkHandler { ctype: mktag!(b"vmhd"), parse: read_vmhd },
470 TrackChunkHandler { ctype: mktag!(b"smhd"), parse: read_smhd },
471 TrackChunkHandler { ctype: mktag!(b"gmhd"), parse: read_gmhd },
472 TrackChunkHandler { ctype: mktag!(b"gmin"), parse: read_gmin },
473 TrackChunkHandler { ctype: mktag!(b"stbl"), parse: read_stbl },
476 fn read_vmhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
477 const KNOWN_VMHD_SIZE: u64 = 12;
478 validate!(track.stream_type == StreamType::Video);
479 validate!(size >= KNOWN_VMHD_SIZE);
480 let version = br.read_byte()?;
481 validate!(version == 0);
482 let _flags = br.read_u24be()?;
483 br.read_skip(2)?; // graphics mode
484 br.read_skip(6)?; // opcolor
488 fn read_smhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
489 const KNOWN_SMHD_SIZE: u64 = 8;
490 validate!(track.stream_type == StreamType::Audio);
491 validate!(size >= KNOWN_SMHD_SIZE);
492 let version = br.read_byte()?;
493 validate!(version == 0);
494 let _flags = br.read_u24be()?;
495 br.read_skip(2)?; // balance
500 fn read_gmhd(track: &mut Track, _br: &mut ByteReader, _size: u64) -> DemuxerResult<u64> {
501 validate!(track.stream_type == StreamType::Data);
505 fn read_gmin(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
506 validate!(track.stream_type == StreamType::Data);
507 const KNOWN_GMIN_SIZE: u64 = 16;
508 validate!(size >= KNOWN_GMIN_SIZE);
509 let version = br.read_byte()?;
510 validate!(version == 0);
511 let _flags = br.read_u24be()?;
512 br.read_skip(2)?; // graphics mode
513 br.read_skip(6)?; // opcolor
514 br.read_skip(2)?; // balance
519 fn read_stbl(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
520 track.read_stbl(br, size)?;
524 const STBL_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
525 TrackChunkHandler { ctype: mktag!(b"stsd"), parse: read_stsd },
526 TrackChunkHandler { ctype: mktag!(b"stts"), parse: read_stts },
527 TrackChunkHandler { ctype: mktag!(b"stss"), parse: read_stss },
528 TrackChunkHandler { ctype: mktag!(b"stsc"), parse: read_stsc },
529 TrackChunkHandler { ctype: mktag!(b"stsz"), parse: read_stsz },
530 TrackChunkHandler { ctype: mktag!(b"stco"), parse: read_stco },
531 TrackChunkHandler { ctype: mktag!(b"stsh"), parse: skip_chunk },
532 TrackChunkHandler { ctype: mktag!(b"ctts"), parse: read_ctts },
535 fn parse_audio_edata(br: &mut ByteReader, start_pos: u64, size: u64) -> DemuxerResult<Option<Vec<u8>>> {
536 let read_part = br.tell() - start_pos;
537 if read_part + 8 < size {
538 let mut buf = [0; 8];
539 br.peek_buf(&mut buf)?;
540 if &buf[4..8] != b"wave" {
541 let mut buf = vec![0; (size - read_part) as usize];
542 br.read_buf(&mut buf)?;
543 return Ok(Some(buf));
546 let csize = br.read_u32be()? as u64;
547 let ctag = br.read_u32be()?;
548 validate!(read_part + csize <= size);
549 validate!(ctag == mktag!(b"wave"));
553 let mut buf = [0; 8];
554 br.peek_buf(&mut buf)?;
555 if &buf[4..8] == b"frma" {
558 let mut buf = vec![0; (csize - 20) as usize];
559 br.read_buf(&mut buf)?;
564 } else if csize > 8 {
565 let mut buf = vec![0; (csize as usize) - 8];
566 br.read_buf(&mut buf)?;
576 #[allow(clippy::neg_cmp_op_on_partial_ord)]
577 fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
578 const KNOWN_STSD_SIZE: u64 = 24;
579 validate!(size >= KNOWN_STSD_SIZE);
580 let start_pos = br.tell();
581 let version = br.read_byte()?;
582 validate!(version == 0);
583 let _flags = br.read_u24be()?;
584 let entries = br.read_u32be()?;
585 validate!(entries > 0);
586 let esize = u64::from(br.read_u32be()?);
587 validate!(esize + 8 <= size);
588 let mut fcc = [0u8; 4];
589 br.read_buf(&mut fcc)?;
591 let _data_ref = br.read_u16be()?;
596 match track.stream_type {
597 StreamType::Video => {
598 let _ver = br.read_u16be()?;
599 let _revision = br.read_u16le()?;
600 let _vendor = br.read_u32be()?;
601 let _temp_quality = br.read_u32be()?;
602 let _spat_quality = br.read_u32be()?;
603 let width = br.read_u16be()? as usize;
604 let height = br.read_u16be()? as usize;
605 let _hor_res = br.read_u32be()?;
606 let _vert_res = br.read_u32be()?;
607 let data_size = br.read_u32be()?;
608 validate!(data_size == 0);
609 let _frame_count = br.read_u16be()? as usize;
610 let _cname_len = br.read_byte()? as usize;
611 br.read_skip(31)?; // actual compressor name
612 let depth = br.read_u16be()?;
613 let ctable_id = br.read_u16be()?;
614 let grayscale = depth > 0x20 || depth == 1;
615 let depth = if grayscale { depth & 0x1F } else { depth };
617 let max_pal_size = start_pos + size - br.tell();
619 let mut pal = [0; 1024];
620 read_palette(br, max_pal_size, &mut pal)?;
621 track.pal = Some(Arc::new(pal));
623 br.read_skip(max_pal_size as usize)?;
625 } else if (depth <= 8) && !grayscale {
628 let mut pal = [0; 1024];
629 pal[..4 * 4].copy_from_slice(&MOV_DEFAULT_PAL_2BIT);
630 track.pal = Some(Arc::new(pal));
633 let mut pal = [0; 1024];
634 pal[..16 * 4].copy_from_slice(&MOV_DEFAULT_PAL_4BIT);
635 track.pal = Some(Arc::new(pal));
638 track.pal = Some(Arc::new(MOV_DEFAULT_PAL_8BIT));
642 } else if grayscale && ctable_id != 0xFFFF {
643 let mut pal = [0; 1024];
644 let cdepth = depth & 0x1F;
645 let size = 1 << cdepth;
647 let mut clr = ((size - 1 - i) as u8) << (8 - cdepth);
648 let mut off = 8 - cdepth;
649 while off >= cdepth {
650 clr |= clr >> (8 - off);
654 clr |= clr >> (8 - off);
657 pal[i * 4 + 1] = clr;
658 pal[i * 4 + 2] = clr;
660 track.pal = Some(Arc::new(pal));
662 // todo other atoms, put as extradata
663 let cname = if let Some(name) = find_codec_from_mov_video_fourcc(&fcc) {
665 } else if let Some(name) = find_codec_from_avi_fourcc(&fcc) {
670 let format = if depth > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
671 let mut vhdr = NAVideoInfo::new(width, height, false, format);
672 vhdr.bits = depth as u8;
673 //skip various common atoms
674 while br.tell() - start_pos + 4 < size {
675 let mut buf = [0u8; 8];
676 br.peek_buf(&mut buf)?;
677 let tsize = read_u32be(&buf).unwrap() as usize;
678 let tag = &buf[4..8];
679 validate!(tsize >= 8);
681 b"pasp" | b"clap" => {
682 br.read_skip(tsize)?;
687 let edata = if br.tell() - start_pos + 4 < size {
688 let edata_size = br.read_u32be()? as usize;
689 validate!(edata_size >= 4);
690 let mut buf = vec![0; edata_size - 4];
691 br.read_buf(buf.as_mut_slice())?;
696 codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), edata);
698 StreamType::Audio => {
699 let sver = br.read_u16be()?;
700 let _revision = br.read_u16le()?;
701 let _vendor = br.read_u32be()?;
702 let mut nchannels = br.read_u16be()?;
704 validate!(nchannels <= 64);
706 let sample_size = br.read_u16be()?;
707 validate!(sample_size <= 128);
708 let _compr_id = br.read_u16be()?;
709 let packet_size = br.read_u16be()? as usize;
710 validate!(packet_size == 0);
711 let mut sample_rate = br.read_u32be()? >> 16;
713 validate!(sample_rate > 0);
715 let cname = if let Some(name) = find_codec_from_mov_audio_fourcc(&fcc) {
717 } 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]))) {
722 let mut soniton = NASoniton::new(sample_size as u8, SONITON_FLAG_SIGNED | SONITON_FLAG_BE);
723 if &fcc == b"raw " && sample_size == 8 {
724 soniton.signed = false;
729 let samples_per_packet = br.read_u32be()?;
730 let _bytes_per_packet = br.read_u32be()?;
731 let bytes_per_frame = br.read_u32be()?;
732 let _bytes_per_sample = br.read_u32be()?;
733 track.bsize = bytes_per_frame as usize;
734 track.frame_samples = samples_per_packet as usize;
735 track.tb_num = samples_per_packet;
738 br.read_u32be()?; // some size
739 let srate = br.read_f64be()?;
740 validate!(srate > 1.0);
741 sample_rate = srate as u32;
742 let channels = br.read_u32be()?;
743 validate!(channels > 0 && channels < 255);
744 nchannels = channels as u16;
745 br.read_u32be()?; // always 0x7F000000
746 let _bits_per_csample = br.read_u32be()?;
747 let _codec_flags = br.read_u32be()?;
748 let bytes_per_frame = br.read_u32be()?;
749 let samples_per_packet = br.read_u32be()?;
750 track.bsize = bytes_per_frame as usize;
751 track.frame_samples = samples_per_packet as usize;
752 track.tb_num = samples_per_packet;
755 track.bsize = (sample_size / 8) as usize;
758 if track.tb_den <= 1 {
759 track.tb_den = sample_rate;
761 track.raw_audio = matches!(&fcc,
762 b"NONE" | b"raw " | b"twos" | b"sowt" |
763 b"in24" | b"in32" | b"fl32" | b"fl64" |
764 b"ima4" | b"ms\x00\x02" | b"ms\x00\x21" |
767 let ahdr = NAAudioInfo::new(sample_rate, nchannels as u8, soniton, block_align);
768 let edata = parse_audio_edata(br, start_pos, size)?;
769 codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
770 track.channels = nchannels as usize;
771 track.bits = sample_size as usize;
773 StreamType::None => {
774 return Err(DemuxerError::InvalidData);
777 //todo put it all into extradata
779 codec_info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
782 let read_size = br.tell() - start_pos;
783 validate!(read_size <= size);
784 track.stream = Some(NAStream::new(track.stream_type, track.track_no, codec_info, track.tb_num, track.tb_den, u64::from(track.duration)));
785 track.stsd_found = true;
789 fn read_stts(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
790 validate!(size >= 8);
791 let start_pos = br.tell();
792 let version = br.read_byte()?;
793 validate!(version == 0);
794 let _flags = br.read_u24be()?;
795 let entries = br.read_u32be()? as usize;
796 validate!(entries as u64 <= (size - 8) / 8);
798 } else if entries == 1 {
799 let _count = br.read_u32be()?;
800 let tb_num = br.read_u32be()?;
801 validate!(tb_num != 0);
802 track.rescale(tb_num);
804 track.time_to_sample.clear();
805 track.time_to_sample.reserve(entries);
806 for _ in 0..entries {
807 let count = br.read_u32be()?;
808 let mult = br.read_u32be()?;
809 track.time_to_sample.push((count, mult));
812 let read_size = br.tell() - start_pos;
813 validate!(read_size <= size);
817 fn read_stss(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
818 let version = br.read_byte()?;
819 validate!(version == 0);
820 let _flags = br.read_u24be()?;
821 let entries = br.read_u32be()? as usize;
822 validate!(entries < ((std::u32::MAX >> 2) - 8) as usize);
823 validate!((entries * 4 + 8) as u64 == size);
824 track.keyframes = Vec::with_capacity(entries);
825 let mut last_sample_no = 0;
826 for _ in 0..entries {
827 let sample_no = br.read_u32be()?;
828 validate!(sample_no > last_sample_no);
829 track.keyframes.push(sample_no);
830 last_sample_no = sample_no;
835 fn read_stsc(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
836 let version = br.read_byte()?;
837 validate!(version == 0);
838 let _flags = br.read_u24be()?;
839 let entries = br.read_u32be()? as usize;
840 validate!(entries < ((std::u32::MAX / 12) - 8) as usize);
841 validate!((entries * 12 + 8) as u64 == size);
842 track.sample_map = Vec::with_capacity(entries);
843 let mut last_sample_no = 0;
844 for _i in 0..entries {
845 let sample_no = br.read_u32be()?;
846 validate!(sample_no > last_sample_no);
847 let nsamples = br.read_u32be()?;
848 let _sample_desc = br.read_u32be()?;
849 track.sample_map.push((sample_no, nsamples));
850 last_sample_no = sample_no;
855 fn read_stsz(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
856 let version = br.read_byte()?;
857 validate!(version == 0);
858 let _flags = br.read_u24be()?;
859 let sample_size = br.read_u32be()?;
860 if sample_size != 0 {
861 track.sample_size = sample_size;
862 if track.sample_size != 1 || track.bsize == 0 {
863 track.bsize = sample_size as usize;
867 let entries = br.read_u32be()? as usize;
868 validate!((entries * 4 + 12) as u64 == size);
869 track.chunk_sizes = Vec::with_capacity(entries);
870 for _ in 0..entries {
871 let sample_size = br.read_u32be()?;
872 track.chunk_sizes.push(sample_size);
878 fn read_stco(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
879 let version = br.read_byte()?;
880 validate!(version == 0);
881 let _flags = br.read_u24be()?;
882 let entries = br.read_u32be()? as usize;
883 validate!((entries * 4 + 8) as u64 == size);
884 track.chunk_offsets = Vec::with_capacity(entries);
885 for _i in 0..entries {
886 let sample_offset = br.read_u32be()?;
887 track.chunk_offsets.push(u64::from(sample_offset));
892 fn read_ctts(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
893 validate!(size >= 8);
894 let version = br.read_byte()?;
895 let _flags = br.read_u24be()?;
897 return Err(DemuxerError::NotImplemented);
899 let entries = br.read_u32be()? as usize;
900 track.ctts_version = version;
901 track.ctts_map.resize(entries);
904 validate!(size == (entries as u64) * 8 + 8);
905 for _ in 0..entries {
906 let samp_count = br.read_u32be()?;
907 let samp_offset = br.read_u32be()?;
908 track.ctts_map.add(samp_count, samp_offset / track.tb_div);
913 track.ctts_map.reset();
918 const TRAF_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
919 TrackChunkHandler { ctype: mktag!(b"tfhd"), parse: read_tfhd },
920 TrackChunkHandler { ctype: mktag!(b"trun"), parse: read_trun },
921 TrackChunkHandler { ctype: mktag!(b"sbgp"), parse: skip_chunk },
922 TrackChunkHandler { ctype: mktag!(b"sgpd"), parse: skip_chunk },
923 TrackChunkHandler { ctype: mktag!(b"subs"), parse: skip_chunk },
924 TrackChunkHandler { ctype: mktag!(b"saiz"), parse: skip_chunk },
925 TrackChunkHandler { ctype: mktag!(b"saio"), parse: skip_chunk },
926 TrackChunkHandler { ctype: mktag!(b"tfdt"), parse: skip_chunk },
927 TrackChunkHandler { ctype: mktag!(b"meta"), parse: skip_chunk },
930 fn read_tfhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
931 validate!(size >= 8);
932 let start = br.tell();
933 let _version = br.read_byte()?;
934 let flags = br.read_u24be()?;
935 let _track_id = br.read_u32be()?;
936 if (flags & 0x000001) != 0 {
937 let base_offset = br.read_u64be()?;
938 track.moof_off = base_offset;
940 if (flags & 0x000002) != 0 {
941 let _sample_description_index = br.read_u32be()?;
943 if (flags & 0x000008) != 0 {
944 let default_sample_duration = br.read_u32be()?;
945 if track.tb_div == 1 {
946 track.rescale(default_sample_duration);
949 if (flags & 0x000010) != 0 {
950 let _default_sample_size = br.read_u32be()?;
952 if (flags & 0x000020) != 0 {
953 let _default_sample_flags = br.read_u32be()?;
955 if (flags & 0x010000) != 0 {
957 /*if (flags & 0x020000) != 0 { // base offset is moof start
959 Ok(br.tell() - start)
962 fn read_trun(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
963 validate!(size >= 8);
964 let version = br.read_byte()?;
965 let flags = br.read_u24be()?;
966 let data_off_present = (flags & 0x000001) != 0;
967 let first_sample_flags = (flags & 0x000004) != 0;
968 let sample_duration_present = (flags & 0x000100) != 0;
969 let sample_size_present = (flags & 0x000200) != 0;
970 let sample_flags_present = (flags & 0x000400) != 0;
971 let sample_ct_off_present = (flags & 0x000800) != 0;
973 let sample_count = br.read_u32be()? as usize;
975 let mut hdr_size = 8;
976 let mut arr_size = 0;
977 if data_off_present {
980 if first_sample_flags {
983 if sample_duration_present {
986 if sample_size_present {
989 if sample_flags_present {
992 if sample_ct_off_present {
995 validate!(size == hdr_size + arr_size * (sample_count as u64));
997 let mut data_off = if data_off_present {
998 let off = br.read_u32be()? as i32;
999 let new_off = (track.moof_off as i64) + i64::from(off);
1000 validate!(new_off > 0);
1005 if first_sample_flags {
1006 let _flags = br.read_u32be()?;
1009 if sample_size_present {
1010 track.chunk_sizes.reserve(sample_count);
1011 track.chunk_offsets.reserve(sample_count);
1014 if sample_ct_off_present {
1015 if track.ctts_version != version {
1016 track.ctts_version = version;
1018 track.ctts_map.reserve(sample_count);
1021 if track.chunk_offsets.len() < (std::u32::MAX as usize) {
1022 track.keyframes.push((track.chunk_offsets.len() + 1) as u32);
1024 for _ in 0..sample_count {
1025 if sample_duration_present {
1026 let _duration = br.read_u32be()?;
1028 if sample_size_present {
1029 let ssize = br.read_u32be()?;
1030 track.chunk_sizes.push(ssize);
1031 track.chunk_offsets.push(data_off);
1032 data_off += u64::from(ssize);
1034 if sample_flags_present {
1035 let _flags = br.read_u32be()?;
1037 if sample_ct_off_present {
1038 let samp_offset = br.read_u32be()?;
1040 track.ctts_map.add(1, samp_offset / track.tb_div);
1042 track.ctts_map.add(1, ((samp_offset as i32) / (track.tb_div as i32)) as u32);
1050 struct MOVDemuxer<'a> {
1051 src: &'a mut ByteReader<'a>,
1059 pal: Option<Arc<[u8; 1024]>>,
1070 track_str_id: usize,
1081 stream_type: StreamType,
1088 keyframes: Vec<u32>,
1089 chunk_sizes: Vec<u32>,
1090 chunk_offsets: Vec<u64>,
1091 time_to_sample: Vec<(u32, u32)>,
1092 sample_map: Vec<(u32, u32)>,
1094 frame_samples: usize,
1095 ctts_map: RLESearcher<u32>,
1097 stream: Option<NAStream>,
1100 cur_ts: Option<u64>,
1101 samples_left: usize,
1103 pal: Option<Arc<[u8; 1024]>>,
1104 timesearch: TimeSearcher,
1112 struct TimeSearcher {
1121 fn new() -> Self { Self::default() }
1122 fn reset(&mut self) {
1123 *self = Self::default();
1125 fn map_time(&mut self, sample: u32, tts: &[(u32, u32)]) -> u64 {
1128 } else if sample >= self.sbase {
1129 let mut sample = sample - self.sbase;
1131 let (cur_len, cur_mul) = tts[0];
1132 self.cur_len = cur_len;
1133 self.cur_mul = cur_mul;
1136 while self.idx < tts.len() && sample > self.cur_len {
1137 sample -= self.cur_len;
1138 self.sbase += self.cur_len;
1139 self.base += u64::from(self.cur_len) * u64::from(self.cur_mul);
1140 self.cur_len = tts[self.idx].0;
1141 self.cur_mul = tts[self.idx].1;
1144 self.base + u64::from(sample) * u64::from(self.cur_mul)
1147 self.map_time(sample, tts)
1153 struct RLESearcher<T> {
1154 array: Vec<(u32, T)>,
1160 impl<T:Default+Copy> RLESearcher<T> {
1161 fn new() -> Self { Self::default() }
1162 fn resize(&mut self, size: usize) {
1164 self.array.reserve(size);
1166 fn reserve(&mut self, size: usize) {
1167 self.array.reserve(size);
1169 fn add(&mut self, len: u32, val: T) {
1170 self.array.push((len, val));
1172 fn reset(&mut self) {
1174 if !self.array.is_empty() {
1176 self.next = u64::from(self.array[0].0);
1178 self.idx = self.array.len();
1182 fn map(&mut self, sample: u64) -> Option<T> {
1183 if sample < self.start {
1186 if self.idx < self.array.len() {
1187 if sample < self.next {
1188 Some(self.array[self.idx].1)
1190 while (self.idx < self.array.len()) && (sample >= self.next) {
1191 self.start = self.next;
1193 if self.idx < self.array.len() {
1194 self.next += u64::from(self.array[self.idx].0);
1197 if self.idx < self.array.len() {
1198 Some(self.array[self.idx].1)
1210 fn new(track_no: u32, tb_den: u32) -> Self {
1223 stream_type: StreamType::None,
1230 keyframes: Vec::new(),
1231 chunk_sizes: Vec::new(),
1232 chunk_offsets: Vec::new(),
1233 time_to_sample: Vec::new(),
1234 sample_map: Vec::new(),
1237 ctts_map: RLESearcher::new(),
1247 timesearch: TimeSearcher::new(),
1251 print_chunks: false,
1254 read_chunk_list!(track; "trak", read_trak, TRAK_CHUNK_HANDLERS);
1255 read_chunk_list!(track; "mdia", read_mdia, MDIA_CHUNK_HANDLERS);
1256 read_chunk_list!(track; "minf", read_minf, MINF_CHUNK_HANDLERS);
1257 read_chunk_list!(track; "stbl", read_stbl, STBL_CHUNK_HANDLERS);
1258 read_chunk_list!(track; "traf", read_traf, TRAF_CHUNK_HANDLERS);
1259 fn rescale(&mut self, tb_num: u32) {
1260 self.tb_div = tb_num;
1261 if let Some(ref mut stream) = self.stream {
1262 let tb_den = stream.tb_den;
1263 let (tb_num, tb_den) = reduce_timebase(tb_num * stream.tb_num, tb_den);
1264 stream.duration /= u64::from(self.tb_div);
1265 stream.tb_num = tb_num;
1266 stream.tb_den = tb_den;
1267 self.tb_num = tb_num;
1268 self.tb_den = tb_den;
1269 self.duration /= self.tb_div;
1272 fn fill_seek_index(&self, seek_index: &mut SeekIndex) {
1273 if !self.keyframes.is_empty() {
1274 seek_index.mode = SeekIndexMode::Present;
1276 let mut tsearch = TimeSearcher::new();
1277 for kf_time in self.keyframes.iter() {
1278 let pts = tsearch.map_time(*kf_time - 1, &self.time_to_sample);
1279 let time = NATimeInfo::ts_to_time(pts, 1000, self.tb_num, self.tb_den);
1280 seek_index.add_entry(self.track_no, SeekEntry { time, pts: u64::from(*kf_time - 1), pos: 0 });
1283 fn calculate_chunk_size(&self, nsamp: usize) -> usize {
1288 b"NONE" | b"raw " | b"twos" | b"sowt" => {
1289 (nsamp * self.bits * self.channels + 7) >> 3
1292 let nblocks = (nsamp + 63) >> 6;
1293 nblocks * 34 * self.channels
1296 (nsamp + 5) / 6 * 2 * self.channels
1299 (nsamp + 5) / 6 * self.channels
1301 b"in24" => nsamp * 3 * self.channels,
1302 b"in32" | b"fl32" => nsamp * 4 * self.channels,
1303 b"fl64" => nsamp * 8 * self.channels,
1304 b"ulaw" | b"alaw" => nsamp,
1305 b"ms\x00\x02" => { //MS ADPCM
1306 ((nsamp - 1) / 2 + 7) * self.channels
1308 b"ms\x00\x21" => { //IMA ADPCM
1309 (nsamp / 2 + 4) * self.channels
1315 fn get_next_chunk(&mut self) -> Option<(NATimeInfo, u64, usize)> {
1316 let pts_val = self.timesearch.map_time(self.cur_sample as u32, &self.time_to_sample);
1317 let dts = if let Some(dts_corr) = self.ctts_map.map(self.cur_sample as u64) {
1318 let dts = match self.ctts_version {
1319 0 => pts_val.wrapping_add(u64::from(dts_corr)),
1320 1 => pts_val.wrapping_add(i64::from(dts_corr as i32) as u64),
1321 _ => unimplemented!(),
1323 if (dts as i64) < 0 {
1331 let mut pts = NATimeInfo::new(Some(pts_val), dts, None, self.tb_num, self.tb_den);
1332 if self.chunk_offsets.len() == self.chunk_sizes.len() { // simple one-to-one mapping
1333 if self.cur_sample >= self.chunk_sizes.len() {
1336 let offset = self.chunk_offsets[self.cur_sample];
1337 let size = self.chunk_sizes[self.cur_sample] as usize;
1338 self.cur_sample += 1;
1339 Some((pts, offset, size))
1341 if self.samples_left == 0 {
1342 if self.cur_chunk >= self.chunk_offsets.len() {
1345 for (idx, samples) in self.sample_map.iter() {
1346 if *idx as usize <= self.cur_chunk + 1 {
1347 self.samples_left = *samples as usize;
1352 self.last_offset = self.chunk_offsets[self.cur_chunk];
1353 self.cur_chunk += 1;
1355 let offset = self.last_offset;
1356 let size = self.get_size(self.cur_sample);
1357 self.last_offset += size as u64;
1358 if self.stream_type == StreamType::Video {
1359 self.samples_left -= 1;
1360 } else if self.frame_samples != 0 && self.bsize != 0 {
1361 let nblocks = size / self.bsize;
1363 pts.pts = Some(self.raw_apos);
1364 pts.duration = Some(nblocks as u64);
1365 self.raw_apos += nblocks as u64;
1368 let consumed = (nblocks * self.frame_samples).min(self.samples_left);
1369 self.samples_left -= consumed;
1371 self.samples_left = 0;
1373 } else if !self.raw_audio {
1374 self.samples_left -= 1;
1376 const BLOCK_SAMPLES: usize = 1024 * 6; // should be multiple of 64 and 6 to fit both IMA ADPCM and MACE 6:1 blocks
1377 let max_size = self.calculate_chunk_size(BLOCK_SAMPLES);
1378 let cur_size = self.calculate_chunk_size(self.samples_left);
1379 let add_off = (size - cur_size) as u64;
1380 let dsize = cur_size.min(max_size);
1381 if self.samples_left >= BLOCK_SAMPLES {
1382 self.cur_sample += BLOCK_SAMPLES;
1383 self.samples_left -= BLOCK_SAMPLES;
1384 self.last_offset -= size as u64;
1386 self.cur_sample += self.samples_left;
1387 self.samples_left = 0;
1389 return Some((pts, offset + add_off, dsize));
1391 self.cur_sample += 1;
1392 Some((pts, offset, size))
1395 fn get_size(&self, sample_no: usize) -> usize {
1396 if !self.chunk_sizes.is_empty() {
1397 self.chunk_sizes[sample_no] as usize
1398 } else if !self.sample_map.is_empty() {
1400 for (idx, samples) in self.sample_map.iter() {
1401 if *idx as usize <= self.cur_chunk {
1407 self.calculate_chunk_size(nsamp as usize)
1412 #[allow(clippy::collapsible_if)]
1413 #[allow(clippy::collapsible_else_if)]
1414 fn seek(&mut self, pts: u64, tpoint: NATimePoint) -> DemuxerResult<u64> {
1415 self.cur_sample = pts as usize;
1416 self.samples_left = 0;
1418 if self.stream_type == StreamType::Audio {
1419 if let NATimePoint::Milliseconds(ms) = tpoint {
1420 let exp_pts = NATimeInfo::time_to_ts(ms, 1000, self.tb_num, self.tb_den);
1422 if self.frame_samples != 0 {
1423 self.raw_apos = exp_pts / (self.frame_samples as u64);
1425 self.cur_sample = 0;
1427 let mut cmap = self.sample_map.iter();
1428 let mut cur_samps = 0;
1429 let (mut next_idx, mut next_samples) = cmap.next().unwrap();
1431 if self.cur_chunk + 1 == next_idx as usize {
1432 self.samples_left = cur_samps;
1433 cur_samps = next_samples as usize;
1434 if let Some((new_idx, new_samples)) = cmap.next() {
1435 next_idx = *new_idx;
1436 next_samples = *new_samples;
1439 self.raw_apos = apos;
1440 apos += (cur_samps / self.frame_samples) as u64;
1442 if cur_samps == self.frame_samples || apos > exp_pts + 1 {
1443 if self.cur_chunk >= self.chunk_offsets.len() {
1444 return Err(DemuxerError::SeekError);
1446 self.last_offset = self.chunk_offsets[self.cur_chunk];
1450 self.cur_chunk += 1;
1452 self.samples_left = cur_samps;
1453 self.cur_chunk += 1;
1455 self.raw_apos = exp_pts;
1456 self.cur_sample = exp_pts as usize;
1459 let mut cmap = self.sample_map.iter();
1460 let mut cur_samps = 0;
1461 let (mut next_idx, mut next_samples) = cmap.next().unwrap();
1463 if self.cur_chunk + 1 == next_idx as usize {
1464 self.samples_left = cur_samps;
1465 cur_samps = next_samples as usize;
1466 if let Some((new_idx, new_samples)) = cmap.next() {
1467 next_idx = *new_idx;
1468 next_samples = *new_samples;
1472 if csamp > self.cur_sample {
1473 if self.cur_chunk >= self.chunk_offsets.len() {
1474 return Err(DemuxerError::SeekError);
1476 self.last_offset = self.chunk_offsets[self.cur_chunk];
1479 self.cur_chunk += 1;
1481 self.samples_left = csamp - self.cur_sample;
1482 self.cur_chunk += 1;
1484 } else if self.chunk_offsets.len() == self.chunk_sizes.len() && self.duration != 0 {
1485 let new_sample = (self.chunk_sizes.len() as u64 * exp_pts / u64::from(self.duration)) as usize;
1486 self.cur_sample = new_sample;
1487 self.cur_chunk = self.cur_sample;
1489 if !self.time_to_sample.is_empty() {
1490 let mut remaining = exp_pts;
1491 let mut abs_csamp = 0;
1492 for &(count, scount) in self.time_to_sample.iter() {
1493 let count = u64::from(count);
1494 let scount = u64::from(scount);
1495 let nblk = remaining / scount;
1500 remaining -= count * scount;
1503 self.cur_sample = abs_csamp as usize;
1505 self.cur_sample = exp_pts as usize;
1507 let tgt_sample = self.cur_sample;
1510 let mut cmap = self.sample_map.iter();
1511 let mut cur_samps = 0;
1512 let (mut next_idx, mut next_samples) = cmap.next().unwrap();
1514 if self.cur_chunk + 1 == next_idx as usize {
1515 self.samples_left = cur_samps;
1516 cur_samps = next_samples as usize;
1517 if let Some((new_idx, new_samples)) = cmap.next() {
1518 next_idx = *new_idx;
1519 next_samples = *new_samples;
1523 if csamp > self.cur_sample {
1524 if self.cur_chunk >= self.chunk_offsets.len() {
1525 self.cur_sample = csamp - cur_samps;
1526 self.samples_left = 0;
1527 self.cur_sample = csamp;
1528 return Err(DemuxerError::SeekError);
1530 self.last_offset = self.chunk_offsets[self.cur_chunk];
1533 self.cur_chunk += 1;
1535 self.cur_sample = csamp - cur_samps;
1536 self.samples_left = cur_samps;
1537 self.last_offset = self.chunk_offsets[self.cur_chunk];
1538 self.cur_chunk += 1;
1540 // try to refine sample position
1541 if self.chunk_sizes.len() > self.chunk_offsets.len() {
1542 for i in self.cur_sample..tgt_sample {
1543 self.cur_sample += 1;
1544 self.samples_left -= 1;
1545 self.last_offset += u64::from(self.chunk_sizes[i]);
1550 self.cur_chunk = self.cur_sample;
1552 } else if self.chunk_offsets.len() != self.chunk_sizes.len() && !self.sample_map.is_empty() {
1555 let mut cmap = self.sample_map.iter();
1556 let mut cur_samps = 0;
1557 let (mut next_idx, mut next_samples) = cmap.next().unwrap();
1559 if self.cur_chunk + 1 == next_idx as usize {
1560 self.samples_left = cur_samps;
1561 cur_samps = next_samples as usize;
1562 if let Some((new_idx, new_samples)) = cmap.next() {
1563 next_idx = *new_idx;
1564 next_samples = *new_samples;
1568 if csamp >= self.cur_sample {
1569 if self.cur_chunk >= self.chunk_offsets.len() {
1570 return Err(DemuxerError::SeekError);
1572 self.last_offset = self.chunk_offsets[self.cur_chunk];
1575 self.cur_chunk += 1;
1578 for sample_no in csamp..self.cur_sample {
1579 self.last_offset += self.get_size(sample_no) as u64;
1581 self.samples_left = csamp + cur_samps - self.cur_sample;
1582 self.cur_chunk += 1;
1584 let cur_pts = self.timesearch.map_time(self.cur_sample as u32, &self.time_to_sample);
1585 let cur_time = NATimeInfo::ts_to_time(cur_pts, 1000, self.tb_num, self.tb_den);
1590 fn process_packet(src: &mut ByteReader, strmgr: &StreamManager, track: &mut Track, pts: NATimeInfo, offset: u64, size: usize, first: bool) -> DemuxerResult<NAPacket> {
1591 if let Some(cpts) = pts.get_pts() {
1592 let ts = NATimeInfo::ts_to_time(cpts, 1000, pts.tb_num, pts.tb_den);
1593 track.cur_ts = Some(ts);
1595 track.cur_ts = None;
1597 let stream = strmgr.get_stream(track.track_str_id);
1598 if stream.is_none() { return Err(DemuxerError::InvalidData); }
1599 let stream = stream.unwrap();
1600 src.seek(SeekFrom::Start(offset))?;
1601 let mut pkt = src.read_packet(stream, pts, false, size)?;
1602 if let Some(ref pal) = track.pal {
1603 let side_data = NASideData::Palette(first, pal.clone());
1604 pkt.add_side_data(side_data);
1609 impl<'a> DemuxCore<'a> for MOVDemuxer<'a> {
1610 fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
1611 if !self.macbinary {
1612 self.read_root(strmgr)?;
1614 let ver = self.src.read_byte()?;
1615 validate!(ver == 0);
1616 self.src.read_skip(64)?;
1617 let tag = self.src.read_tag()?;
1618 validate!(&tag == b"MooV");
1619 self.src.read_skip(14)?;
1620 let data_length = self.src.read_u32be()?;
1621 validate!(data_length > 8);
1622 let rsrc_length = self.src.read_u32be()?;
1623 validate!(rsrc_length > 0);
1624 self.src.read_skip(31)?;
1625 let ver = self.src.read_byte()?;
1626 validate!(ver == 0x81);
1627 let ver = self.src.read_byte()?;
1628 validate!(ver == 0x81);
1629 //xxx: maybe check header CRC
1631 let rsrc_start = 0x80 + ((data_length + 0x7F) & !0x7F);
1632 self.src.seek(SeekFrom::Start(rsrc_start.into()))?;
1633 let rsrc_off = self.src.read_u32be()?;
1634 let rsrc_map_off = self.src.read_u32be()?;
1635 let rsrc_size = self.src.read_u32be()?;
1636 let _rsrc_map_size = self.src.read_u32be()?;
1637 validate!(rsrc_off >= 0x10);
1638 validate!(rsrc_map_off >= rsrc_off + rsrc_size);
1639 self.src.seek(SeekFrom::Current(i64::from(rsrc_off - 16)))?;
1640 // I'm too lazy to parse resource map, so let's just iterate over resources for movie header
1641 let end_pos = u64::from(rsrc_start + rsrc_off + rsrc_size);
1642 let mut peek_buf = [0u8; 8];
1643 while self.src.tell() < end_pos {
1644 let cur_size = self.src.read_u32be()?;
1645 validate!(self.src.tell() + u64::from(cur_size) <= end_pos);
1647 let rsize = self.src.peek_u32be()?;
1648 if rsize == cur_size {
1649 self.src.peek_buf(&mut peek_buf)?;
1650 if &peek_buf[4..] == b"moov" {
1651 self.src.read_skip(8)?;
1652 self.read_moov(strmgr, rsize.into())?;
1658 self.src.read_skip(cur_size as usize)?;
1661 validate!(self.mdat_pos > 0);
1662 validate!(!self.tracks.is_empty());
1663 for track in self.tracks.iter_mut() {
1664 let mut strm = None;
1665 std::mem::swap(&mut track.stream, &mut strm);
1666 if let Some(stream) = strm {
1667 let str_id = strmgr.add_stream(stream).unwrap();
1668 track.track_str_id = str_id;
1672 // patch data offsets
1673 for track in self.tracks.iter_mut() {
1674 for offset in track.chunk_offsets.iter_mut() {
1679 for track in self.tracks.iter() {
1680 track.fill_seek_index(seek_index);
1682 self.src.seek(SeekFrom::Start(self.mdat_pos))?;
1687 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
1688 if self.tracks.is_empty() {
1689 return Err(DemuxerError::EOF);
1691 let mut has_all_time = true;
1692 let mut min_ts = std::u64::MAX;
1693 for trk in self.tracks.iter() {
1694 if let Some(ts) = trk.cur_ts {
1695 min_ts = min_ts.min(ts);
1697 has_all_time = false;
1702 for (trk_no, track) in self.tracks.iter_mut().enumerate() {
1703 if let Some(ts) = track.cur_ts {
1705 let first = track.cur_sample == 0;
1706 if let Some((pts, offset, size)) = track.get_next_chunk() {
1707 self.cur_track = trk_no + 1;
1708 return process_packet(self.src, strmgr, track, pts, offset, size, first);
1715 for _ in 0..self.tracks.len() {
1716 if self.cur_track >= self.tracks.len() {
1719 let track = &mut self.tracks[self.cur_track];
1720 self.cur_track += 1;
1721 let first = track.cur_sample == 0;
1722 if let Some((pts, offset, size)) = track.get_next_chunk() {
1723 return process_packet(self.src, strmgr, track, pts, offset, size, first);
1726 Err(DemuxerError::EOF)
1729 fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
1730 let ret = seek_index.find_pos(time);
1732 if let NATimePoint::Milliseconds(_) = time {
1733 let mut aonly = true;
1734 for track in self.tracks.iter() {
1735 if track.stream_type != StreamType::Audio {
1741 for track in self.tracks.iter_mut() {
1742 track.seek(0, time)?;
1747 return Err(DemuxerError::SeekError);
1749 let seek_info = ret.unwrap();
1750 let tbn = self.tracks[seek_info.str_id as usize].tb_num;
1751 let tbd = self.tracks[seek_info.str_id as usize].tb_den;
1752 let mut vpts = None;
1753 let mut apts = None;
1754 for track in self.tracks.iter_mut() {
1755 let cur_pts = if track.track_id == seek_info.str_id {
1758 seek_info.pts * u64::from(tbn) * u64::from(track.tb_den) / (u64::from(tbd) * u64::from(track.tb_num))
1760 let actual_time = track.seek(cur_pts, time)?;
1761 match track.stream_type {
1762 StreamType::Video => vpts = Some(actual_time),
1763 StreamType::Audio => apts = Some(actual_time),
1767 /* For audio+video stream case when the post-seek actual times differ
1768 by more than half a second try to seek audio to a closer position
1771 if let (true, Some(vtime), Some(atime)) = (self.tracks.len() == 2, vpts, apts) {
1772 if vtime.max(atime) - vtime.min(atime) > 500 && atime != 0 {
1773 for track in self.tracks.iter_mut() {
1774 if track.stream_type == StreamType::Audio {
1775 let new_pts = NATimeInfo::time_to_ts(vtime, 1000, track.tb_num, track.tb_den);
1776 track.seek(new_pts, NATimePoint::Milliseconds(vtime))?;
1784 fn get_duration(&self) -> u64 {
1785 if self.tb_den != 0 {
1786 u64::from(self.duration) * 1000 / u64::from(self.tb_den)
1793 const PRINT_CHUNKS: &str = "print_chunks";
1795 const DEMUXER_OPTIONS: &[NAOptionDefinition] = &[
1796 NAOptionDefinition {
1798 description: "Print parsed file structure",
1799 opt_type: NAOptionDefinitionType::Bool },
1802 impl<'a> NAOptionHandler for MOVDemuxer<'a> {
1803 fn get_supported_options(&self) -> &[NAOptionDefinition] { DEMUXER_OPTIONS }
1804 #[allow(clippy::single_match)]
1805 fn set_options(&mut self, options: &[NAOption]) {
1806 for option in options.iter() {
1807 for opt_def in DEMUXER_OPTIONS.iter() {
1808 if opt_def.check(option).is_ok() {
1809 match (option.name, &option.value) {
1810 (PRINT_CHUNKS, NAValue::Bool(val)) => {
1811 self.print_chunks = *val;
1819 fn query_option_value(&self, name: &str) -> Option<NAValue> {
1821 PRINT_CHUNKS => Some(NAValue::Bool(self.print_chunks)),
1827 impl<'a> MOVDemuxer<'a> {
1828 fn new(io: &'a mut ByteReader<'a>) -> Self {
1829 Self::new_common(io, false)
1831 fn new_macbinary(io: &'a mut ByteReader<'a>) -> Self {
1832 Self::new_common(io, true)
1834 fn new_common(io: &'a mut ByteReader<'a>, macbinary: bool) -> Self {
1840 tracks: Vec::with_capacity(2),
1848 print_chunks: false,
1853 fn read_root(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
1855 while self.src.left() != 0 {
1856 let ret = read_chunk_header(self.src);
1857 if ret.is_err() { break; }
1858 let (ctype, size) = ret.unwrap();
1859 if self.print_chunks {
1860 print_cname(ctype, size, self.src.tell(), 0);
1862 if IGNORED_CHUNKS.contains(&ctype) {
1863 self.src.skip64(size)?;
1866 let handler = ROOT_CHUNK_HANDLERS.iter().find(|x| x.ctype == ctype);
1868 if let Some(handler) = handler {
1869 read_size = (handler.parse)(self, strmgr, size)?;
1871 println!("skipping unknown chunk {:08X} size {}", ctype, size);
1874 validate!(read_size <= size);
1875 self.src.skip64(size - read_size)?;
1877 //todo check if all needed chunks are found
1880 read_chunk_list!(root; "moov", read_moov, MOOV_CHUNK_HANDLERS);
1881 read_chunk_list!(root; "moof", read_moof, MOOF_CHUNK_HANDLERS);
1884 pub struct MOVDemuxerCreator { }
1886 impl DemuxerCreator for MOVDemuxerCreator {
1887 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1888 Box::new(MOVDemuxer::new(br))
1890 fn get_name(&self) -> &'static str { "mov" }
1893 pub struct MacBinaryMOVDemuxerCreator { }
1895 impl DemuxerCreator for MacBinaryMOVDemuxerCreator {
1896 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1897 Box::new(MOVDemuxer::new_macbinary(br))
1899 fn get_name(&self) -> &'static str { "mov-macbin" }
1902 const MOV_DEFAULT_PAL_2BIT: [u8; 4 * 4] = [
1903 0x93, 0x65, 0x5E, 0x00,
1904 0xFF, 0xFF, 0xFF, 0x00,
1905 0xDF, 0xD0, 0xAB, 0x00,
1906 0x00, 0x00, 0x00, 0x00
1908 const MOV_DEFAULT_PAL_4BIT: [u8; 16 * 4] = [
1909 0xFF, 0xFB, 0xFF, 0x00,
1910 0xEF, 0xD9, 0xBB, 0x00,
1911 0xE8, 0xC9, 0xB1, 0x00,
1912 0x93, 0x65, 0x5E, 0x00,
1913 0xFC, 0xDE, 0xE8, 0x00,
1914 0x9D, 0x88, 0x91, 0x00,
1915 0xFF, 0xFF, 0xFF, 0x00,
1916 0xFF, 0xFF, 0xFF, 0x00,
1917 0xFF, 0xFF, 0xFF, 0x00,
1918 0x47, 0x48, 0x37, 0x00,
1919 0x7A, 0x5E, 0x55, 0x00,
1920 0xDF, 0xD0, 0xAB, 0x00,
1921 0xFF, 0xFB, 0xF9, 0x00,
1922 0xE8, 0xCA, 0xC5, 0x00,
1923 0x8A, 0x7C, 0x77, 0x00,
1924 0x00, 0x00, 0x00, 0x00
1926 const MOV_DEFAULT_PAL_8BIT: [u8; 256 * 4] = [
1927 0xFF, 0xFF, 0xFF, 0x00,
1928 0xFF, 0xFF, 0xCC, 0x00,
1929 0xFF, 0xFF, 0x99, 0x00,
1930 0xFF, 0xFF, 0x66, 0x00,
1931 0xFF, 0xFF, 0x33, 0x00,
1932 0xFF, 0xFF, 0x00, 0x00,
1933 0xFF, 0xCC, 0xFF, 0x00,
1934 0xFF, 0xCC, 0xCC, 0x00,
1935 0xFF, 0xCC, 0x99, 0x00,
1936 0xFF, 0xCC, 0x66, 0x00,
1937 0xFF, 0xCC, 0x33, 0x00,
1938 0xFF, 0xCC, 0x00, 0x00,
1939 0xFF, 0x99, 0xFF, 0x00,
1940 0xFF, 0x99, 0xCC, 0x00,
1941 0xFF, 0x99, 0x99, 0x00,
1942 0xFF, 0x99, 0x66, 0x00,
1943 0xFF, 0x99, 0x33, 0x00,
1944 0xFF, 0x99, 0x00, 0x00,
1945 0xFF, 0x66, 0xFF, 0x00,
1946 0xFF, 0x66, 0xCC, 0x00,
1947 0xFF, 0x66, 0x99, 0x00,
1948 0xFF, 0x66, 0x66, 0x00,
1949 0xFF, 0x66, 0x33, 0x00,
1950 0xFF, 0x66, 0x00, 0x00,
1951 0xFF, 0x33, 0xFF, 0x00,
1952 0xFF, 0x33, 0xCC, 0x00,
1953 0xFF, 0x33, 0x99, 0x00,
1954 0xFF, 0x33, 0x66, 0x00,
1955 0xFF, 0x33, 0x33, 0x00,
1956 0xFF, 0x33, 0x00, 0x00,
1957 0xFF, 0x00, 0xFF, 0x00,
1958 0xFF, 0x00, 0xCC, 0x00,
1959 0xFF, 0x00, 0x99, 0x00,
1960 0xFF, 0x00, 0x66, 0x00,
1961 0xFF, 0x00, 0x33, 0x00,
1962 0xFF, 0x00, 0x00, 0x00,
1963 0xCC, 0xFF, 0xFF, 0x00,
1964 0xCC, 0xFF, 0xCC, 0x00,
1965 0xCC, 0xFF, 0x99, 0x00,
1966 0xCC, 0xFF, 0x66, 0x00,
1967 0xCC, 0xFF, 0x33, 0x00,
1968 0xCC, 0xFF, 0x00, 0x00,
1969 0xCC, 0xCC, 0xFF, 0x00,
1970 0xCC, 0xCC, 0xCC, 0x00,
1971 0xCC, 0xCC, 0x99, 0x00,
1972 0xCC, 0xCC, 0x66, 0x00,
1973 0xCC, 0xCC, 0x33, 0x00,
1974 0xCC, 0xCC, 0x00, 0x00,
1975 0xCC, 0x99, 0xFF, 0x00,
1976 0xCC, 0x99, 0xCC, 0x00,
1977 0xCC, 0x99, 0x99, 0x00,
1978 0xCC, 0x99, 0x66, 0x00,
1979 0xCC, 0x99, 0x33, 0x00,
1980 0xCC, 0x99, 0x00, 0x00,
1981 0xCC, 0x66, 0xFF, 0x00,
1982 0xCC, 0x66, 0xCC, 0x00,
1983 0xCC, 0x66, 0x99, 0x00,
1984 0xCC, 0x66, 0x66, 0x00,
1985 0xCC, 0x66, 0x33, 0x00,
1986 0xCC, 0x66, 0x00, 0x00,
1987 0xCC, 0x33, 0xFF, 0x00,
1988 0xCC, 0x33, 0xCC, 0x00,
1989 0xCC, 0x33, 0x99, 0x00,
1990 0xCC, 0x33, 0x66, 0x00,
1991 0xCC, 0x33, 0x33, 0x00,
1992 0xCC, 0x33, 0x00, 0x00,
1993 0xCC, 0x00, 0xFF, 0x00,
1994 0xCC, 0x00, 0xCC, 0x00,
1995 0xCC, 0x00, 0x99, 0x00,
1996 0xCC, 0x00, 0x66, 0x00,
1997 0xCC, 0x00, 0x33, 0x00,
1998 0xCC, 0x00, 0x00, 0x00,
1999 0x99, 0xFF, 0xFF, 0x00,
2000 0x99, 0xFF, 0xCC, 0x00,
2001 0x99, 0xFF, 0x99, 0x00,
2002 0x99, 0xFF, 0x66, 0x00,
2003 0x99, 0xFF, 0x33, 0x00,
2004 0x99, 0xFF, 0x00, 0x00,
2005 0x99, 0xCC, 0xFF, 0x00,
2006 0x99, 0xCC, 0xCC, 0x00,
2007 0x99, 0xCC, 0x99, 0x00,
2008 0x99, 0xCC, 0x66, 0x00,
2009 0x99, 0xCC, 0x33, 0x00,
2010 0x99, 0xCC, 0x00, 0x00,
2011 0x99, 0x99, 0xFF, 0x00,
2012 0x99, 0x99, 0xCC, 0x00,
2013 0x99, 0x99, 0x99, 0x00,
2014 0x99, 0x99, 0x66, 0x00,
2015 0x99, 0x99, 0x33, 0x00,
2016 0x99, 0x99, 0x00, 0x00,
2017 0x99, 0x66, 0xFF, 0x00,
2018 0x99, 0x66, 0xCC, 0x00,
2019 0x99, 0x66, 0x99, 0x00,
2020 0x99, 0x66, 0x66, 0x00,
2021 0x99, 0x66, 0x33, 0x00,
2022 0x99, 0x66, 0x00, 0x00,
2023 0x99, 0x33, 0xFF, 0x00,
2024 0x99, 0x33, 0xCC, 0x00,
2025 0x99, 0x33, 0x99, 0x00,
2026 0x99, 0x33, 0x66, 0x00,
2027 0x99, 0x33, 0x33, 0x00,
2028 0x99, 0x33, 0x00, 0x00,
2029 0x99, 0x00, 0xFF, 0x00,
2030 0x99, 0x00, 0xCC, 0x00,
2031 0x99, 0x00, 0x99, 0x00,
2032 0x99, 0x00, 0x66, 0x00,
2033 0x99, 0x00, 0x33, 0x00,
2034 0x99, 0x00, 0x00, 0x00,
2035 0x66, 0xFF, 0xFF, 0x00,
2036 0x66, 0xFF, 0xCC, 0x00,
2037 0x66, 0xFF, 0x99, 0x00,
2038 0x66, 0xFF, 0x66, 0x00,
2039 0x66, 0xFF, 0x33, 0x00,
2040 0x66, 0xFF, 0x00, 0x00,
2041 0x66, 0xCC, 0xFF, 0x00,
2042 0x66, 0xCC, 0xCC, 0x00,
2043 0x66, 0xCC, 0x99, 0x00,
2044 0x66, 0xCC, 0x66, 0x00,
2045 0x66, 0xCC, 0x33, 0x00,
2046 0x66, 0xCC, 0x00, 0x00,
2047 0x66, 0x99, 0xFF, 0x00,
2048 0x66, 0x99, 0xCC, 0x00,
2049 0x66, 0x99, 0x99, 0x00,
2050 0x66, 0x99, 0x66, 0x00,
2051 0x66, 0x99, 0x33, 0x00,
2052 0x66, 0x99, 0x00, 0x00,
2053 0x66, 0x66, 0xFF, 0x00,
2054 0x66, 0x66, 0xCC, 0x00,
2055 0x66, 0x66, 0x99, 0x00,
2056 0x66, 0x66, 0x66, 0x00,
2057 0x66, 0x66, 0x33, 0x00,
2058 0x66, 0x66, 0x00, 0x00,
2059 0x66, 0x33, 0xFF, 0x00,
2060 0x66, 0x33, 0xCC, 0x00,
2061 0x66, 0x33, 0x99, 0x00,
2062 0x66, 0x33, 0x66, 0x00,
2063 0x66, 0x33, 0x33, 0x00,
2064 0x66, 0x33, 0x00, 0x00,
2065 0x66, 0x00, 0xFF, 0x00,
2066 0x66, 0x00, 0xCC, 0x00,
2067 0x66, 0x00, 0x99, 0x00,
2068 0x66, 0x00, 0x66, 0x00,
2069 0x66, 0x00, 0x33, 0x00,
2070 0x66, 0x00, 0x00, 0x00,
2071 0x33, 0xFF, 0xFF, 0x00,
2072 0x33, 0xFF, 0xCC, 0x00,
2073 0x33, 0xFF, 0x99, 0x00,
2074 0x33, 0xFF, 0x66, 0x00,
2075 0x33, 0xFF, 0x33, 0x00,
2076 0x33, 0xFF, 0x00, 0x00,
2077 0x33, 0xCC, 0xFF, 0x00,
2078 0x33, 0xCC, 0xCC, 0x00,
2079 0x33, 0xCC, 0x99, 0x00,
2080 0x33, 0xCC, 0x66, 0x00,
2081 0x33, 0xCC, 0x33, 0x00,
2082 0x33, 0xCC, 0x00, 0x00,
2083 0x33, 0x99, 0xFF, 0x00,
2084 0x33, 0x99, 0xCC, 0x00,
2085 0x33, 0x99, 0x99, 0x00,
2086 0x33, 0x99, 0x66, 0x00,
2087 0x33, 0x99, 0x33, 0x00,
2088 0x33, 0x99, 0x00, 0x00,
2089 0x33, 0x66, 0xFF, 0x00,
2090 0x33, 0x66, 0xCC, 0x00,
2091 0x33, 0x66, 0x99, 0x00,
2092 0x33, 0x66, 0x66, 0x00,
2093 0x33, 0x66, 0x33, 0x00,
2094 0x33, 0x66, 0x00, 0x00,
2095 0x33, 0x33, 0xFF, 0x00,
2096 0x33, 0x33, 0xCC, 0x00,
2097 0x33, 0x33, 0x99, 0x00,
2098 0x33, 0x33, 0x66, 0x00,
2099 0x33, 0x33, 0x33, 0x00,
2100 0x33, 0x33, 0x00, 0x00,
2101 0x33, 0x00, 0xFF, 0x00,
2102 0x33, 0x00, 0xCC, 0x00,
2103 0x33, 0x00, 0x99, 0x00,
2104 0x33, 0x00, 0x66, 0x00,
2105 0x33, 0x00, 0x33, 0x00,
2106 0x33, 0x00, 0x00, 0x00,
2107 0x00, 0xFF, 0xFF, 0x00,
2108 0x00, 0xFF, 0xCC, 0x00,
2109 0x00, 0xFF, 0x99, 0x00,
2110 0x00, 0xFF, 0x66, 0x00,
2111 0x00, 0xFF, 0x33, 0x00,
2112 0x00, 0xFF, 0x00, 0x00,
2113 0x00, 0xCC, 0xFF, 0x00,
2114 0x00, 0xCC, 0xCC, 0x00,
2115 0x00, 0xCC, 0x99, 0x00,
2116 0x00, 0xCC, 0x66, 0x00,
2117 0x00, 0xCC, 0x33, 0x00,
2118 0x00, 0xCC, 0x00, 0x00,
2119 0x00, 0x99, 0xFF, 0x00,
2120 0x00, 0x99, 0xCC, 0x00,
2121 0x00, 0x99, 0x99, 0x00,
2122 0x00, 0x99, 0x66, 0x00,
2123 0x00, 0x99, 0x33, 0x00,
2124 0x00, 0x99, 0x00, 0x00,
2125 0x00, 0x66, 0xFF, 0x00,
2126 0x00, 0x66, 0xCC, 0x00,
2127 0x00, 0x66, 0x99, 0x00,
2128 0x00, 0x66, 0x66, 0x00,
2129 0x00, 0x66, 0x33, 0x00,
2130 0x00, 0x66, 0x00, 0x00,
2131 0x00, 0x33, 0xFF, 0x00,
2132 0x00, 0x33, 0xCC, 0x00,
2133 0x00, 0x33, 0x99, 0x00,
2134 0x00, 0x33, 0x66, 0x00,
2135 0x00, 0x33, 0x33, 0x00,
2136 0x00, 0x33, 0x00, 0x00,
2137 0x00, 0x00, 0xFF, 0x00,
2138 0x00, 0x00, 0xCC, 0x00,
2139 0x00, 0x00, 0x99, 0x00,
2140 0x00, 0x00, 0x66, 0x00,
2141 0x00, 0x00, 0x33, 0x00,
2142 0xEE, 0x00, 0x00, 0x00,
2143 0xDD, 0x00, 0x00, 0x00,
2144 0xBB, 0x00, 0x00, 0x00,
2145 0xAA, 0x00, 0x00, 0x00,
2146 0x88, 0x00, 0x00, 0x00,
2147 0x77, 0x00, 0x00, 0x00,
2148 0x55, 0x00, 0x00, 0x00,
2149 0x44, 0x00, 0x00, 0x00,
2150 0x22, 0x00, 0x00, 0x00,
2151 0x11, 0x00, 0x00, 0x00,
2152 0x00, 0xEE, 0x00, 0x00,
2153 0x00, 0xDD, 0x00, 0x00,
2154 0x00, 0xBB, 0x00, 0x00,
2155 0x00, 0xAA, 0x00, 0x00,
2156 0x00, 0x88, 0x00, 0x00,
2157 0x00, 0x77, 0x00, 0x00,
2158 0x00, 0x55, 0x00, 0x00,
2159 0x00, 0x44, 0x00, 0x00,
2160 0x00, 0x22, 0x00, 0x00,
2161 0x00, 0x11, 0x00, 0x00,
2162 0x00, 0x00, 0xEE, 0x00,
2163 0x00, 0x00, 0xDD, 0x00,
2164 0x00, 0x00, 0xBB, 0x00,
2165 0x00, 0x00, 0xAA, 0x00,
2166 0x00, 0x00, 0x88, 0x00,
2167 0x00, 0x00, 0x77, 0x00,
2168 0x00, 0x00, 0x55, 0x00,
2169 0x00, 0x00, 0x44, 0x00,
2170 0x00, 0x00, 0x22, 0x00,
2171 0x00, 0x00, 0x11, 0x00,
2172 0xEE, 0xEE, 0xEE, 0x00,
2173 0xDD, 0xDD, 0xDD, 0x00,
2174 0xBB, 0xBB, 0xBB, 0x00,
2175 0xAA, 0xAA, 0xAA, 0x00,
2176 0x88, 0x88, 0x88, 0x00,
2177 0x77, 0x77, 0x77, 0x00,
2178 0x55, 0x55, 0x55, 0x00,
2179 0x44, 0x44, 0x44, 0x00,
2180 0x22, 0x22, 0x22, 0x00,
2181 0x11, 0x11, 0x11, 0x00,
2182 0x00, 0x00, 0x00, 0x00
2191 fn test_mov_demux() {
2192 // sample: https://samples.mplayerhq.hu/V-codecs/IV32/cubes.mov
2193 let mut file = File::open("assets/Indeo/cubes.mov").unwrap();
2194 let mut fr = FileReader::new_read(&mut file);
2195 let mut br = ByteReader::new(&mut fr);
2196 let mut dmx = MOVDemuxer::new(&mut br);
2197 let mut sm = StreamManager::new();
2198 let mut si = SeekIndex::new();
2199 dmx.open(&mut sm, &mut si).unwrap();
2202 let pktres = dmx.get_frame(&mut sm);
2203 if let Err(e) = pktres {
2204 if e == DemuxerError::EOF { break; }
2207 let pkt = pktres.unwrap();
2208 println!("Got {}", pkt);
2213 fn test_dash_demux() {
2214 // sample: a stream downloaded with youtube-dl
2215 let mut file = File::open("assets/ITU/dash.m4a").unwrap();
2216 let mut fr = FileReader::new_read(&mut file);
2217 let mut br = ByteReader::new(&mut fr);
2218 let mut dmx = MOVDemuxer::new(&mut br);
2219 let mut sm = StreamManager::new();
2220 let mut si = SeekIndex::new();
2221 dmx.open(&mut sm, &mut si).unwrap();
2224 let pktres = dmx.get_frame(&mut sm);
2225 if let Err(e) = pktres {
2226 if e == DemuxerError::EOF { break; }
2229 let pkt = pktres.unwrap();
2230 println!("Got {}", pkt);
2235 fn test_macbinary_demux() {
2236 // sample from King's Quest VI Macintosh edition
2237 let mut file = File::open("assets/QT/Halfdome.bin").unwrap();
2238 let mut fr = FileReader::new_read(&mut file);
2239 let mut br = ByteReader::new(&mut fr);
2240 let mut dmx = MOVDemuxer::new_macbinary(&mut br);
2241 let mut sm = StreamManager::new();
2242 let mut si = SeekIndex::new();
2243 dmx.open(&mut sm, &mut si).unwrap();
2246 let pktres = dmx.get_frame(&mut sm);
2247 if let Err(e) = pktres {
2248 if e == DemuxerError::EOF { break; }
2251 let pkt = pktres.unwrap();
2252 println!("Got {}", pkt);