1 use nihav_core::demuxers::*;
2 use nihav_registry::register::*;
5 ($a:expr, $b:expr, $c:expr, $d:expr) => ({
6 (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
9 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
14 fn skip64(&mut self, size: u64) -> ByteIOResult<()>;
17 impl<'a> Skip64 for ByteReader<'a> {
18 fn skip64(&mut self, size: u64) -> ByteIOResult<()> {
19 if (size as usize as u64) != size {
20 self.seek(SeekFrom::Current(size as i64))?;
22 self.read_skip(size as usize)?;
28 fn read_chunk_header(br: &mut ByteReader) -> DemuxerResult<(u32, u64)> {
29 let size = br.read_u32be()?;
30 let ctype = br.read_u32be()?;
32 Ok((ctype, br.left() as u64))
34 let size64 = br.read_u64be()?;
35 validate!(size64 >= 16);
36 Ok((ctype, size64 - 16))
39 Ok((ctype, (size as u64) - 8))
43 fn read_palette(br: &mut ByteReader, size: u64, pal: &mut Vec<u16>) -> DemuxerResult<u64> {
44 let _seed = br.read_u32be()?;
45 let _flags = br.read_u16be()?;
46 let palsize = (br.read_u16be()? as usize) + 1;
47 validate!(palsize <= 256);
48 validate!((palsize as u64) * 8 + 8 == size);
49 pal.resize(palsize * 4, 0);
51 let a = br.read_u16be()?;
52 let r = br.read_u16be()?;
53 let g = br.read_u16be()?;
54 let b = br.read_u16be()?;
63 struct RootChunkHandler {
65 parse: fn(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64>,
68 struct TrackChunkHandler {
70 parse: fn(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64>,
73 const IGNORED_CHUNKS: &[u32] = &[
74 mktag!(b"free"), mktag!(b"skip"), mktag!(b"udta"), mktag!(b"wide")
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 },
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<()> {
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 {
96 if IGNORED_CHUNKS.contains(&ctype) {
97 self.src.skip64(size)?;
100 let handler = $handlers.iter().find(|x| x.ctype == ctype);
102 if let Some(ref handler) = handler {
103 read_size = (handler.parse)(self, strmgr, size)?;
105 println!("skipping unknown chunk {:08X} size {}", ctype, size);
108 validate!(read_size <= size);
109 self.src.skip64(size - read_size)?;
112 validate!(self.src.tell() == list_end);
116 (track; $name: expr, $fname: ident, $handlers: ident) => {
117 fn $fname(&mut self, br: &mut ByteReader, size: u64) -> DemuxerResult<()> {
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 {
128 if IGNORED_CHUNKS.contains(&ctype) {
132 let handler = $handlers.iter().find(|x| x.ctype == ctype);
134 if let Some(ref handler) = handler {
135 read_size = (handler.parse)(self, br, size)?;
139 validate!(read_size <= size);
140 br.skip64(size - read_size)?;
143 validate!(br.tell() == list_end);
149 fn skip_chunk(_track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
154 fn read_ftyp(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
155 dmx.src.skip64(size)?;
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)?;
166 fn read_moov(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
167 dmx.read_moov(strmgr, size)?;
171 const MOOV_CHUNK_HANDLERS: &[RootChunkHandler] = &[
172 RootChunkHandler { ctype: mktag!(b"mvhd"), parse: read_mvhd },
173 RootChunkHandler { ctype: mktag!(b"ctab"), parse: read_ctab },
174 RootChunkHandler { ctype: mktag!(b"trak"), parse: read_trak },
175 RootChunkHandler { ctype: mktag!(b"meta"), parse: read_meta },
178 fn read_mvhd(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
179 const KNOWN_MVHD_SIZE: u64 = 100;
180 let br = &mut dmx.src;
181 validate!(size >= KNOWN_MVHD_SIZE);
182 let version = br.read_byte()?;
183 validate!(version == 0);
184 let _flags = br.read_u24be()?;
185 let _ctime = br.read_u32be()?;
186 let _mtime = br.read_u32be()?;
187 let tscale = br.read_u32be()?;
188 let duration = br.read_u32be()?;
189 let _pref_rate = br.read_u32be()?;
190 let _pref_volume = br.read_u16be()?;
192 br.read_skip(36)?; // matrix
193 let _preview_time = br.read_u32be()?;
194 let _preview_duration = br.read_u32be()?;
195 let _poster_time = br.read_u32be()?;
196 let _sel_time = br.read_u32be()?;
197 let _sel_duration = br.read_u32be()?;
198 let _cur_time = br.read_u32be()?;
199 let _next_track_id = br.read_u32be()?;
200 dmx.duration = duration;
206 fn read_ctab(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
207 read_palette(&mut dmx.src, size, &mut dmx.pal)
210 fn read_meta(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
211 dmx.src.skip64(size)?;
215 fn read_trak(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
216 let mut track = Track::new(dmx.cur_track as u32, dmx.tb_den);
217 track.read_trak(&mut dmx.src, size)?;
218 validate!(track.tkhd_found && track.stsd_found);
219 validate!(strmgr.get_stream_by_id(track.track_id).is_none());
222 std::mem::swap(&mut track.stream, &mut str);
223 if let Some(stream) = str {
224 let str_id = strmgr.add_stream(stream).unwrap();
225 track.track_str_id = str_id;
227 dmx.tracks.push(track);
231 const TRAK_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
232 TrackChunkHandler { ctype: mktag!(b"clip"), parse: skip_chunk },
233 TrackChunkHandler { ctype: mktag!(b"matt"), parse: skip_chunk },
234 TrackChunkHandler { ctype: mktag!(b"edts"), parse: skip_chunk },
235 TrackChunkHandler { ctype: mktag!(b"tref"), parse: skip_chunk },
236 TrackChunkHandler { ctype: mktag!(b"load"), parse: skip_chunk },
237 TrackChunkHandler { ctype: mktag!(b"imap"), parse: skip_chunk },
238 TrackChunkHandler { ctype: mktag!(b"tkhd"), parse: read_tkhd },
239 TrackChunkHandler { ctype: mktag!(b"mdia"), parse: read_mdia },
242 fn read_tkhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
243 const KNOWN_TKHD_SIZE: u64 = 84;
244 validate!(size >= KNOWN_TKHD_SIZE);
245 let version = br.read_byte()?;
246 validate!(version == 0);
247 let _flags = br.read_u24be()?;
248 let _ctime = br.read_u32be()?;
249 let _mtime = br.read_u32be()?;
250 let track_id = br.read_u32be()?;
252 let _duration = br.read_u32be()?;
254 let _layer = br.read_u16be()?;
255 let _alt_group = br.read_u16be()?;
256 let _volume = br.read_u16be()?;
258 br.read_skip(36)?; // matrix
259 let width = br.read_u32be()? as usize;
260 let height = br.read_u32be()? as usize;
261 track.width = width >> 16;
262 track.height = height >> 16;
263 track.track_id = track_id;
265 track.tkhd_found = true;
269 fn read_mdia(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
270 track.stream_type = StreamType::None;
271 track.read_mdia(br, size)?;
275 const MDIA_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
276 TrackChunkHandler { ctype: mktag!(b"mdhd"), parse: skip_chunk },
277 TrackChunkHandler { ctype: mktag!(b"hdlr"), parse: read_hdlr },
278 TrackChunkHandler { ctype: mktag!(b"minf"), parse: read_minf },
281 fn read_hdlr(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
282 const KNOWN_HDLR_SIZE: u64 = 24;
283 validate!(size >= KNOWN_HDLR_SIZE);
284 let version = br.read_byte()?;
285 validate!(version == 0);
286 let flags = br.read_u24be()?;
287 validate!(flags == 0);
288 let comp_type = br.read_u32be()?;
289 let comp_subtype = br.read_u32be()?;
290 let _comp_manufacturer = br.read_u32be()?;
291 let _comp_flags = br.read_u32be()?;
292 let _comp_flags_mask = br.read_u32be()?;
294 if comp_type == mktag!(b"mhlr") {
295 if comp_subtype == mktag!(b"vide") {
296 track.stream_type = StreamType::Video;
297 } else if comp_subtype == mktag!(b"soun") {
298 track.stream_type = StreamType::Audio;
300 track.stream_type = StreamType::Data;
302 } else if comp_type == mktag!(b"dhlr") {
303 track.stream_type = StreamType::Data;
305 println!("Unknown stream type");
306 track.stream_type = StreamType::Data;
312 fn read_minf(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
313 track.read_minf(br, size)?;
317 const MINF_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
318 TrackChunkHandler { ctype: mktag!(b"hdlr"), parse: skip_chunk },
319 TrackChunkHandler { ctype: mktag!(b"dinf"), parse: skip_chunk },
320 TrackChunkHandler { ctype: mktag!(b"vmhd"), parse: read_vmhd },
321 TrackChunkHandler { ctype: mktag!(b"smhd"), parse: read_smhd },
322 TrackChunkHandler { ctype: mktag!(b"gmhd"), parse: read_gmhd },
323 TrackChunkHandler { ctype: mktag!(b"gmin"), parse: read_gmin },
324 TrackChunkHandler { ctype: mktag!(b"stbl"), parse: read_stbl },
327 fn read_vmhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
328 const KNOWN_VMHD_SIZE: u64 = 12;
329 validate!(track.stream_type == StreamType::Video);
330 validate!(size >= KNOWN_VMHD_SIZE);
331 let version = br.read_byte()?;
332 validate!(version == 0);
333 let _flags = br.read_u24be()?;
334 br.read_skip(2)?; // graphics mode
335 br.read_skip(6)?; // opcolor
339 fn read_smhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
340 const KNOWN_SMHD_SIZE: u64 = 8;
341 validate!(track.stream_type == StreamType::Audio);
342 validate!(size >= KNOWN_SMHD_SIZE);
343 let version = br.read_byte()?;
344 validate!(version == 0);
345 let _flags = br.read_u24be()?;
346 br.read_skip(2)?; // balance
351 fn read_gmhd(track: &mut Track, _br: &mut ByteReader, _size: u64) -> DemuxerResult<u64> {
352 validate!(track.stream_type == StreamType::Data);
356 fn read_gmin(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
357 validate!(track.stream_type == StreamType::Data);
358 const KNOWN_GMIN_SIZE: u64 = 16;
359 validate!(size >= KNOWN_GMIN_SIZE);
360 let version = br.read_byte()?;
361 validate!(version == 0);
362 let _flags = br.read_u24be()?;
363 br.read_skip(2)?; // graphics mode
364 br.read_skip(6)?; // opcolor
365 br.read_skip(2)?; // balance
370 fn read_stbl(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
371 track.read_stbl(br, size)?;
375 const STBL_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
376 TrackChunkHandler { ctype: mktag!(b"stsd"), parse: read_stsd },
377 TrackChunkHandler { ctype: mktag!(b"stts"), parse: skip_chunk },
378 TrackChunkHandler { ctype: mktag!(b"stss"), parse: read_stss },
379 TrackChunkHandler { ctype: mktag!(b"stsc"), parse: read_stsc },
380 TrackChunkHandler { ctype: mktag!(b"stsz"), parse: read_stsz },
381 TrackChunkHandler { ctype: mktag!(b"stco"), parse: read_stco },
382 TrackChunkHandler { ctype: mktag!(b"stsh"), parse: skip_chunk },
385 fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
386 const KNOWN_STSD_SIZE: u64 = 24;
387 validate!(size >= KNOWN_STSD_SIZE);
388 let start_pos = br.tell();
389 let version = br.read_byte()?;
390 validate!(version == 0);
391 let _flags = br.read_u24be()?;
392 let entries = br.read_u32be()?;
393 validate!(entries > 0);
394 let esize = br.read_u32be()? as u64;
395 validate!(esize + 8 <= size);
396 let mut fcc = [0u8; 4];
397 br.read_buf(&mut fcc)?;
399 let _data_ref = br.read_u16be()?;
404 match track.stream_type {
405 StreamType::Video => {
406 let _ver = br.read_u16be()?;
407 let _revision = br.read_u16le()?;
408 let _vendor = br.read_u32be()?;
409 let _temp_quality = br.read_u32be()?;
410 let _spat_quality = br.read_u32be()?;
411 let width = br.read_u16be()? as usize;
412 let height = br.read_u16be()? as usize;
413 let _hor_res = br.read_u32be()?;
414 let _vert_res = br.read_u32be()?;
415 let data_size = br.read_u32be()?;
416 validate!(data_size == 0);
417 let _frame_count = br.read_u16be()? as usize;
418 let _cname_len = br.read_byte()? as usize;
419 br.read_skip(31)?; // actual compressor name
420 let depth = br.read_u16be()?;
421 let ctable_id = br.read_u16be()?;
422 validate!((depth <= 8) || (ctable_id == 0xFFFF));
424 let max_pal_size = start_pos + size - br.tell();
425 read_palette(br, max_pal_size, &mut track.pal)?;
427 // todo other atoms, put as extradata
428 let cname = if let Some(name) = find_codec_from_mov_video_fourcc(&fcc) {
430 } else if let Some(name) = find_codec_from_avi_fourcc(&fcc) {
435 let format = if depth > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
436 let vhdr = NAVideoInfo::new(width, height, false, format);
438 if br.tell() - start_pos + 4 < size {
439 //todo skip various common atoms
440 let edata_size = br.read_u32be()? as usize;
441 let mut buf = vec![0; edata_size];
442 br.read_buf(buf.as_mut_slice())?;
447 codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), edata);
449 StreamType::Audio => {
450 let _ver = br.read_u16be()?;
451 let _revision = br.read_u16le()?;
452 let _vendor = br.read_u32be()?;
453 let nchannels = br.read_u16be()?;
454 validate!(nchannels <= 64);
455 let sample_size = br.read_u16be()?;
456 validate!(sample_size <= 128);
457 let _compr_id = br.read_u16be()?;
458 let packet_size = br.read_u16be()? as usize;
459 validate!(packet_size == 0);
460 let sample_rate = br.read_u32be()?;
461 validate!(sample_rate > 0);
462 let cname = if let Some(name) = find_codec_from_mov_audio_fourcc(&fcc) {
464 } 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]))) {
469 //todo adjust format for various PCM kinds
470 let soniton = NASoniton::new(sample_size as u8, SONITON_FLAG_SIGNED | SONITON_FLAG_BE);
472 let ahdr = NAAudioInfo::new(sample_rate >> 16, nchannels as u8, soniton, block_align);
474 codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
475 track.channels = nchannels as usize;
476 track.bits = sample_size as usize;
478 StreamType::None => {
479 return Err(DemuxerError::InvalidData);
482 //todo put it all into extradata
484 codec_info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
487 let read_size = br.tell() - start_pos;
488 validate!(read_size <= size);
489 track.stream = Some(NAStream::new(track.stream_type, track.track_no, codec_info, 1, track.tb_den));
490 track.stsd_found = true;
494 fn read_stss(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
495 let version = br.read_byte()?;
496 validate!(version == 0);
497 let _flags = br.read_u24be()?;
498 let entries = br.read_u32be()? as usize;
499 validate!(entries < ((std::u32::MAX >> 2) - 8) as usize);
500 validate!((entries * 4 + 8) as u64 == size);
501 track.keyframes = Vec::with_capacity(entries);
502 let mut last_sample_no = 0;
503 for _ in 0..entries {
504 let sample_no = br.read_u32be()?;
505 validate!(sample_no > last_sample_no);
506 track.keyframes.push(sample_no);
507 last_sample_no = sample_no;
512 fn read_stsc(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
513 let version = br.read_byte()?;
514 validate!(version == 0);
515 let _flags = br.read_u24be()?;
516 let entries = br.read_u32be()? as usize;
517 validate!(entries < ((std::u32::MAX / 12) - 8) as usize);
518 validate!((entries * 12 + 8) as u64 == size);
519 track.sample_map = Vec::with_capacity(entries);
520 let mut last_sample_no = 0;
521 for _i in 0..entries {
522 let sample_no = br.read_u32be()?;
523 validate!(sample_no > last_sample_no);
524 let nsamples = br.read_u32be()?;
525 let _sample_desc = br.read_u32be()?;
526 track.sample_map.push((sample_no, nsamples));
527 last_sample_no = sample_no;
532 fn read_stsz(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
533 let version = br.read_byte()?;
534 validate!(version == 0);
535 let _flags = br.read_u24be()?;
536 let sample_size = br.read_u32be()?;
537 if sample_size != 0 {
538 track.sample_size = sample_size;
541 let entries = br.read_u32be()? as usize;
542 validate!((entries * 4 + 12) as u64 == size);
543 track.chunk_sizes = Vec::with_capacity(entries);
544 for _ in 0..entries {
545 let sample_size = br.read_u32be()?;
546 track.chunk_sizes.push(sample_size);
552 fn read_stco(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
553 let version = br.read_byte()?;
554 validate!(version == 0);
555 let _flags = br.read_u24be()?;
556 let entries = br.read_u32be()? as usize;
557 validate!((entries * 4 + 8) as u64 == size);
558 track.chunk_offsets = Vec::with_capacity(entries);
559 for _i in 0..entries {
560 let sample_offset = br.read_u32be()?;
561 track.chunk_offsets.push(u64::from(sample_offset));
566 struct MOVDemuxer<'a> {
567 src: &'a mut ByteReader<'a>,
586 stream_type: StreamType,
593 chunk_sizes: Vec<u32>,
594 chunk_offsets: Vec<u64>,
595 sample_map: Vec<(u32, u32)>,
597 stream: Option<NAStream>,
606 fn new(track_no: u32, tb_den: u32) -> Self {
614 stream_type: StreamType::None,
620 keyframes: Vec::new(),
621 chunk_sizes: Vec::new(),
622 chunk_offsets: Vec::new(),
623 sample_map: Vec::new(),
634 read_chunk_list!(track; "trak", read_trak, TRAK_CHUNK_HANDLERS);
635 read_chunk_list!(track; "mdia", read_mdia, MDIA_CHUNK_HANDLERS);
636 read_chunk_list!(track; "minf", read_minf, MINF_CHUNK_HANDLERS);
637 read_chunk_list!(track; "stbl", read_stbl, STBL_CHUNK_HANDLERS);
638 fn fill_seek_index(&self, seek_index: &mut SeekIndex) {
639 if self.keyframes.len() > 0 {
640 seek_index.mode = SeekIndexMode::Present;
642 for kf_time in self.keyframes.iter() {
643 let pts = u64::from(*kf_time - 1);
644 let time = NATimeInfo::ts_to_time(pts, 1000, 1, self.tb_den);
645 let idx = (*kf_time - 1) as usize;
646 if idx < self.chunk_offsets.len() {
647 let pos = self.chunk_offsets[idx];
648 seek_index.add_entry(self.track_no as u32, SeekEntry { time, pts, pos });
652 fn calculate_chunk_size(&self, nsamp: usize) -> usize {
654 self.sample_size as usize
657 b"NONE" | b"raw " | b"twos" | b"sowt" => {
658 (nsamp * self.bits * self.channels + 7) >> 3
661 let nblocks = (nsamp + 63) >> 6;
662 nblocks * 34 * self.channels
665 (nsamp + 5) / 6 * 2 * self.channels
668 (nsamp + 5) / 6 * self.channels
670 b"in24" => nsamp * 3 * self.channels,
671 b"in32" | b"fl32" => nsamp * 4 * self.channels,
672 b"fl64" => nsamp * 8 * self.channels,
673 b"ulaw" | b"alaw" => nsamp,
674 b"ms\x00\x02" => { //MS ADPCM
675 ((nsamp - 1) / 2 + 7) * self.channels
677 b"ms\x00\x21" => { //IMA ADPCM
678 (nsamp / 2 + 4) * self.channels
680 _ => self.sample_size as usize,
684 fn get_next_chunk(&mut self) -> Option<(NATimeInfo, u64, usize)> {
685 let pts = NATimeInfo::new(Some(self.cur_sample as u64), None, None, 1, self.tb_den);
687 if self.chunk_offsets.len() == self.chunk_sizes.len() { // simple one-to-one mapping
688 if self.cur_sample >= self.chunk_sizes.len() {
691 let offset = self.chunk_offsets[self.cur_sample];
692 let size = self.chunk_sizes[self.cur_sample] as usize;
693 self.cur_sample += 1;
694 Some((pts, offset, size))
696 if self.samples_left == 0 {
697 if self.cur_chunk >= self.chunk_offsets.len() {
700 for (idx, samples) in self.sample_map.iter() {
701 if *idx as usize <= self.cur_chunk + 1 {
702 self.samples_left = *samples as usize;
707 self.last_offset = self.chunk_offsets[self.cur_chunk];
710 let offset = self.last_offset;
711 let size = self.get_size(self.cur_sample);
712 self.last_offset += size as u64;
713 if self.stream_type == StreamType::Video {
714 self.samples_left -= 1;
716 self.samples_left = 0;
718 self.cur_sample += 1;
719 Some((pts, offset, size))
722 fn get_size(&self, sample_no: usize) -> usize {
723 if self.chunk_sizes.len() > 0 {
724 self.chunk_sizes[sample_no] as usize
725 } else if self.sample_map.len() > 0 {
727 for (idx, samples) in self.sample_map.iter() {
728 if *idx as usize <= self.cur_chunk {
734 self.calculate_chunk_size(nsamp as usize)
736 self.sample_size as usize
739 fn seek(&mut self, pts: u64) {
740 self.cur_sample = pts as usize;
741 self.samples_left = 0;
742 if self.stream_type == StreamType::Audio {
743 self.cur_chunk = self.cur_sample;
744 } else if self.chunk_offsets.len() != self.chunk_sizes.len() && self.sample_map.len() > 0{
747 let mut cmap = self.sample_map.iter();
748 let mut cur_samps = 0;
749 let (mut next_idx, mut next_samples) = cmap.next().unwrap();
751 if self.cur_chunk == next_idx as usize {
752 self.samples_left = cur_samps;
753 cur_samps = next_samples as usize;
754 if let Some((new_idx, new_samples)) = cmap.next() {
756 next_samples = *new_samples;
760 if csamp >= self.cur_sample {
761 self.last_offset = self.chunk_offsets[self.cur_chunk];
767 for sample_no in csamp..self.cur_chunk {
768 self.last_offset += self.get_size(sample_no) as u64;
770 self.samples_left = self.cur_sample - csamp - cur_samps;
775 impl<'a> DemuxCore<'a> for MOVDemuxer<'a> {
776 fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
777 self.read_root(strmgr)?;
778 validate!(self.mdat_pos > 0);
779 validate!(self.tracks.len() > 0);
780 for track in self.tracks.iter() {
781 track.fill_seek_index(seek_index);
783 self.src.seek(SeekFrom::Start(self.mdat_pos))?;
788 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
789 if self.tracks.len() == 0 {
790 return Err(DemuxerError::EOF);
792 for _ in 0..self.tracks.len() {
793 if self.cur_track >= self.tracks.len() {
796 let track = &mut self.tracks[self.cur_track];
798 if let Some((pts, offset, size)) = track.get_next_chunk() {
799 let str = strmgr.get_stream(track.track_str_id);
800 if str.is_none() { return Err(DemuxerError::InvalidData); }
801 let stream = str.unwrap();
802 self.src.seek(SeekFrom::Start(offset))?;
803 let pkt = self.src.read_packet(stream, pts, false, size)?;
807 return Err(DemuxerError::EOF);
810 fn seek(&mut self, time: u64, seek_index: &SeekIndex) -> DemuxerResult<()> {
811 let ret = seek_index.find_pos(time);
813 return Err(DemuxerError::SeekError);
815 let seek_info = ret.unwrap();
816 for track in self.tracks.iter_mut() {
817 track.seek(seek_info.pts);
823 impl<'a> MOVDemuxer<'a> {
824 fn new(io: &'a mut ByteReader<'a>) -> Self {
830 tracks: Vec::with_capacity(2),
837 fn read_root(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
839 while self.src.left() != 0 {
840 let ret = read_chunk_header(&mut self.src);
841 if ret.is_err() { break; }
842 let (ctype, size) = ret.unwrap();
843 if IGNORED_CHUNKS.contains(&ctype) {
844 self.src.skip64(size)?;
847 let handler = ROOT_CHUNK_HANDLERS.iter().find(|x| x.ctype == ctype);
849 if let Some(ref handler) = handler {
850 read_size = (handler.parse)(self, strmgr, size)?;
852 println!("skipping unknown chunk {:08X} size {}", ctype, size);
855 validate!(read_size <= size);
856 self.src.skip64(size - read_size)?;
858 //todo check if all needed chunks are found
861 read_chunk_list!(root; "moov", read_moov, MOOV_CHUNK_HANDLERS);
864 pub struct MOVDemuxerCreator { }
866 impl DemuxerCreator for MOVDemuxerCreator {
867 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
868 Box::new(MOVDemuxer::new(br))
870 fn get_name(&self) -> &'static str { "mov" }
879 fn test_mov_demux() {
880 let mut file = File::open("assets/Indeo/cubes.mov").unwrap();
881 let mut fr = FileReader::new_read(&mut file);
882 let mut br = ByteReader::new(&mut fr);
883 let mut dmx = MOVDemuxer::new(&mut br);
884 let mut sm = StreamManager::new();
885 let mut si = SeekIndex::new();
886 dmx.open(&mut sm, &mut si).unwrap();
889 let pktres = dmx.get_frame(&mut sm);
890 if let Err(e) = pktres {
891 if e == DemuxerError::EOF { break; }
894 let pkt = pktres.unwrap();
895 println!("Got {}", pkt);