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"mdat"), parse: read_mdat },
79 RootChunkHandler { ctype: mktag!(b"moov"), parse: read_moov },
82 macro_rules! read_chunk_list {
83 (root; $name: expr, $fname: ident, $handlers: ident) => {
84 fn $fname(&mut self, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<()> {
86 validate!(self.depth < 32);
87 let list_end = self.src.tell() + size;
88 while self.src.tell() < list_end {
89 let ret = read_chunk_header(&mut self.src);
90 if ret.is_err() { break; }
91 let (ctype, size) = ret.unwrap();
92 if self.src.tell() + size > list_end {
95 if IGNORED_CHUNKS.contains(&ctype) {
96 self.src.skip64(size)?;
99 let handler = $handlers.iter().find(|x| x.ctype == ctype);
101 if let Some(ref handler) = handler {
102 read_size = (handler.parse)(self, strmgr, size)?;
104 println!("skipping unknown chunk {:08X} size {}", ctype, size);
107 validate!(read_size <= size);
108 self.src.skip64(size - read_size)?;
111 validate!(self.src.tell() == list_end);
115 (track; $name: expr, $fname: ident, $handlers: ident) => {
116 fn $fname(&mut self, br: &mut ByteReader, size: u64) -> DemuxerResult<()> {
118 validate!(self.depth < 32);
119 let list_end = br.tell() + size;
120 while br.tell() < list_end {
121 let ret = read_chunk_header(br);
122 if ret.is_err() { break; }
123 let (ctype, size) = ret.unwrap();
124 if br.tell() + size > list_end {
127 if IGNORED_CHUNKS.contains(&ctype) {
131 let handler = $handlers.iter().find(|x| x.ctype == ctype);
133 if let Some(ref handler) = handler {
134 read_size = (handler.parse)(self, br, size)?;
138 validate!(read_size <= size);
139 br.skip64(size - read_size)?;
142 validate!(br.tell() == list_end);
148 fn skip_chunk(_track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
153 fn read_mdat(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
154 dmx.mdat_pos = dmx.src.tell();
155 dmx.mdat_size = size;
156 dmx.src.skip64(size)?;
160 fn read_moov(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
161 dmx.read_moov(strmgr, size)?;
165 const MOOV_CHUNK_HANDLERS: &[RootChunkHandler] = &[
166 RootChunkHandler { ctype: mktag!(b"mvhd"), parse: read_mvhd },
167 RootChunkHandler { ctype: mktag!(b"ctab"), parse: read_ctab },
168 RootChunkHandler { ctype: mktag!(b"trak"), parse: read_trak },
171 fn read_mvhd(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
172 const KNOWN_MVHD_SIZE: u64 = 100;
173 let br = &mut dmx.src;
174 validate!(size >= KNOWN_MVHD_SIZE);
175 let version = br.read_byte()?;
176 validate!(version == 0);
177 let _flags = br.read_u24be()?;
178 let _ctime = br.read_u32be()?;
179 let _mtime = br.read_u32be()?;
180 let tscale = br.read_u32be()?;
181 let duration = br.read_u32be()?;
182 let _pref_rate = br.read_u32be()?;
183 let _pref_volume = br.read_u16be()?;
185 br.read_skip(36)?; // matrix
186 let _preview_time = br.read_u32be()?;
187 let _preview_duration = br.read_u32be()?;
188 let _poster_time = br.read_u32be()?;
189 let _sel_time = br.read_u32be()?;
190 let _sel_duration = br.read_u32be()?;
191 let _cur_time = br.read_u32be()?;
192 let _next_track_id = br.read_u32be()?;
193 dmx.duration = duration;
199 fn read_ctab(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
200 read_palette(&mut dmx.src, size, &mut dmx.pal)
203 fn read_trak(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
204 let mut track = Track::new(dmx.cur_track as u32, dmx.tb_den);
205 track.read_trak(&mut dmx.src, size)?;
206 validate!(track.tkhd_found && track.stsd_found);
207 validate!(strmgr.get_stream_by_id(track.track_id).is_none());
210 std::mem::swap(&mut track.stream, &mut str);
211 if let Some(stream) = str {
212 let str_id = strmgr.add_stream(stream).unwrap();
213 track.track_str_id = str_id;
215 dmx.tracks.push(track);
219 const TRAK_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
220 TrackChunkHandler { ctype: mktag!(b"clip"), parse: skip_chunk },
221 TrackChunkHandler { ctype: mktag!(b"matt"), parse: skip_chunk },
222 TrackChunkHandler { ctype: mktag!(b"edts"), parse: skip_chunk },
223 TrackChunkHandler { ctype: mktag!(b"tref"), parse: skip_chunk },
224 TrackChunkHandler { ctype: mktag!(b"load"), parse: skip_chunk },
225 TrackChunkHandler { ctype: mktag!(b"imap"), parse: skip_chunk },
226 TrackChunkHandler { ctype: mktag!(b"tkhd"), parse: read_tkhd },
227 TrackChunkHandler { ctype: mktag!(b"mdia"), parse: read_mdia },
230 fn read_tkhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
231 const KNOWN_TKHD_SIZE: u64 = 84;
232 validate!(size >= KNOWN_TKHD_SIZE);
233 let version = br.read_byte()?;
234 validate!(version == 0);
235 let _flags = br.read_u24be()?;
236 let _ctime = br.read_u32be()?;
237 let _mtime = br.read_u32be()?;
238 let track_id = br.read_u32be()?;
240 let _duration = br.read_u32be()?;
242 let _layer = br.read_u16be()?;
243 let _alt_group = br.read_u16be()?;
244 let _volume = br.read_u16be()?;
246 br.read_skip(36)?; // matrix
247 let width = br.read_u32be()? as usize;
248 let height = br.read_u32be()? as usize;
249 track.width = width >> 16;
250 track.height = height >> 16;
251 track.track_id = track_id;
253 track.tkhd_found = true;
257 fn read_mdia(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
258 track.stream_type = StreamType::None;
259 track.read_mdia(br, size)?;
263 const MDIA_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
264 TrackChunkHandler { ctype: mktag!(b"mdhd"), parse: skip_chunk },
265 TrackChunkHandler { ctype: mktag!(b"hdlr"), parse: read_hdlr },
266 TrackChunkHandler { ctype: mktag!(b"minf"), parse: read_minf },
269 fn read_hdlr(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
270 const KNOWN_HDLR_SIZE: u64 = 24;
271 validate!(size >= KNOWN_HDLR_SIZE);
272 let version = br.read_byte()?;
273 validate!(version == 0);
274 let flags = br.read_u24be()?;
275 validate!(flags == 0);
276 let comp_type = br.read_u32be()?;
277 let comp_subtype = br.read_u32be()?;
278 let _comp_manufacturer = br.read_u32be()?;
279 let _comp_flags = br.read_u32be()?;
280 let _comp_flags_mask = br.read_u32be()?;
282 if comp_type == mktag!(b"mhlr") {
283 if comp_subtype == mktag!(b"vide") {
284 track.stream_type = StreamType::Video;
285 } else if comp_subtype == mktag!(b"soun") {
286 track.stream_type = StreamType::Audio;
288 track.stream_type = StreamType::Data;
290 } else if comp_type == mktag!(b"dhlr") {
291 track.stream_type = StreamType::Data;
293 println!("Unknown stream type");
294 track.stream_type = StreamType::Data;
300 fn read_minf(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
301 track.read_minf(br, size)?;
305 const MINF_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
306 TrackChunkHandler { ctype: mktag!(b"hdlr"), parse: skip_chunk },
307 TrackChunkHandler { ctype: mktag!(b"dinf"), parse: skip_chunk },
308 TrackChunkHandler { ctype: mktag!(b"vmhd"), parse: read_vmhd },
309 TrackChunkHandler { ctype: mktag!(b"smhd"), parse: read_smhd },
310 TrackChunkHandler { ctype: mktag!(b"gmhd"), parse: read_gmhd },
311 TrackChunkHandler { ctype: mktag!(b"gmin"), parse: read_gmin },
312 TrackChunkHandler { ctype: mktag!(b"stbl"), parse: read_stbl },
315 fn read_vmhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
316 const KNOWN_VMHD_SIZE: u64 = 12;
317 validate!(track.stream_type == StreamType::Video);
318 validate!(size >= KNOWN_VMHD_SIZE);
319 let version = br.read_byte()?;
320 validate!(version == 0);
321 let _flags = br.read_u24be()?;
322 br.read_skip(2)?; // graphics mode
323 br.read_skip(6)?; // opcolor
327 fn read_smhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
328 const KNOWN_SMHD_SIZE: u64 = 8;
329 validate!(track.stream_type == StreamType::Audio);
330 validate!(size >= KNOWN_SMHD_SIZE);
331 let version = br.read_byte()?;
332 validate!(version == 0);
333 let _flags = br.read_u24be()?;
334 br.read_skip(2)?; // balance
339 fn read_gmhd(track: &mut Track, _br: &mut ByteReader, _size: u64) -> DemuxerResult<u64> {
340 validate!(track.stream_type == StreamType::Data);
344 fn read_gmin(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
345 validate!(track.stream_type == StreamType::Data);
346 const KNOWN_GMIN_SIZE: u64 = 16;
347 validate!(size >= KNOWN_GMIN_SIZE);
348 let version = br.read_byte()?;
349 validate!(version == 0);
350 let _flags = br.read_u24be()?;
351 br.read_skip(2)?; // graphics mode
352 br.read_skip(6)?; // opcolor
353 br.read_skip(2)?; // balance
358 fn read_stbl(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
359 track.read_stbl(br, size)?;
363 const STBL_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
364 TrackChunkHandler { ctype: mktag!(b"stsd"), parse: read_stsd },
365 TrackChunkHandler { ctype: mktag!(b"stts"), parse: skip_chunk },
366 TrackChunkHandler { ctype: mktag!(b"stss"), parse: read_stss },
367 TrackChunkHandler { ctype: mktag!(b"stsc"), parse: read_stsc },
368 TrackChunkHandler { ctype: mktag!(b"stsz"), parse: read_stsz },
369 TrackChunkHandler { ctype: mktag!(b"stco"), parse: read_stco },
370 TrackChunkHandler { ctype: mktag!(b"stsh"), parse: skip_chunk },
373 fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
374 const KNOWN_STSD_SIZE: u64 = 24;
375 validate!(size >= KNOWN_STSD_SIZE);
376 let start_pos = br.tell();
377 let version = br.read_byte()?;
378 validate!(version == 0);
379 let _flags = br.read_u24be()?;
380 let entries = br.read_u32be()?;
381 validate!(entries > 0);
382 let esize = br.read_u32be()? as u64;
383 validate!(esize + 8 <= size);
384 let mut fcc = [0u8; 4];
385 br.read_buf(&mut fcc)?;
387 let _data_ref = br.read_u16be()?;
392 match track.stream_type {
393 StreamType::Video => {
394 let _ver = br.read_u16be()?;
395 let _revision = br.read_u16le()?;
396 let _vendor = br.read_u32be()?;
397 let _temp_quality = br.read_u32be()?;
398 let _spat_quality = br.read_u32be()?;
399 let width = br.read_u16be()? as usize;
400 let height = br.read_u16be()? as usize;
401 let _hor_res = br.read_u32be()?;
402 let _vert_res = br.read_u32be()?;
403 let data_size = br.read_u32be()?;
404 validate!(data_size == 0);
405 let _frame_count = br.read_u16be()? as usize;
406 let _cname_len = br.read_byte()? as usize;
407 br.read_skip(31)?; // actual compressor name
408 let depth = br.read_u16be()?;
409 let ctable_id = br.read_u16be()?;
410 validate!((depth <= 8) || (ctable_id == 0xFFFF));
412 let max_pal_size = start_pos + size - br.tell();
413 read_palette(br, max_pal_size, &mut track.pal)?;
415 // todo other atoms, put as extradata
416 let cname = if let Some(name) = find_codec_from_mov_video_fourcc(&fcc) {
418 } else if let Some(name) = find_codec_from_avi_fourcc(&fcc) {
423 let format = if depth > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
424 let vhdr = NAVideoInfo::new(width, height, false, format);
426 if br.tell() - start_pos + 4 < size {
427 //todo skip various common atoms
428 let edata_size = br.read_u32be()? as usize;
429 let mut buf = vec![0; edata_size];
430 br.read_buf(buf.as_mut_slice())?;
435 codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), edata);
437 StreamType::Audio => {
438 let _ver = br.read_u16be()?;
439 let _revision = br.read_u16le()?;
440 let _vendor = br.read_u32be()?;
441 let nchannels = br.read_u16be()?;
442 validate!(nchannels <= 64);
443 let sample_size = br.read_u16be()?;
444 validate!(sample_size <= 128);
445 let _compr_id = br.read_u16be()?;
446 let packet_size = br.read_u16be()? as usize;
447 validate!(packet_size == 0);
448 let sample_rate = br.read_u32be()?;
449 validate!(sample_rate > 0);
450 let cname = if let Some(name) = find_codec_from_mov_audio_fourcc(&fcc) {
452 } 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]))) {
457 //todo adjust format for various PCM kinds
458 let soniton = NASoniton::new(sample_size as u8, SONITON_FLAG_SIGNED | SONITON_FLAG_BE);
460 let ahdr = NAAudioInfo::new(sample_rate >> 16, nchannels as u8, soniton, block_align);
462 codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
463 track.channels = nchannels as usize;
464 track.bits = sample_size as usize;
466 StreamType::None => {
467 return Err(DemuxerError::InvalidData);
470 //todo put it all into extradata
472 codec_info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
475 let read_size = br.tell() - start_pos;
476 validate!(read_size <= size);
477 track.stream = Some(NAStream::new(track.stream_type, track.track_no, codec_info, 1, track.tb_den));
478 track.stsd_found = true;
482 fn read_stss(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
483 let version = br.read_byte()?;
484 validate!(version == 0);
485 let _flags = br.read_u24be()?;
486 let entries = br.read_u32be()? as usize;
487 validate!(entries < ((std::u32::MAX >> 2) - 8) as usize);
488 validate!((entries * 4 + 8) as u64 == size);
489 track.keyframes = Vec::with_capacity(entries);
490 let mut last_sample_no = 0;
491 for _ in 0..entries {
492 let sample_no = br.read_u32be()?;
493 validate!(sample_no > last_sample_no);
494 track.keyframes.push(sample_no);
495 last_sample_no = sample_no;
500 fn read_stsc(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
501 let version = br.read_byte()?;
502 validate!(version == 0);
503 let _flags = br.read_u24be()?;
504 let entries = br.read_u32be()? as usize;
505 validate!(entries < ((std::u32::MAX / 12) - 8) as usize);
506 validate!((entries * 12 + 8) as u64 == size);
507 track.sample_map = Vec::with_capacity(entries);
508 let mut last_sample_no = 0;
509 for _i in 0..entries {
510 let sample_no = br.read_u32be()?;
511 validate!(sample_no > last_sample_no);
512 let nsamples = br.read_u32be()?;
513 let _sample_desc = br.read_u32be()?;
514 track.sample_map.push((sample_no, nsamples));
515 last_sample_no = sample_no;
520 fn read_stsz(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
521 let version = br.read_byte()?;
522 validate!(version == 0);
523 let _flags = br.read_u24be()?;
524 let sample_size = br.read_u32be()?;
525 if sample_size != 0 {
526 track.sample_size = sample_size;
529 let entries = br.read_u32be()? as usize;
530 validate!((entries * 4 + 12) as u64 == size);
531 track.chunk_sizes = Vec::with_capacity(entries);
532 for _ in 0..entries {
533 let sample_size = br.read_u32be()?;
534 track.chunk_sizes.push(sample_size);
540 fn read_stco(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
541 let version = br.read_byte()?;
542 validate!(version == 0);
543 let _flags = br.read_u24be()?;
544 let entries = br.read_u32be()? as usize;
545 validate!((entries * 4 + 8) as u64 == size);
546 track.chunk_offsets = Vec::with_capacity(entries);
547 for _i in 0..entries {
548 let sample_offset = br.read_u32be()?;
549 track.chunk_offsets.push(u64::from(sample_offset));
554 struct MOVDemuxer<'a> {
555 src: &'a mut ByteReader<'a>,
574 stream_type: StreamType,
581 chunk_sizes: Vec<u32>,
582 chunk_offsets: Vec<u64>,
583 sample_map: Vec<(u32, u32)>,
585 stream: Option<NAStream>,
594 fn new(track_no: u32, tb_den: u32) -> Self {
602 stream_type: StreamType::None,
608 keyframes: Vec::new(),
609 chunk_sizes: Vec::new(),
610 chunk_offsets: Vec::new(),
611 sample_map: Vec::new(),
622 read_chunk_list!(track; "trak", read_trak, TRAK_CHUNK_HANDLERS);
623 read_chunk_list!(track; "mdia", read_mdia, MDIA_CHUNK_HANDLERS);
624 read_chunk_list!(track; "minf", read_minf, MINF_CHUNK_HANDLERS);
625 read_chunk_list!(track; "stbl", read_stbl, STBL_CHUNK_HANDLERS);
626 fn fill_seek_index(&self, seek_index: &mut SeekIndex) {
627 if self.keyframes.len() > 0 {
628 seek_index.mode = SeekIndexMode::Present;
630 for kf_time in self.keyframes.iter() {
631 let pts = u64::from(*kf_time - 1);
632 let time = NATimeInfo::ts_to_time(pts, 1000, 1, self.tb_den);
633 let idx = (*kf_time - 1) as usize;
634 if idx < self.chunk_offsets.len() {
635 let pos = self.chunk_offsets[idx];
636 seek_index.add_entry(self.track_no as u32, SeekEntry { time, pts, pos });
640 fn calculate_chunk_size(&self, nsamp: usize) -> usize {
642 self.sample_size as usize
645 b"NONE" | b"raw " | b"twos" | b"sowt" => {
646 (nsamp * self.bits * self.channels + 7) >> 3
649 let nblocks = (nsamp + 63) >> 6;
650 nblocks * 34 * self.channels
653 (nsamp + 5) / 6 * 2 * self.channels
656 (nsamp + 5) / 6 * self.channels
658 b"in24" => nsamp * 3 * self.channels,
659 b"in32" | b"fl32" => nsamp * 4 * self.channels,
660 b"fl64" => nsamp * 8 * self.channels,
661 b"ulaw" | b"alaw" => nsamp,
662 b"ms\x00\x02" => { //MS ADPCM
663 ((nsamp - 1) / 2 + 7) * self.channels
665 b"ms\x00\x21" => { //IMA ADPCM
666 (nsamp / 2 + 4) * self.channels
668 _ => self.sample_size as usize,
672 fn get_next_chunk(&mut self) -> Option<(NATimeInfo, u64, usize)> {
673 let pts = NATimeInfo::new(Some(self.cur_sample as u64), None, None, 1, self.tb_den);
675 if self.chunk_offsets.len() == self.chunk_sizes.len() { // simple one-to-one mapping
676 if self.cur_sample >= self.chunk_sizes.len() {
679 let offset = self.chunk_offsets[self.cur_sample];
680 let size = self.chunk_sizes[self.cur_sample] as usize;
681 self.cur_sample += 1;
682 Some((pts, offset, size))
684 if self.samples_left == 0 {
685 if self.cur_chunk >= self.chunk_offsets.len() {
688 for (idx, samples) in self.sample_map.iter() {
689 if *idx as usize <= self.cur_chunk + 1 {
690 self.samples_left = *samples as usize;
695 self.last_offset = self.chunk_offsets[self.cur_chunk];
698 let offset = self.last_offset;
699 let size = self.get_size(self.cur_sample);
700 self.last_offset += size as u64;
701 if self.stream_type == StreamType::Video {
702 self.samples_left -= 1;
704 self.samples_left = 0;
706 self.cur_sample += 1;
707 Some((pts, offset, size))
710 fn get_size(&self, sample_no: usize) -> usize {
711 if self.chunk_sizes.len() > 0 {
712 self.chunk_sizes[sample_no] as usize
713 } else if self.sample_map.len() > 0 {
715 for (idx, samples) in self.sample_map.iter() {
716 if *idx as usize <= self.cur_chunk {
722 self.calculate_chunk_size(nsamp as usize)
724 self.sample_size as usize
727 fn seek(&mut self, pts: u64) {
728 self.cur_sample = pts as usize;
729 self.samples_left = 0;
730 if self.stream_type == StreamType::Audio {
731 self.cur_chunk = self.cur_sample;
732 } else if self.chunk_offsets.len() != self.chunk_sizes.len() && self.sample_map.len() > 0{
735 let mut cmap = self.sample_map.iter();
736 let mut cur_samps = 0;
737 let (mut next_idx, mut next_samples) = cmap.next().unwrap();
739 if self.cur_chunk == next_idx as usize {
740 self.samples_left = cur_samps;
741 cur_samps = next_samples as usize;
742 if let Some((new_idx, new_samples)) = cmap.next() {
744 next_samples = *new_samples;
748 if csamp >= self.cur_sample {
749 self.last_offset = self.chunk_offsets[self.cur_chunk];
755 for sample_no in csamp..self.cur_chunk {
756 self.last_offset += self.get_size(sample_no) as u64;
758 self.samples_left = self.cur_sample - csamp - cur_samps;
763 impl<'a> DemuxCore<'a> for MOVDemuxer<'a> {
764 fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
765 self.read_root(strmgr)?;
766 validate!(self.mdat_pos > 0);
767 validate!(self.tracks.len() > 0);
768 for track in self.tracks.iter() {
769 track.fill_seek_index(seek_index);
771 self.src.seek(SeekFrom::Start(self.mdat_pos))?;
776 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
777 if self.tracks.len() == 0 {
778 return Err(DemuxerError::EOF);
780 for _ in 0..self.tracks.len() {
781 if self.cur_track >= self.tracks.len() {
784 let track = &mut self.tracks[self.cur_track];
786 if let Some((pts, offset, size)) = track.get_next_chunk() {
787 let str = strmgr.get_stream(track.track_str_id);
788 if str.is_none() { return Err(DemuxerError::InvalidData); }
789 let stream = str.unwrap();
790 self.src.seek(SeekFrom::Start(offset))?;
791 let pkt = self.src.read_packet(stream, pts, false, size)?;
795 return Err(DemuxerError::EOF);
798 fn seek(&mut self, time: u64, seek_index: &SeekIndex) -> DemuxerResult<()> {
799 let ret = seek_index.find_pos(time);
801 return Err(DemuxerError::SeekError);
803 let seek_info = ret.unwrap();
804 for track in self.tracks.iter_mut() {
805 track.seek(seek_info.pts);
811 impl<'a> MOVDemuxer<'a> {
812 fn new(io: &'a mut ByteReader<'a>) -> Self {
818 tracks: Vec::with_capacity(2),
825 fn read_root(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
827 while self.src.left() != 0 {
828 let ret = read_chunk_header(&mut self.src);
829 if ret.is_err() { break; }
830 let (ctype, size) = ret.unwrap();
831 if IGNORED_CHUNKS.contains(&ctype) {
832 self.src.skip64(size)?;
835 let handler = ROOT_CHUNK_HANDLERS.iter().find(|x| x.ctype == ctype);
837 if let Some(ref handler) = handler {
838 read_size = (handler.parse)(self, strmgr, size)?;
840 println!("skipping unknown chunk {:08X} size {}", ctype, size);
843 validate!(read_size <= size);
844 self.src.skip64(size - read_size)?;
846 //todo check if all needed chunks are found
849 read_chunk_list!(root; "moov", read_moov, MOOV_CHUNK_HANDLERS);
852 pub struct MOVDemuxerCreator { }
854 impl DemuxerCreator for MOVDemuxerCreator {
855 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
856 Box::new(MOVDemuxer::new(br))
858 fn get_name(&self) -> &'static str { "mov" }
867 fn test_mov_demux() {
868 let mut file = File::open("assets/Indeo/cubes.mov").unwrap();
869 let mut fr = FileReader::new_read(&mut file);
870 let mut br = ByteReader::new(&mut fr);
871 let mut dmx = MOVDemuxer::new(&mut br);
872 let mut sm = StreamManager::new();
873 let mut si = SeekIndex::new();
874 dmx.open(&mut sm, &mut si).unwrap();
877 let pktres = dmx.get_frame(&mut sm);
878 if let Err(e) = pktres {
879 if e == DemuxerError::EOF { break; }
882 let pkt = pktres.unwrap();
883 println!("Got {}", pkt);