projects / nihav.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mov: do not overwrite timebase with sample rate
[nihav.git] / nihav-commonfmt / src / demuxers / mov.rs
CommitLineData
58309c73
KS		 1use nihav_core::demuxers::*;
2use nihav_registry::register::*;
fbf1f900 3use nihav_core::compr::deflate::*;
58309c73
KS		 4
5macro_rules! mktag {
6 ($a:expr, $b:expr, $c:expr, $d:expr) => ({
7 (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
8 });
9 ($arr:expr) => ({
10 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
11 });
12}
13
14trait Skip64 {
15 fn skip64(&mut self, size: u64) -> ByteIOResult<()>;
16}
17
18impl<'a> Skip64 for ByteReader<'a> {
19 fn skip64(&mut self, size: u64) -> ByteIOResult<()> {
20 if (size as usize as u64) != size {
21 self.seek(SeekFrom::Current(size as i64))?;
22 } else {
23 self.read_skip(size as usize)?;
24 }
25 Ok(())
26 }
27}
28
29fn read_chunk_header(br: &mut ByteReader) -> DemuxerResult<(u32, u64)> {
30 let size = br.read_u32be()?;
31 let ctype = br.read_u32be()?;
32 if size == 0 {
33 Ok((ctype, br.left() as u64))
34 } else if size == 1 {
35 let size64 = br.read_u64be()?;
36 validate!(size64 >= 16);
37 Ok((ctype, size64 - 16))
38 } else {
39 validate!(size >= 8);
40 Ok((ctype, (size as u64) - 8))
41 }
42}
43
58cd51fa 44fn read_palette(br: &mut ByteReader, size: u64, pal: &mut [u8; 1024]) -> DemuxerResult<u64> {
00333698 45 let _seed = br.read_u32be()?;
0ad1f05e 46 let flags = br.read_u16be()?;
00333698
KS		 47 let palsize = (br.read_u16be()? as usize) + 1;
48 validate!(palsize <= 256);
0ad1f05e
KS		 49 validate!(flags == 0 || flags == 0x4000 || flags == 0x8000);
50 validate!((palsize as u64) * 8 + 8 <= size);
00333698
KS		 51 for i in 0..palsize {
52 let a = br.read_u16be()?;
53 let r = br.read_u16be()?;
54 let g = br.read_u16be()?;
55 let b = br.read_u16be()?;
58cd51fa
KS		 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;
0ad1f05e
KS		 59 if flags == 0x8000 {
60 pal[i * 4 + 3] = (a >> 8) as u8;
61 }
62 }
63 if flags == 0x4000 {
64 br.read_skip(8)?;
00333698
KS		 65 }
66 Ok(size)
67}
68
58309c73
KS		 69struct RootChunkHandler {
70 ctype: u32,
71 parse: fn(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64>,
72}
73
74struct TrackChunkHandler {
75 ctype: u32,
76 parse: fn(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64>,
77}
78
79const IGNORED_CHUNKS: &[u32] = &[
80 mktag!(b"free"), mktag!(b"skip"), mktag!(b"udta"), mktag!(b"wide")
81];
82
83const ROOT_CHUNK_HANDLERS: &[RootChunkHandler] = &[
7e19285f 84 RootChunkHandler { ctype: mktag!(b"ftyp"), parse: read_ftyp },
58309c73
KS		 85 RootChunkHandler { ctype: mktag!(b"mdat"), parse: read_mdat },
86 RootChunkHandler { ctype: mktag!(b"moov"), parse: read_moov },
0a0456a8
KS		 87 RootChunkHandler { ctype: mktag!(b"moof"), parse: read_moof },
88 RootChunkHandler { ctype: mktag!(b"sidx"), parse: read_sidx },
58309c73
KS		 89];
90
650d7bfb
KS		 91fn 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;
6f263099
KS		 95 for ch in tag.iter() {
96 if !(0x20..=0x7F).contains(ch) {
650d7bfb
KS		 97 printable = false;
98 break;
99 }
100 }
101 if printable {
102 print!(" '{}{}{}{}'", tag[0] as char, tag[1] as char, tag[2] as char, tag[3] as char);
103 } else {
104 print!(" {:08X}", ctype);
105 }
106 println!(" size {} @ {:X}", size, off);
107}
108
58309c73
KS		 109macro_rules! read_chunk_list {
110 (root; $name: expr, $fname: ident, $handlers: ident) => {
111 fn $fname(&mut self, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<()> {
112 self.depth += 1;
113 validate!(self.depth < 32);
114 let list_end = self.src.tell() + size;
115 while self.src.tell() < list_end {
6f263099 116 let ret = read_chunk_header(self.src);
58309c73
KS		 117 if ret.is_err() { break; }
118 let (ctype, size) = ret.unwrap();
650d7bfb
KS		 119 if self.print_chunks {
120 print_cname(ctype, size, self.src.tell(), self.depth as u8);
121 }
58309c73
KS		 122 if self.src.tell() + size > list_end {
123 break;
124 }
125 if IGNORED_CHUNKS.contains(&ctype) {
126 self.src.skip64(size)?;
127 continue;
128 }
129 let handler = $handlers.iter().find(|x| x.ctype == ctype);
130 let read_size;
131 if let Some(ref handler) = handler {
132 read_size = (handler.parse)(self, strmgr, size)?;
133 } else {
134 println!("skipping unknown chunk {:08X} size {}", ctype, size);
135 read_size = 0;
136 }
137 validate!(read_size <= size);
138 self.src.skip64(size - read_size)?;
139 }
140 self.depth -= 1;
141 validate!(self.src.tell() == list_end);
142 Ok(())
143 }
144 };
145 (track; $name: expr, $fname: ident, $handlers: ident) => {
146 fn $fname(&mut self, br: &mut ByteReader, size: u64) -> DemuxerResult<()> {
147 self.depth += 1;
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();
650d7bfb
KS		 154 if self.print_chunks {
155 print_cname(ctype, size, br.tell(), self.depth + 1);
156 }
58309c73
KS		 157 if br.tell() + size > list_end {
158 break;
159 }
160 if IGNORED_CHUNKS.contains(&ctype) {
161 br.skip64(size)?;
162 continue;
163 }
164 let handler = $handlers.iter().find(|x| x.ctype == ctype);
165 let read_size;
166 if let Some(ref handler) = handler {
167 read_size = (handler.parse)(self, br, size)?;
168 } else {
169 read_size = 0;
170 }
171 validate!(read_size <= size);
172 br.skip64(size - read_size)?;
173 }
174 self.depth -= 1;
175 validate!(br.tell() == list_end);
176 Ok(())
177 }
178 }
179}
180
181fn skip_chunk(_track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
182 br.skip64(size)?;
183 Ok(size)
184}
185
7e19285f
KS		 186fn read_ftyp(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
187 dmx.src.skip64(size)?;
188 Ok(size)
189}
190
58309c73
KS		 191fn 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)?;
195 Ok(size)
196}
197
0a0456a8
KS		 198fn read_sidx(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64) -> DemuxerResult<u64> {
199 Ok(0)
200}
201
58309c73
KS		 202fn read_moov(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
203 dmx.read_moov(strmgr, size)?;
204 Ok(size)
205}
206
207const MOOV_CHUNK_HANDLERS: &[RootChunkHandler] = &[
208 RootChunkHandler { ctype: mktag!(b"mvhd"), parse: read_mvhd },
fbf1f900 209 RootChunkHandler { ctype: mktag!(b"cmov"), parse: read_cmov },
00333698 210 RootChunkHandler { ctype: mktag!(b"ctab"), parse: read_ctab },
58309c73 211 RootChunkHandler { ctype: mktag!(b"trak"), parse: read_trak },
7e19285f 212 RootChunkHandler { ctype: mktag!(b"meta"), parse: read_meta },
0a0456a8 213 RootChunkHandler { ctype: mktag!(b"mvex"), parse: read_mvex },
554caf5d 214 RootChunkHandler { ctype: mktag!(b"iods"), parse: skip_chunk_mov },
58309c73
KS		 215];
216
217fn 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()?;
230 br.read_skip(10)?;
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;
240 dmx.tb_den = tscale;
241
242 Ok(KNOWN_MVHD_SIZE)
243}
244
fbf1f900
KS		 245fn 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);
254 }
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())?;
61a228ff 264 let ret = Inflate::uncompress(sbuf.as_slice(), dbuf.as_mut_slice());
fbf1f900
KS		 265 if ret.is_err() {
266 return Err(DemuxerError::InvalidData);
267 }
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);
650d7bfb 275 ddmx.print_chunks = dmx.print_chunks;
fbf1f900
KS		 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);
237cc1f9 281
fbf1f900
KS		 282 Ok(size)
283}
284
00333698 285fn read_ctab(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
58cd51fa 286 let mut pal = [0; 1024];
6f263099 287 let size = read_palette(dmx.src, size, &mut pal)?;
58cd51fa
KS		 288 dmx.pal = Some(Arc::new(pal));
289 Ok(size)
00333698
KS		 290}
291
7e19285f
KS		 292fn read_meta(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
293 dmx.src.skip64(size)?;
294 Ok(size)
295}
296
0a0456a8
KS		 297fn read_mvex(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64) -> DemuxerResult<u64> {
298 Ok(0)
299}
300
554caf5d
KS		 301fn skip_chunk_mov(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64) -> DemuxerResult<u64> {
302 Ok(0)
303}
304
58309c73
KS		 305fn 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);
650d7bfb 307 track.print_chunks = dmx.print_chunks;
6f263099 308 track.read_trak(dmx.src, size)?;
58309c73
KS		 309 validate!(track.tkhd_found && track.stsd_found);
310 validate!(strmgr.get_stream_by_id(track.track_id).is_none());
311 dmx.cur_track += 1;
58309c73
KS		 312 dmx.tracks.push(track);
313 Ok(size)
314}
315
0a0456a8
KS		 316fn 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)?;
319 Ok(size)
320}
321
322const 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 },
326];
327
328fn 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()?;
336
337 Ok(KNOWN_MFHD_SIZE)
338}
339
340fn 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 {
348 track = Some(trk);
349 break;
350 }
351 }
352 if let Some(track) = track {
353 track.moof_off = dmx.moof_off;
6f263099 354 track.read_traf(dmx.src, size)?;
0a0456a8
KS		 355 Ok(size)
356 } else {
357 Ok(0)
358 }
359}
360
58309c73
KS		 361const 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 },
370];
371
372fn 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()?;
381 br.read_skip(4)?;
a480a0de 382 let duration = br.read_u32be()?;
58309c73
KS		 383 br.read_skip(8)?;
384 let _layer = br.read_u16be()?;
385 let _alt_group = br.read_u16be()?;
386 let _volume = br.read_u16be()?;
387 br.read_skip(2)?;
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;
a480a0de 394 track.duration = duration;
58309c73
KS		 395
396 track.tkhd_found = true;
397 Ok(KNOWN_TKHD_SIZE)
398}
399
400fn read_mdia(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
401 track.stream_type = StreamType::None;
402 track.read_mdia(br, size)?;
403 Ok(size)
404}
405
406const MDIA_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
079fff1d 407 TrackChunkHandler { ctype: mktag!(b"mdhd"), parse: read_mdhd },
58309c73
KS		 408 TrackChunkHandler { ctype: mktag!(b"hdlr"), parse: read_hdlr },
409 TrackChunkHandler { ctype: mktag!(b"minf"), parse: read_minf },
410];
411
079fff1d
KS		 412fn 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()?;
426
427 Ok(KNOWN_MDHD_SIZE)
428}
429
58309c73
KS		 430fn 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()?;
442
d4809976 443 if comp_type == mktag!(b"mhlr") || comp_type == 0 {
58309c73
KS		 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;
448 } else {
449 track.stream_type = StreamType::Data;
450 }
451 } else if comp_type == mktag!(b"dhlr") {
452 track.stream_type = StreamType::Data;
453 } else {
454 println!("Unknown stream type");
455 track.stream_type = StreamType::Data;
456 }
c8db9313 457
58309c73
KS		 458 Ok(KNOWN_HDLR_SIZE)
459}
460
461fn read_minf(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
462 track.read_minf(br, size)?;
463 Ok(size)
464}
465
466const 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 },
474];
475
476fn 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
485 Ok(KNOWN_VMHD_SIZE)
486}
487
488fn 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
496 br.read_skip(2)?;
497 Ok(KNOWN_SMHD_SIZE)
498}
499
500fn read_gmhd(track: &mut Track, _br: &mut ByteReader, _size: u64) -> DemuxerResult<u64> {
501 validate!(track.stream_type == StreamType::Data);
502 Ok(0)
503}
504
505fn 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
515 br.read_skip(2)?;
516 Ok(KNOWN_GMIN_SIZE)
517}
518
519fn read_stbl(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
520 track.read_stbl(br, size)?;
521 Ok(size)
522}
523
524const STBL_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
525 TrackChunkHandler { ctype: mktag!(b"stsd"), parse: read_stsd },
bbbf86dd 526 TrackChunkHandler { ctype: mktag!(b"stts"), parse: read_stts },
58309c73
KS		 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 },
4e7deeda 532 TrackChunkHandler { ctype: mktag!(b"ctts"), parse: read_ctts },
58309c73
KS		 533];
534
89b16ac8
KS		 535fn 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 {
9aa783a0
KS		 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));
544 }
545
89b16ac8
KS		 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"));
550 if csize == 8 {
551 return Ok(None);
552 }
553 let mut buf = [0; 8];
554 br.peek_buf(&mut buf)?;
555 if &buf[4..8] == b"frma" {
556 br.read_skip(12)?;
557 if csize > 20 {
558 let mut buf = vec![0; (csize - 20) as usize];
559 br.read_buf(&mut buf)?;
560 Ok(Some(buf))
561 } else {
562 Ok(None)
563 }
564 } else if csize > 8 {
565 let mut buf = vec![0; (csize as usize) - 8];
566 br.read_buf(&mut buf)?;
567 Ok(Some(buf))
568 } else {
569 Ok(None)
570 }
571 } else {
572 Ok(None)
573 }
574}
575
58309c73
KS		 576fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
577 const KNOWN_STSD_SIZE: u64 = 24;
578 validate!(size >= KNOWN_STSD_SIZE);
579 let start_pos = br.tell();
580 let version = br.read_byte()?;
581 validate!(version == 0);
582 let _flags = br.read_u24be()?;
583 let entries = br.read_u32be()?;
584 validate!(entries > 0);
61cab15b 585 let esize = u64::from(br.read_u32be()?);
58309c73
KS		 586 validate!(esize + 8 <= size);
587 let mut fcc = [0u8; 4];
588 br.read_buf(&mut fcc)?;
589 br.read_skip(6)?;
590 let _data_ref = br.read_u16be()?;
591
592 track.fcc = fcc;
593
594 let codec_info;
595 match track.stream_type {
596 StreamType::Video => {
597 let _ver = br.read_u16be()?;
598 let _revision = br.read_u16le()?;
599 let _vendor = br.read_u32be()?;
600 let _temp_quality = br.read_u32be()?;
601 let _spat_quality = br.read_u32be()?;
602 let width = br.read_u16be()? as usize;
603 let height = br.read_u16be()? as usize;
604 let _hor_res = br.read_u32be()?;
605 let _vert_res = br.read_u32be()?;
606 let data_size = br.read_u32be()?;
607 validate!(data_size == 0);
608 let _frame_count = br.read_u16be()? as usize;
609 let _cname_len = br.read_byte()? as usize;
610 br.read_skip(31)?; // actual compressor name
611 let depth = br.read_u16be()?;
612 let ctable_id = br.read_u16be()?;
8019c866
KS		 613 let grayscale = depth > 0x20 || depth == 1;
614 let depth = if grayscale { depth & 0x1F } else { depth };
58309c73 615 if ctable_id == 0 {
00333698 616 let max_pal_size = start_pos + size - br.tell();
88fd1059
KS		 617 if depth <= 8 {
618 let mut pal = [0; 1024];
619 read_palette(br, max_pal_size, &mut pal)?;
620 track.pal = Some(Arc::new(pal));
621 } else {
622 br.read_skip(max_pal_size as usize)?;
623 }
8019c866 624 } else if (depth <= 8) && !grayscale {
2736c15a
KS		 625 match depth & 0x1F {
626 2 => {
627 let mut pal = [0; 1024];
628 (&mut pal[..4 * 4]).copy_from_slice(&MOV_DEFAULT_PAL_2BIT);
629 track.pal = Some(Arc::new(pal));
630 },
631 4 => {
632 let mut pal = [0; 1024];
633 (&mut pal[..16 * 4]).copy_from_slice(&MOV_DEFAULT_PAL_4BIT);
634 track.pal = Some(Arc::new(pal));
635 },
636 8 => {
637 track.pal = Some(Arc::new(MOV_DEFAULT_PAL_8BIT));
638 },
639 _ => {},
640 };
2949bcfa 641 } else if grayscale && ctable_id != 0xFFFF {
2736c15a
KS		 642 let mut pal = [0; 1024];
643 let cdepth = depth & 0x1F;
644 let size = 1 << cdepth;
645 for i in 0..size {
8019c866 646 let mut clr = ((size - 1 - i) as u8) << (8 - cdepth);
2736c15a
KS		 647 let mut off = 8 - cdepth;
648 while off >= cdepth {
649 clr |= clr >> (8 - off);
650 off -= cdepth;
651 }
652 if off > 0 {
653 clr |= clr >> (8 - off);
654 }
655 pal[i * 4] = clr;
656 pal[i * 4 + 1] = clr;
657 pal[i * 4 + 2] = clr;
658 }
659 track.pal = Some(Arc::new(pal));
58309c73
KS		 660 }
661// todo other atoms, put as extradata
662 let cname = if let Some(name) = find_codec_from_mov_video_fourcc(&fcc) {
663 name
664 } else if let Some(name) = find_codec_from_avi_fourcc(&fcc) {
665 name
666 } else {
667 "unknown"
668 };
669 let format = if depth > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
8019c866
KS		 670 let mut vhdr = NAVideoInfo::new(width, height, false, format);
671 vhdr.bits = depth as u8;
b9862e98
KS		 672 //skip various common atoms
673 while br.tell() - start_pos + 4 < size {
674 let mut buf = [0u8; 8];
675 br.peek_buf(&mut buf)?;
676 let tsize = read_u32be(&buf).unwrap() as usize;
677 let tag = &buf[4..8];
678 validate!(tsize >= 8);
679 match tag {
680 b"pasp" | b"clap" => {
681 br.read_skip(tsize)?;
682 },
683 _ => break,
684 };
685 }
61cab15b 686 let edata = if br.tell() - start_pos + 4 < size {
61cab15b 687 let edata_size = br.read_u32be()? as usize;
d341f57a
KS		 688 validate!(edata_size >= 4);
689 let mut buf = vec![0; edata_size - 4];
58309c73 690 br.read_buf(buf.as_mut_slice())?;
61cab15b
KS		 691 Some(buf)
692 } else {
693 None
694 };
58309c73
KS		 695 codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), edata);
696 },
697 StreamType::Audio => {
89b16ac8 698 let sver = br.read_u16be()?;
58309c73
KS		 699 let _revision = br.read_u16le()?;
700 let _vendor = br.read_u32be()?;
9559c2c8
KS		 701 let mut nchannels = br.read_u16be()?;
702 if sver != 2 {
703 validate!(nchannels <= 64);
704 }
58309c73
KS		 705 let sample_size = br.read_u16be()?;
706 validate!(sample_size <= 128);
707 let _compr_id = br.read_u16be()?;
708 let packet_size = br.read_u16be()? as usize;
709 validate!(packet_size == 0);
9559c2c8
KS		 710 let mut sample_rate = br.read_u32be()? >> 16;
711 if sver != 2 {
712 validate!(sample_rate > 0);
713 }
58309c73
KS		 714 let cname = if let Some(name) = find_codec_from_mov_audio_fourcc(&fcc) {
715 name
716 } 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]))) {
717 name
718 } else {
719 "unknown"
720 };
e5d3fef5
KS		 721 let mut soniton = NASoniton::new(sample_size as u8, SONITON_FLAG_SIGNED | SONITON_FLAG_BE);
722 if &fcc == b"raw " && sample_size == 8 {
723 soniton.signed = false;
724 }
58309c73 725 let block_align = 1;
9559c2c8
KS		 726 match sver {
727 1 => {
728 let samples_per_packet = br.read_u32be()?;
729 let _bytes_per_packet = br.read_u32be()?;
730 let bytes_per_frame = br.read_u32be()?;
731 let _bytes_per_sample = br.read_u32be()?;
732 track.bsize = bytes_per_frame as usize;
733 track.frame_samples = samples_per_packet as usize;
734 track.tb_num = samples_per_packet;
735 },
736 2 => {
737 br.read_u32be()?; // some size
738 let srate = br.read_f64be()?;
739 validate!(srate > 1.0);
740 sample_rate = srate as u32;
741 let channels = br.read_u32be()?;
742 validate!(channels > 0 && channels < 255);
743 nchannels = channels as u16;
744 br.read_u32be()?; // always 0x7F000000
745 let _bits_per_csample = br.read_u32be()?;
746 let _codec_flags = br.read_u32be()?;
747 let bytes_per_frame = br.read_u32be()?;
748 let samples_per_packet = br.read_u32be()?;
749 track.bsize = bytes_per_frame as usize;
750 track.frame_samples = samples_per_packet as usize;
751 track.tb_num = samples_per_packet;
752 },
753 _ => {
754 track.bsize = (sample_size / 8) as usize;
755 },
756 };
de3f3f00
KS		 757 if track.tb_den <= 1 {
758 track.tb_den = sample_rate;
759 }
6f263099 760 track.raw_audio = matches!(&fcc,
7afec34d
KS		 761 b"NONE" | b"raw " | b"twos" | b"sowt" |
762 b"in24" | b"in32" | b"fl32" | b"fl64" |
763 b"ima4" | b"ms\x00\x02" | b"ms\x00\x21" |
764 b"alaw" | b"ulaw" |
6f263099 765 b"MAC3" | b"MAC6");
9559c2c8 766 let ahdr = NAAudioInfo::new(sample_rate, nchannels as u8, soniton, block_align);
89b16ac8 767 let edata = parse_audio_edata(br, start_pos, size)?;
58309c73
KS		 768 codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
769 track.channels = nchannels as usize;
770 track.bits = sample_size as usize;
771 },
772 StreamType::None => {
773 return Err(DemuxerError::InvalidData);
774 },
775 _ => {
776//todo put it all into extradata
777 let edata = None;
778 codec_info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
779 },
780 };
781 let read_size = br.tell() - start_pos;
782 validate!(read_size <= size);
7afec34d 783 track.stream = Some(NAStream::new(track.stream_type, track.track_no, codec_info, track.tb_num, track.tb_den, u64::from(track.duration)));
58309c73
KS		 784 track.stsd_found = true;
785 Ok(read_size)
786}
787
bbbf86dd 788fn read_stts(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
d4809976 789 validate!(size >= 8);
bbbf86dd
KS		 790 let start_pos = br.tell();
791 let version = br.read_byte()?;
792 validate!(version == 0);
793 let _flags = br.read_u24be()?;
794 let entries = br.read_u32be()? as usize;
795 validate!(entries as u64 <= (size - 8) / 8);
d4809976
KS		 796 if entries == 0 {
797 } else if entries == 1 {
bbbf86dd
KS		 798 let _count = br.read_u32be()?;
799 let tb_num = br.read_u32be()?;
4e7deeda 800 validate!(tb_num != 0);
0a0456a8 801 track.rescale(tb_num);
bbbf86dd 802 } else {
37952415 803 track.time_to_sample.clear();
bbbf86dd
KS		 804 track.time_to_sample.reserve(entries);
805 for _ in 0..entries {
806 let count = br.read_u32be()?;
807 let mult = br.read_u32be()?;
808 track.time_to_sample.push((count, mult));
809 }
810 }
811 let read_size = br.tell() - start_pos;
812 validate!(read_size <= size);
813 Ok(read_size)
814}
815
58309c73
KS		 816fn read_stss(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
817 let version = br.read_byte()?;
818 validate!(version == 0);
819 let _flags = br.read_u24be()?;
820 let entries = br.read_u32be()? as usize;
821 validate!(entries < ((std::u32::MAX >> 2) - 8) as usize);
822 validate!((entries * 4 + 8) as u64 == size);
823 track.keyframes = Vec::with_capacity(entries);
824 let mut last_sample_no = 0;
825 for _ in 0..entries {
826 let sample_no = br.read_u32be()?;
827 validate!(sample_no > last_sample_no);
828 track.keyframes.push(sample_no);
829 last_sample_no = sample_no;
830 }
831 Ok(size)
832}
833
834fn read_stsc(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
835 let version = br.read_byte()?;
836 validate!(version == 0);
837 let _flags = br.read_u24be()?;
838 let entries = br.read_u32be()? as usize;
839 validate!(entries < ((std::u32::MAX / 12) - 8) as usize);
840 validate!((entries * 12 + 8) as u64 == size);
841 track.sample_map = Vec::with_capacity(entries);
842 let mut last_sample_no = 0;
843 for _i in 0..entries {
844 let sample_no = br.read_u32be()?;
845 validate!(sample_no > last_sample_no);
846 let nsamples = br.read_u32be()?;
847 let _sample_desc = br.read_u32be()?;
848 track.sample_map.push((sample_no, nsamples));
849 last_sample_no = sample_no;
850 }
851 Ok(size)
852}
853
854fn read_stsz(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
855 let version = br.read_byte()?;
856 validate!(version == 0);
857 let _flags = br.read_u24be()?;
858 let sample_size = br.read_u32be()?;
859 if sample_size != 0 {
860 track.sample_size = sample_size;
9efec4ed
KS		 861 if track.sample_size != 1 || track.bsize == 0 {
862 track.bsize = sample_size as usize;
863 }
58309c73
KS		 864 Ok(8)
865 } else {
866 let entries = br.read_u32be()? as usize;
867 validate!((entries * 4 + 12) as u64 == size);
868 track.chunk_sizes = Vec::with_capacity(entries);
869 for _ in 0..entries {
870 let sample_size = br.read_u32be()?;
871 track.chunk_sizes.push(sample_size);
872 }
873 Ok(size)
874 }
875}
876
877fn read_stco(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
878 let version = br.read_byte()?;
879 validate!(version == 0);
880 let _flags = br.read_u24be()?;
881 let entries = br.read_u32be()? as usize;
882 validate!((entries * 4 + 8) as u64 == size);
883 track.chunk_offsets = Vec::with_capacity(entries);
884 for _i in 0..entries {
885 let sample_offset = br.read_u32be()?;
886 track.chunk_offsets.push(u64::from(sample_offset));
887 }
888 Ok(size)
889}
890
4e7deeda
KS		 891fn read_ctts(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
892 validate!(size >= 8);
893 let version = br.read_byte()?;
894 let _flags = br.read_u24be()?;
895 if version > 1 {
896 return Err(DemuxerError::NotImplemented);
897 }
898 let entries = br.read_u32be()? as usize;
899 track.ctts_version = version;
900 track.ctts_map.resize(entries);
901 match version {
902 0 | 1 => {
903 validate!(size == (entries as u64) * 8 + 8);
904 for _ in 0..entries {
905 let samp_count = br.read_u32be()?;
906 let samp_offset = br.read_u32be()?;
907 track.ctts_map.add(samp_count, samp_offset / track.tb_div);
908 }
909 },
910 _ => unreachable!(),
911 };
912 track.ctts_map.reset();
913
914 Ok(size)
915}
916
0a0456a8
KS		 917const TRAF_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
918 TrackChunkHandler { ctype: mktag!(b"tfhd"), parse: read_tfhd },
919 TrackChunkHandler { ctype: mktag!(b"trun"), parse: read_trun },
920 TrackChunkHandler { ctype: mktag!(b"sbgp"), parse: skip_chunk },
921 TrackChunkHandler { ctype: mktag!(b"sgpd"), parse: skip_chunk },
922 TrackChunkHandler { ctype: mktag!(b"subs"), parse: skip_chunk },
923 TrackChunkHandler { ctype: mktag!(b"saiz"), parse: skip_chunk },
924 TrackChunkHandler { ctype: mktag!(b"saio"), parse: skip_chunk },
925 TrackChunkHandler { ctype: mktag!(b"tfdt"), parse: skip_chunk },
926 TrackChunkHandler { ctype: mktag!(b"meta"), parse: skip_chunk },
927];
928
929fn read_tfhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
930 validate!(size >= 8);
931 let start = br.tell();
932 let _version = br.read_byte()?;
933 let flags = br.read_u24be()?;
934 let _track_id = br.read_u32be()?;
935 if (flags & 0x000001) != 0 {
936 let base_offset = br.read_u64be()?;
937 track.moof_off = base_offset;
938 }
939 if (flags & 0x000002) != 0 {
940 let _sample_description_index = br.read_u32be()?;
941 }
942 if (flags & 0x000008) != 0 {
943 let default_sample_duration = br.read_u32be()?;
944 if track.tb_div == 1 {
945 track.rescale(default_sample_duration);
946 }
947 }
948 if (flags & 0x000010) != 0 {
949 let _default_sample_size = br.read_u32be()?;
950 }
951 if (flags & 0x000020) != 0 {
952 let _default_sample_flags = br.read_u32be()?;
953 }
954 if (flags & 0x010000) != 0 {
955 }
956 /*if (flags & 0x020000) != 0 { // base offset is moof start
957 }*/
958 Ok(br.tell() - start)
959}
960
961fn read_trun(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
962 validate!(size >= 8);
963 let version = br.read_byte()?;
964 let flags = br.read_u24be()?;
965 let data_off_present = (flags & 0x000001) != 0;
966 let first_sample_flags = (flags & 0x000004) != 0;
967 let sample_duration_present = (flags & 0x000100) != 0;
968 let sample_size_present = (flags & 0x000200) != 0;
969 let sample_flags_present = (flags & 0x000400) != 0;
970 let sample_ct_off_present = (flags & 0x000800) != 0;
971
972 let sample_count = br.read_u32be()? as usize;
973
974 let mut hdr_size = 8;
975 let mut arr_size = 0;
976 if data_off_present {
977 hdr_size += 4;
978 }
979 if first_sample_flags {
980 hdr_size += 4;
981 }
982 if sample_duration_present {
983 arr_size += 4;
984 }
985 if sample_size_present {
986 arr_size += 4;
987 }
988 if sample_flags_present {
989 arr_size += 4;
990 }
991 if sample_ct_off_present {
992 arr_size += 4;
993 }
994 validate!(size == hdr_size + arr_size * (sample_count as u64));
995
996 let mut data_off = if data_off_present {
997 let off = br.read_u32be()? as i32;
998 let new_off = (track.moof_off as i64) + i64::from(off);
999 validate!(new_off > 0);
1000 new_off as u64
1001 } else {
1002 track.moof_off
1003 };
1004 if first_sample_flags {
1005 let _flags = br.read_u32be()?;
1006 }
1007
1008 if sample_size_present {
1009 track.chunk_sizes.reserve(sample_count);
1010 track.chunk_offsets.reserve(sample_count);
1011 }
1012
1013 if sample_ct_off_present {
1014 if track.ctts_version != version {
1015 track.ctts_version = version;
1016 }
1017 track.ctts_map.reserve(sample_count);
1018 }
1019
6bb26927
KS		 1020 if track.chunk_offsets.len() < (std::u32::MAX as usize) {
1021 track.keyframes.push((track.chunk_offsets.len() + 1) as u32);
1022 }
0a0456a8
KS		 1023 for _ in 0..sample_count {
1024 if sample_duration_present {
1025 let _duration = br.read_u32be()?;
1026 }
1027 if sample_size_present {
1028 let ssize = br.read_u32be()?;
1029 track.chunk_sizes.push(ssize);
1030 track.chunk_offsets.push(data_off);
1031 data_off += u64::from(ssize);
1032 }
1033 if sample_flags_present {
1034 let _flags = br.read_u32be()?;
1035 }
1036 if sample_ct_off_present {
1037 let samp_offset = br.read_u32be()?;
1038 if version == 0 {
1039 track.ctts_map.add(1, samp_offset / track.tb_div);
1040 } else {
1041 track.ctts_map.add(1, ((samp_offset as i32) / (track.tb_div as i32)) as u32);
1042 }
1043 }
1044 }
1045
1046 Ok(size)
1047}
1048
58309c73
KS		 1049struct MOVDemuxer<'a> {
1050 src: &'a mut ByteReader<'a>,
1051 depth: usize,
1052 mdat_pos: u64,
1053 mdat_size: u64,
1054 tracks: Vec<Track>,
1055 cur_track: usize,
1056 tb_den: u32,
1057 duration: u32,
58cd51fa 1058 pal: Option<Arc<[u8; 1024]>>,
650d7bfb 1059
0a0456a8
KS		 1060 moof_off: u64,
1061
650d7bfb 1062 print_chunks: bool,
88fd1059
KS		 1063
1064 macbinary: bool,
58309c73
KS		 1065}
1066
1067struct Track {
1068 track_id: u32,
1069 track_str_id: usize,
1070 track_no: u32,
bbbf86dd 1071 tb_num: u32,
58309c73 1072 tb_den: u32,
4e7deeda 1073 tb_div: u32,
7afec34d
KS		 1074 raw_audio: bool,
1075 raw_apos: u64,
a480a0de 1076 duration: u32,
58309c73
KS		 1077 depth: u8,
1078 tkhd_found: bool,
1079 stsd_found: bool,
1080 stream_type: StreamType,
1081 width: usize,
1082 height: usize,
1083 channels: usize,
1084 bits: usize,
9efec4ed 1085 bsize: usize,
58309c73
KS		 1086 fcc: [u8; 4],
1087 keyframes: Vec<u32>,
1088 chunk_sizes: Vec<u32>,
1089 chunk_offsets: Vec<u64>,
bbbf86dd 1090 time_to_sample: Vec<(u32, u32)>,
58309c73
KS		 1091 sample_map: Vec<(u32, u32)>,
1092 sample_size: u32,
b0e12d42 1093 frame_samples: usize,
4e7deeda
KS		 1094 ctts_map: RLESearcher<u32>,
1095 ctts_version: u8,
58309c73
KS		 1096 stream: Option<NAStream>,
1097 cur_chunk: usize,
1098 cur_sample: usize,
07972bf3 1099 cur_ts: Option<u64>,
58309c73
KS		 1100 samples_left: usize,
1101 last_offset: u64,
58cd51fa 1102 pal: Option<Arc<[u8; 1024]>>,
bbbf86dd 1103 timesearch: TimeSearcher,
650d7bfb 1104
0a0456a8
KS		 1105 moof_off: u64,
1106
650d7bfb 1107 print_chunks: bool,
bbbf86dd
KS		 1108}
1109
1110#[derive(Default)]
1111struct TimeSearcher {
1112 idx: usize,
1113 base: u64,
1114 sbase: u32,
1115 cur_len: u32,
1116 cur_mul: u32,
1117}
1118
1119impl TimeSearcher {
1120 fn new() -> Self { Self::default() }
1121 fn reset(&mut self) {
1122 *self = Self::default();
1123 }
b7c882c1 1124 fn map_time(&mut self, sample: u32, tts: &[(u32, u32)]) -> u64 {
bbbf86dd
KS		 1125 if tts.is_empty() {
1126 u64::from(sample)
1127 } else if sample >= self.sbase {
1128 let mut sample = sample - self.sbase;
1129 if self.idx == 0 {
1130 let (cur_len, cur_mul) = tts[0];
1131 self.cur_len = cur_len;
1132 self.cur_mul = cur_mul;
1133 self.idx += 1;
1134 }
1135 while self.idx < tts.len() && sample > self.cur_len {
1136 sample -= self.cur_len;
1137 self.sbase += self.cur_len;
1138 self.base += u64::from(self.cur_len) * u64::from(self.cur_mul);
1139 self.cur_len = tts[self.idx].0;
1140 self.cur_mul = tts[self.idx].1;
1141 self.idx += 1;
1142 }
1143 self.base + u64::from(sample) * u64::from(self.cur_mul)
1144 } else {
1145 self.reset();
1146 self.map_time(sample, tts)
1147 }
1148 }
58309c73
KS		 1149}
1150
4e7deeda
KS		 1151#[derive(Default)]
1152struct RLESearcher<T> {
1153 array: Vec<(u32, T)>,
1154 idx: usize,
1155 start: u64,
1156 next: u64,
1157}
1158
1159impl<T:Default+Copy> RLESearcher<T> {
1160 fn new() -> Self { Self::default() }
1161 fn resize(&mut self, size: usize) {
37952415 1162 self.array.clear();
4e7deeda
KS		 1163 self.array.reserve(size);
1164 }
0a0456a8
KS		 1165 fn reserve(&mut self, size: usize) {
1166 self.array.reserve(size);
1167 }
4e7deeda
KS		 1168 fn add(&mut self, len: u32, val: T) {
1169 self.array.push((len, val));
1170 }
1171 fn reset(&mut self) {
1172 self.start = 0;
1173 if !self.array.is_empty() {
1174 self.idx = 0;
1175 self.next = u64::from(self.array[0].0);
1176 } else {
1177 self.idx = self.array.len();
1178 self.next = 0;
1179 }
1180 }
1181 fn map(&mut self, sample: u64) -> Option<T> {
1182 if sample < self.start {
1183 self.reset();
1184 }
1185 if self.idx < self.array.len() {
1186 if sample < self.next {
1187 Some(self.array[self.idx].1)
1188 } else {
1189 while (self.idx < self.array.len()) && (sample >= self.next) {
1190 self.start = self.next;
1191 self.idx += 1;
1192 if self.idx < self.array.len() {
1193 self.next += u64::from(self.array[self.idx].0);
1194 }
1195 }
1196 if self.idx < self.array.len() {
1197 Some(self.array[self.idx].1)
1198 } else {
1199 None
1200 }
1201 }
1202 } else {
1203 None
1204 }
1205 }
1206}
1207
58309c73
KS		 1208impl Track {
1209 fn new(track_no: u32, tb_den: u32) -> Self {
1210 Self {
1211 tkhd_found: false,
1212 stsd_found: false,
1213 track_id: 0,
1214 track_str_id: 0,
1215 track_no,
bbbf86dd 1216 tb_num: 1,
58309c73 1217 tb_den,
4e7deeda 1218 tb_div: 1,
7afec34d
KS		 1219 raw_audio: false,
1220 raw_apos: 0,
a480a0de 1221 duration: 0,
58309c73
KS		 1222 stream_type: StreamType::None,
1223 width: 0,
1224 height: 0,
1225 channels: 0,
1226 bits: 0,
9efec4ed 1227 bsize: 0,
58309c73
KS		 1228 fcc: [0; 4],
1229 keyframes: Vec::new(),
1230 chunk_sizes: Vec::new(),
1231 chunk_offsets: Vec::new(),
bbbf86dd 1232 time_to_sample: Vec::new(),
58309c73
KS		 1233 sample_map: Vec::new(),
1234 sample_size: 0,
b0e12d42 1235 frame_samples: 0,
4e7deeda
KS		 1236 ctts_map: RLESearcher::new(),
1237 ctts_version: 0,
58309c73
KS		 1238 stream: None,
1239 depth: 0,
1240 cur_chunk: 0,
1241 cur_sample: 0,
07972bf3 1242 cur_ts: None,
58309c73
KS		 1243 samples_left: 0,
1244 last_offset: 0,
58cd51fa 1245 pal: None,
bbbf86dd 1246 timesearch: TimeSearcher::new(),
650d7bfb 1247
0a0456a8
KS		 1248 moof_off: 0,
1249
650d7bfb 1250 print_chunks: false,
58309c73
KS		 1251 }
1252 }
1253 read_chunk_list!(track; "trak", read_trak, TRAK_CHUNK_HANDLERS);
1254 read_chunk_list!(track; "mdia", read_mdia, MDIA_CHUNK_HANDLERS);
1255 read_chunk_list!(track; "minf", read_minf, MINF_CHUNK_HANDLERS);
1256 read_chunk_list!(track; "stbl", read_stbl, STBL_CHUNK_HANDLERS);
0a0456a8
KS		 1257 read_chunk_list!(track; "traf", read_traf, TRAF_CHUNK_HANDLERS);
1258 fn rescale(&mut self, tb_num: u32) {
1259 self.tb_div = tb_num;
1260 if let Some(ref mut stream) = self.stream {
1261 let tb_den = stream.tb_den;
1262 let (tb_num, tb_den) = reduce_timebase(tb_num * stream.tb_num, tb_den);
1263 stream.duration /= u64::from(self.tb_div);
1264 stream.tb_num = tb_num;
1265 stream.tb_den = tb_den;
1266 self.tb_num = tb_num;
1267 self.tb_den = tb_den;
1268 self.duration /= self.tb_div;
1269 }
1270 }
58309c73 1271 fn fill_seek_index(&self, seek_index: &mut SeekIndex) {
61cab15b 1272 if !self.keyframes.is_empty() {
58309c73
KS		 1273 seek_index.mode = SeekIndexMode::Present;
1274 }
bbbf86dd 1275 let mut tsearch = TimeSearcher::new();
58309c73 1276 for kf_time in self.keyframes.iter() {
bbbf86dd
KS		 1277 let pts = tsearch.map_time(*kf_time - 1, &self.time_to_sample);
1278 let time = NATimeInfo::ts_to_time(pts, 1000, self.tb_num, self.tb_den);
1279 seek_index.add_entry(self.track_no as u32, SeekEntry { time, pts: u64::from(*kf_time - 1), pos: 0 });
58309c73
KS		 1280 }
1281 }
1282 fn calculate_chunk_size(&self, nsamp: usize) -> usize {
1283 if nsamp == 0 {
9efec4ed 1284 self.bsize
58309c73
KS		 1285 } else {
1286 match &self.fcc {
1287 b"NONE" | b"raw " | b"twos" | b"sowt" => {
1288 (nsamp * self.bits * self.channels + 7) >> 3
1289 },
1290 b"ima4" => {
1291 let nblocks = (nsamp + 63) >> 6;
1292 nblocks * 34 * self.channels
1293 },
1294 b"MAC3" => {
1295 (nsamp + 5) / 6 * 2 * self.channels
1296 },
1297 b"MAC6" => {
1298 (nsamp + 5) / 6 * self.channels
1299 },
1300 b"in24" => nsamp * 3 * self.channels,
1301 b"in32" | b"fl32" => nsamp * 4 * self.channels,
1302 b"fl64" => nsamp * 8 * self.channels,
1303 b"ulaw" | b"alaw" => nsamp,
1304 b"ms\x00\x02" => { //MS ADPCM
1305 ((nsamp - 1) / 2 + 7) * self.channels
1306 },
1307 b"ms\x00\x21" => { //IMA ADPCM
1308 (nsamp / 2 + 4) * self.channels
1309 },
9efec4ed 1310 _ => self.bsize,
58309c73
KS		 1311 }
1312 }
1313 }
1314 fn get_next_chunk(&mut self) -> Option<(NATimeInfo, u64, usize)> {
bbbf86dd 1315 let pts_val = self.timesearch.map_time(self.cur_sample as u32, &self.time_to_sample);
4e7deeda
KS		 1316 let dts = if let Some(dts_corr) = self.ctts_map.map(self.cur_sample as u64) {
1317 let dts = match self.ctts_version {
1318 0 => pts_val.wrapping_add(u64::from(dts_corr)),
1319 1 => pts_val.wrapping_add(i64::from(dts_corr as i32) as u64),
1320 _ => unimplemented!(),
1321 };
1322 if (dts as i64) < 0 {
1323 None
1324 } else {
1325 Some(dts)
1326 }
1327 } else {
eade06ed 1328 Some(pts_val)
4e7deeda
KS		 1329 };
1330 let mut pts = NATimeInfo::new(Some(pts_val), dts, None, self.tb_num, self.tb_den);
58309c73
KS		 1331 if self.chunk_offsets.len() == self.chunk_sizes.len() { // simple one-to-one mapping
1332 if self.cur_sample >= self.chunk_sizes.len() {
1333 return None;
1334 }
1335 let offset = self.chunk_offsets[self.cur_sample];
1336 let size = self.chunk_sizes[self.cur_sample] as usize;
1337 self.cur_sample += 1;
1338 Some((pts, offset, size))
1339 } else {
1340 if self.samples_left == 0 {
1341 if self.cur_chunk >= self.chunk_offsets.len() {
1342 return None;
1343 }
1344 for (idx, samples) in self.sample_map.iter() {
1345 if *idx as usize <= self.cur_chunk + 1 {
1346 self.samples_left = *samples as usize;
1347 } else {
1348 break;
1349 }
1350 }
1351 self.last_offset = self.chunk_offsets[self.cur_chunk];
1352 self.cur_chunk += 1;
1353 }
1354 let offset = self.last_offset;
1355 let size = self.get_size(self.cur_sample);
1356 self.last_offset += size as u64;
1357 if self.stream_type == StreamType::Video {
1358 self.samples_left -= 1;
d940f0c2
KS		 1359 } else if self.frame_samples != 0 && self.bsize != 0 {
1360 let nblocks = size / self.bsize;
7afec34d
KS		 1361 if self.raw_audio {
1362 pts.pts = Some(self.raw_apos);
1363 pts.duration = Some(nblocks as u64);
1364 self.raw_apos += nblocks as u64;
1365 }
d940f0c2
KS		 1366 if nblocks > 0 {
1367 let consumed = (nblocks * self.frame_samples).min(self.samples_left);
1368 self.samples_left -= consumed;
1369 } else {
1370 self.samples_left = 0;
1371 }
7afec34d
KS		 1372 } else if !self.raw_audio {
1373 self.samples_left -= 1;
58309c73 1374 } else {
7afec34d
KS		 1375 const BLOCK_SAMPLES: usize = 1024 * 6; // should be multiple of 64 and 6 to fit both IMA ADPCM and MACE 6:1 blocks
1376 let max_size = self.calculate_chunk_size(BLOCK_SAMPLES);
1377 let cur_size = self.calculate_chunk_size(self.samples_left);
1378 let add_off = (size - cur_size) as u64;
1379 let dsize = cur_size.min(max_size);
1380 if self.samples_left >= BLOCK_SAMPLES {
1381 self.cur_sample += BLOCK_SAMPLES;
1382 self.samples_left -= BLOCK_SAMPLES;
1383 self.last_offset -= size as u64;
1384 } else {
1385 self.cur_sample += self.samples_left;
1386 self.samples_left = 0;
1387 }
1388 return Some((pts, offset + add_off, dsize));
58309c73
KS		 1389 }
1390 self.cur_sample += 1;
1391 Some((pts, offset, size))
1392 }
1393 }
1394 fn get_size(&self, sample_no: usize) -> usize {
61cab15b 1395 if !self.chunk_sizes.is_empty() {
58309c73 1396 self.chunk_sizes[sample_no] as usize
61cab15b 1397 } else if !self.sample_map.is_empty() {
58309c73
KS		 1398 let mut nsamp = 0;
1399 for (idx, samples) in self.sample_map.iter() {
1400 if *idx as usize <= self.cur_chunk {
1401 nsamp = *samples;
1402 } else {
1403 break;
1404 }
1405 }
1406 self.calculate_chunk_size(nsamp as usize)
1407 } else {
9efec4ed 1408 self.bsize
58309c73
KS		 1409 }
1410 }
b7c882c1 1411 #[allow(clippy::collapsible_if)]
d9bf7e74 1412 fn seek(&mut self, pts: u64, tpoint: NATimePoint) -> DemuxerResult<u64> {
58309c73
KS		 1413 self.cur_sample = pts as usize;
1414 self.samples_left = 0;
07972bf3 1415 self.cur_ts = None;
58309c73 1416 if self.stream_type == StreamType::Audio {
7afec34d
KS		 1417 if let NATimePoint::Milliseconds(ms) = tpoint {
1418 let exp_pts = NATimeInfo::time_to_ts(ms, 1000, self.tb_num, self.tb_den);
1419 if self.raw_audio {
1420 if self.frame_samples != 0 {
1421 self.raw_apos = exp_pts / (self.frame_samples as u64);
1422 let mut apos = 0;
1423 self.cur_sample = 0;
1424 self.cur_chunk = 0;
1425 let mut cmap = self.sample_map.iter();
1426 let mut cur_samps = 0;
1427 let (mut next_idx, mut next_samples) = cmap.next().unwrap();
1428 loop {
1429 if self.cur_chunk + 1 == next_idx as usize {
1430 self.samples_left = cur_samps;
1431 cur_samps = next_samples as usize;
1432 if let Some((new_idx, new_samples)) = cmap.next() {
1433 next_idx = *new_idx;
1434 next_samples = *new_samples;
1435 }
1436 }
1437 self.raw_apos = apos;
1438 apos += (cur_samps / self.frame_samples) as u64;
1439 if apos > exp_pts {
1440 if cur_samps == self.frame_samples || apos > exp_pts + 1 {
1441 if self.cur_chunk >= self.chunk_offsets.len() {
1442 return Err(DemuxerError::SeekError);
1443 }
1444 self.last_offset = self.chunk_offsets[self.cur_chunk];
1445 break;
1446 }
1447 }
1448 self.cur_chunk += 1;
1449 }
1450 self.samples_left = cur_samps;
1451 self.cur_chunk += 1;
1452 } else {
1453 self.raw_apos = exp_pts;
1454 self.cur_sample = exp_pts as usize;
1455 let mut csamp = 0;
1456 self.cur_chunk = 0;
1457 let mut cmap = self.sample_map.iter();
1458 let mut cur_samps = 0;
1459 let (mut next_idx, mut next_samples) = cmap.next().unwrap();
1460 loop {
1461 if self.cur_chunk + 1 == next_idx as usize {
1462 self.samples_left = cur_samps;
1463 cur_samps = next_samples as usize;
1464 if let Some((new_idx, new_samples)) = cmap.next() {
1465 next_idx = *new_idx;
1466 next_samples = *new_samples;
1467 }
1468 }
1469 csamp += cur_samps;
1470 if csamp > self.cur_sample {
1471 if self.cur_chunk >= self.chunk_offsets.len() {
1472 return Err(DemuxerError::SeekError);
1473 }
1474 self.last_offset = self.chunk_offsets[self.cur_chunk];
1475 break;
1476 }
1477 self.cur_chunk += 1;
1478 }
1479 self.samples_left = csamp - self.cur_sample;
1480 self.cur_chunk += 1;
1481 }
5317ee9c 1482 } else if self.chunk_offsets.len() == self.chunk_sizes.len() {
7afec34d 1483 self.cur_chunk = self.cur_sample;
5317ee9c 1484 } else {
de82c821
KS		 1485 if !self.time_to_sample.is_empty() {
1486 let mut remaining = exp_pts;
1487 let mut abs_csamp = 0;
1488 for &(count, scount) in self.time_to_sample.iter() {
1489 let count = u64::from(count);
1490 let scount = u64::from(scount);
1491 let nblk = remaining / scount;
1492 if nblk < count {
1493 abs_csamp += nblk;
1494 break;
1495 }
1496 remaining -= count * scount;
1497 abs_csamp += count;
1498 }
1499 self.cur_sample = abs_csamp as usize;
1500 } else {
1501 self.cur_sample = exp_pts as usize;
1502 }
1503 let tgt_sample = self.cur_sample;
5317ee9c
KS		 1504 let mut csamp = 0;
1505 self.cur_chunk = 0;
1506 let mut cmap = self.sample_map.iter();
1507 let mut cur_samps = 0;
1508 let (mut next_idx, mut next_samples) = cmap.next().unwrap();
1509 loop {
1510 if self.cur_chunk + 1 == next_idx as usize {
1511 self.samples_left = cur_samps;
1512 cur_samps = next_samples as usize;
1513 if let Some((new_idx, new_samples)) = cmap.next() {
1514 next_idx = *new_idx;
1515 next_samples = *new_samples;
1516 }
1517 }
1518 csamp += cur_samps;
1519 if csamp > self.cur_sample {
1520 if self.cur_chunk >= self.chunk_offsets.len() {
a970b211
KS		 1521 self.cur_sample = csamp - cur_samps;
1522 self.samples_left = 0;
1523 self.cur_sample = csamp;
5317ee9c
KS		 1524 return Err(DemuxerError::SeekError);
1525 }
1526 self.last_offset = self.chunk_offsets[self.cur_chunk];
1527 break;
1528 }
1529 self.cur_chunk += 1;
1530 }
1531 self.cur_sample = csamp - cur_samps;
1532 self.samples_left = cur_samps;
1533 self.last_offset = self.chunk_offsets[self.cur_chunk];
1534 self.cur_chunk += 1;
de82c821
KS		 1535
1536 // try to refine sample position
1537 if self.chunk_sizes.len() > self.chunk_offsets.len() {
1538 for i in self.cur_sample..tgt_sample {
1539 self.cur_sample += 1;
1540 self.samples_left -= 1;
1541 self.last_offset += u64::from(self.chunk_sizes[i]);
1542 }
1543 }
7afec34d
KS		 1544 }
1545 } else {
1546 self.cur_chunk = self.cur_sample;
1547 }
61cab15b 1548 } else if self.chunk_offsets.len() != self.chunk_sizes.len() && !self.sample_map.is_empty() {
58309c73
KS		 1549 let mut csamp = 0;
1550 self.cur_chunk = 0;
1551 let mut cmap = self.sample_map.iter();
1552 let mut cur_samps = 0;
1553 let (mut next_idx, mut next_samples) = cmap.next().unwrap();
1554 loop {
bbbf86dd 1555 if self.cur_chunk + 1 == next_idx as usize {
58309c73
KS		 1556 self.samples_left = cur_samps;
1557 cur_samps = next_samples as usize;
1558 if let Some((new_idx, new_samples)) = cmap.next() {
1559 next_idx = *new_idx;
1560 next_samples = *new_samples;
1561 }
1562 }
1563 csamp += cur_samps;
1564 if csamp >= self.cur_sample {
7afec34d
KS		 1565 if self.cur_chunk >= self.chunk_offsets.len() {
1566 return Err(DemuxerError::SeekError);
1567 }
58309c73
KS		 1568 self.last_offset = self.chunk_offsets[self.cur_chunk];
1569 break;
1570 }
1571 self.cur_chunk += 1;
1572 }
1573 csamp -= cur_samps;
bbbf86dd 1574 for sample_no in csamp..self.cur_sample {
58309c73
KS		 1575 self.last_offset += self.get_size(sample_no) as u64;
1576 }
bbbf86dd
KS		 1577 self.samples_left = csamp + cur_samps - self.cur_sample;
1578 self.cur_chunk += 1;
58309c73 1579 }
d9bf7e74
KS		 1580 let cur_pts = self.timesearch.map_time(self.cur_sample as u32, &self.time_to_sample);
1581 let cur_time = NATimeInfo::ts_to_time(cur_pts, 1000, self.tb_num, self.tb_den);
1582 Ok(cur_time)
58309c73
KS		 1583 }
1584}
1585
07972bf3
KS		 1586fn process_packet(src: &mut ByteReader, strmgr: &StreamManager, track: &mut Track, pts: NATimeInfo, offset: u64, size: usize, first: bool) -> DemuxerResult<NAPacket> {
1587 if let Some(cpts) = pts.get_pts() {
1588 let ts = NATimeInfo::ts_to_time(cpts, 1000, pts.tb_num, pts.tb_den);
1589 track.cur_ts = Some(ts);
1590 } else {
1591 track.cur_ts = None;
1592 }
817e4872
KS		 1593 let stream = strmgr.get_stream(track.track_str_id);
1594 if stream.is_none() { return Err(DemuxerError::InvalidData); }
1595 let stream = stream.unwrap();
07972bf3
KS		 1596 src.seek(SeekFrom::Start(offset))?;
1597 let mut pkt = src.read_packet(stream, pts, false, size)?;
1598 if let Some(ref pal) = track.pal {
1599 let side_data = NASideData::Palette(first, pal.clone());
1600 pkt.add_side_data(side_data);
1601 }
1602 Ok(pkt)
1603}
1604
58309c73
KS		 1605impl<'a> DemuxCore<'a> for MOVDemuxer<'a> {
1606 fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
88fd1059
KS		 1607 if !self.macbinary {
1608 self.read_root(strmgr)?;
1609 } else {
1610 let ver = self.src.read_byte()?;
1611 validate!(ver == 0);
1612 self.src.read_skip(64)?;
1613 let tag = self.src.read_tag()?;
1614 validate!(&tag == b"MooV");
1615 self.src.read_skip(14)?;
1616 let data_length = self.src.read_u32be()?;
1617 validate!(data_length > 8);
1618 let rsrc_length = self.src.read_u32be()?;
1619 validate!(rsrc_length > 0);
1620 self.src.read_skip(31)?;
1621 let ver = self.src.read_byte()?;
1622 validate!(ver == 0x81);
1623 let ver = self.src.read_byte()?;
1624 validate!(ver == 0x81);
1625 //xxx: maybe check header CRC
1626
1627 let rsrc_start = 0x80 + ((data_length + 0x7F) & !0x7F);
1628 self.src.seek(SeekFrom::Start(rsrc_start.into()))?;
1629 let rsrc_off = self.src.read_u32be()?;
1630 let rsrc_map_off = self.src.read_u32be()?;
1631 let rsrc_size = self.src.read_u32be()?;
1632 let _rsrc_map_size = self.src.read_u32be()?;
1633 validate!(rsrc_off >= 0x10);
1634 validate!(rsrc_map_off >= rsrc_off + rsrc_size);
1635 self.src.seek(SeekFrom::Current(i64::from(rsrc_off - 16)))?;
1636 // I'm too lazy to parse resource map, so let's just iterate over resources for movie header
1637 let end_pos = u64::from(rsrc_start + rsrc_off + rsrc_size);
1638 let mut peek_buf = [0u8; 8];
1639 while self.src.tell() < end_pos {
1640 let cur_size = self.src.read_u32be()?;
1641 validate!(self.src.tell() + u64::from(cur_size) <= end_pos);
1642 if cur_size > 8 {
1643 let rsize = self.src.peek_u32be()?;
1644 if rsize == cur_size {
1645 self.src.peek_buf(&mut peek_buf)?;
1646 if &peek_buf[4..] == b"moov" {
1647 self.src.read_skip(8)?;
1648 self.read_moov(strmgr, rsize.into())?;
1649 self.mdat_pos = 8;
1650 break;
1651 }
1652 }
1653 }
1654 self.src.read_skip(cur_size as usize)?;
1655 }
1656 }
58309c73 1657 validate!(self.mdat_pos > 0);
61cab15b 1658 validate!(!self.tracks.is_empty());
0a0456a8 1659 for track in self.tracks.iter_mut() {
817e4872
KS		 1660 let mut strm = None;
1661 std::mem::swap(&mut track.stream, &mut strm);
1662 if let Some(stream) = strm {
0a0456a8
KS		 1663 let str_id = strmgr.add_stream(stream).unwrap();
1664 track.track_str_id = str_id;
1665 }
1666 }
88fd1059
KS		 1667 if self.macbinary {
1668 // patch data offsets
1669 for track in self.tracks.iter_mut() {
1670 for offset in track.chunk_offsets.iter_mut() {
1671 *offset += 0x80;
1672 }
1673 }
1674 }
58309c73
KS		 1675 for track in self.tracks.iter() {
1676 track.fill_seek_index(seek_index);
1677 }
1678 self.src.seek(SeekFrom::Start(self.mdat_pos))?;
1679 self.cur_track = 0;
1680 Ok(())
1681 }
1682
1683 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
61cab15b 1684 if self.tracks.is_empty() {
58309c73
KS		 1685 return Err(DemuxerError::EOF);
1686 }
07972bf3
KS		 1687 let mut has_all_time = true;
1688 let mut min_ts = std::u64::MAX;
1689 for trk in self.tracks.iter() {
1690 if let Some(ts) = trk.cur_ts {
1691 min_ts = min_ts.min(ts);
1692 } else {
1693 has_all_time = false;
1694 break;
1695 }
1696 }
1697 if has_all_time {
1698 for (trk_no, track) in self.tracks.iter_mut().enumerate() {
1699 if let Some(ts) = track.cur_ts {
1700 if ts == min_ts {
1701 let first = track.cur_sample == 0;
1702 if let Some((pts, offset, size)) = track.get_next_chunk() {
1703 self.cur_track = trk_no + 1;
6f263099 1704 return process_packet(self.src, strmgr, track, pts, offset, size, first);
07972bf3
KS		 1705 }
1706 }
1707 }
1708 }
1709 }
1710
58309c73
KS		 1711 for _ in 0..self.tracks.len() {
1712 if self.cur_track >= self.tracks.len() {
1713 self.cur_track = 0;
1714 }
1715 let track = &mut self.tracks[self.cur_track];
1716 self.cur_track += 1;
58cd51fa 1717 let first = track.cur_sample == 0;
58309c73 1718 if let Some((pts, offset, size)) = track.get_next_chunk() {
6f263099 1719 return process_packet(self.src, strmgr, track, pts, offset, size, first);
58309c73
KS		 1720 }
1721 }
61cab15b 1722 Err(DemuxerError::EOF)
58309c73
KS		 1723 }
1724
24d99894 1725 fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
58309c73
KS		 1726 let ret = seek_index.find_pos(time);
1727 if ret.is_none() {
5317ee9c
KS		 1728 if let NATimePoint::Milliseconds(_) = time {
1729 let mut aonly = true;
1730 for track in self.tracks.iter() {
de82c821 1731 if track.stream_type != StreamType::Audio {
5317ee9c
KS		 1732 aonly = false;
1733 break;
1734 }
1735 }
1736 if aonly {
1737 for track in self.tracks.iter_mut() {
1738 track.seek(0, time)?;
1739 }
1740 return Ok(());
1741 }
1742 }
58309c73
KS		 1743 return Err(DemuxerError::SeekError);
1744 }
1745 let seek_info = ret.unwrap();
5317ee9c
KS		 1746 let tbn = self.tracks[seek_info.str_id as usize].tb_num;
1747 let tbd = self.tracks[seek_info.str_id as usize].tb_den;
d9bf7e74
KS		 1748 let mut vpts = None;
1749 let mut apts = None;
58309c73 1750 for track in self.tracks.iter_mut() {
5317ee9c
KS		 1751 let cur_pts = if track.track_id == seek_info.str_id {
1752 seek_info.pts
1753 } else {
1754 seek_info.pts * u64::from(tbn) * u64::from(track.tb_den) / (u64::from(tbd) * u64::from(track.tb_num))
1755 };
d9bf7e74
KS		 1756 let actual_time = track.seek(cur_pts, time)?;
1757 match track.stream_type {
1758 StreamType::Video => vpts = Some(actual_time),
1759 StreamType::Audio => apts = Some(actual_time),
1760 _ => {},
1761 };
58309c73 1762 }
d9bf7e74
KS		 1763 /* For audio+video stream case when the post-seek actual times differ
1764 by more than half a second try to seek audio to a closer position
1765 to video.
1766 */
1767 if let (true, Some(vtime), Some(atime)) = (self.tracks.len() == 2, vpts, apts) {
1768 if vtime.max(atime) - vtime.min(atime) > 500 && atime != 0 {
1769 for track in self.tracks.iter_mut() {
1770 if track.stream_type == StreamType::Audio {
1771 let new_pts = NATimeInfo::time_to_ts(vtime, 1000, track.tb_num, track.tb_den);
1772 track.seek(new_pts, NATimePoint::Milliseconds(vtime))?;
1773 }
1774 }
1775 }
1776 }
1777
58309c73
KS		 1778 Ok(())
1779 }
a480a0de
KS		 1780 fn get_duration(&self) -> u64 {
1781 if self.tb_den != 0 {
1782 u64::from(self.duration) * 1000 / u64::from(self.tb_den)
1783 } else {
1784 0
1785 }
1786 }
58309c73
KS		 1787}
1788
650d7bfb
KS		 1789const PRINT_CHUNKS: &str = "print_chunks";
1790
1791const DEMUXER_OPTIONS: &[NAOptionDefinition] = &[
1792 NAOptionDefinition {
1793 name: PRINT_CHUNKS,
1794 description: "Print parsed file structure",
1795 opt_type: NAOptionDefinitionType::Bool },
1796];
1797
787b8d03 1798impl<'a> NAOptionHandler for MOVDemuxer<'a> {
650d7bfb 1799 fn get_supported_options(&self) -> &[NAOptionDefinition] { DEMUXER_OPTIONS }
b7c882c1 1800 #[allow(clippy::single_match)]
650d7bfb
KS		 1801 fn set_options(&mut self, options: &[NAOption]) {
1802 for option in options.iter() {
1803 for opt_def in DEMUXER_OPTIONS.iter() {
1804 if opt_def.check(option).is_ok() {
1805 match (option.name, &option.value) {
1806 (PRINT_CHUNKS, NAValue::Bool(val)) => {
1807 self.print_chunks = *val;
1808 },
1809 _ => {},
1810 }
1811 }
1812 }
1813 }
1814 }
1815 fn query_option_value(&self, name: &str) -> Option<NAValue> {
1816 match name {
1817 PRINT_CHUNKS => Some(NAValue::Bool(self.print_chunks)),
1818 _ => None,
1819 }
1820 }
787b8d03
KS		 1821}
1822
58309c73
KS		 1823impl<'a> MOVDemuxer<'a> {
1824 fn new(io: &'a mut ByteReader<'a>) -> Self {
88fd1059
KS		 1825 Self::new_common(io, false)
1826 }
1827 fn new_macbinary(io: &'a mut ByteReader<'a>) -> Self {
1828 Self::new_common(io, true)
1829 }
1830 fn new_common(io: &'a mut ByteReader<'a>, macbinary: bool) -> Self {
58309c73
KS		 1831 MOVDemuxer {
1832 src: io,
1833 depth: 0,
1834 mdat_pos: 0,
1835 mdat_size: 0,
1836 tracks: Vec::with_capacity(2),
1837 cur_track: 0,
1838 tb_den: 0,
1839 duration: 0,
58cd51fa 1840 pal: None,
650d7bfb 1841
0a0456a8
KS		 1842 moof_off: 0,
1843
650d7bfb 1844 print_chunks: false,
88fd1059
KS		 1845
1846 macbinary,
58309c73
KS		 1847 }
1848 }
1849 fn read_root(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
1850 self.depth = 0;
1851 while self.src.left() != 0 {
6f263099 1852 let ret = read_chunk_header(self.src);
58309c73
KS		 1853 if ret.is_err() { break; }
1854 let (ctype, size) = ret.unwrap();
0a0456a8
KS		 1855 if self.print_chunks {
1856 print_cname(ctype, size, self.src.tell(), 0);
1857 }
58309c73
KS		 1858 if IGNORED_CHUNKS.contains(&ctype) {
1859 self.src.skip64(size)?;
1860 continue;
1861 }
1862 let handler = ROOT_CHUNK_HANDLERS.iter().find(|x| x.ctype == ctype);
1863 let read_size;
6f263099 1864 if let Some(handler) = handler {
58309c73
KS		 1865 read_size = (handler.parse)(self, strmgr, size)?;
1866 } else {
1867 println!("skipping unknown chunk {:08X} size {}", ctype, size);
1868 read_size = 0;
1869 }
1870 validate!(read_size <= size);
1871 self.src.skip64(size - read_size)?;
1872 }
1873//todo check if all needed chunks are found
1874 Ok(())
1875 }
1876 read_chunk_list!(root; "moov", read_moov, MOOV_CHUNK_HANDLERS);
0a0456a8 1877 read_chunk_list!(root; "moof", read_moof, MOOF_CHUNK_HANDLERS);
58309c73
KS		 1878}
1879
1880pub struct MOVDemuxerCreator { }
1881
1882impl DemuxerCreator for MOVDemuxerCreator {
1883 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1884 Box::new(MOVDemuxer::new(br))
1885 }
1886 fn get_name(&self) -> &'static str { "mov" }
1887}
1888
88fd1059
KS		 1889pub struct MacBinaryMOVDemuxerCreator { }
1890
1891impl DemuxerCreator for MacBinaryMOVDemuxerCreator {
1892 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1893 Box::new(MOVDemuxer::new_macbinary(br))
1894 }
1895 fn get_name(&self) -> &'static str { "mov-macbin" }
1896}
1897
2736c15a
KS		 1898const MOV_DEFAULT_PAL_2BIT: [u8; 4 * 4] = [
1899 0x93, 0x65, 0x5E, 0x00,
1900 0xFF, 0xFF, 0xFF, 0x00,
1901 0xDF, 0xD0, 0xAB, 0x00,
1902 0x00, 0x00, 0x00, 0x00
1903];
1904const MOV_DEFAULT_PAL_4BIT: [u8; 16 * 4] = [
1905 0xFF, 0xFB, 0xFF, 0x00,
1906 0xEF, 0xD9, 0xBB, 0x00,
1907 0xE8, 0xC9, 0xB1, 0x00,
1908 0x93, 0x65, 0x5E, 0x00,
1909 0xFC, 0xDE, 0xE8, 0x00,
1910 0x9D, 0x88, 0x91, 0x00,
1911 0xFF, 0xFF, 0xFF, 0x00,
1912 0xFF, 0xFF, 0xFF, 0x00,
1913 0xFF, 0xFF, 0xFF, 0x00,
1914 0x47, 0x48, 0x37, 0x00,
1915 0x7A, 0x5E, 0x55, 0x00,
1916 0xDF, 0xD0, 0xAB, 0x00,
1917 0xFF, 0xFB, 0xF9, 0x00,
1918 0xE8, 0xCA, 0xC5, 0x00,
1919 0x8A, 0x7C, 0x77, 0x00,
1920 0x00, 0x00, 0x00, 0x00
1921];
1922const MOV_DEFAULT_PAL_8BIT: [u8; 256 * 4] = [
1923 0xFF, 0xFF, 0xFF, 0x00,
1924 0xFF, 0xFF, 0xCC, 0x00,
1925 0xFF, 0xFF, 0x99, 0x00,
1926 0xFF, 0xFF, 0x66, 0x00,
1927 0xFF, 0xFF, 0x33, 0x00,
1928 0xFF, 0xFF, 0x00, 0x00,
1929 0xFF, 0xCC, 0xFF, 0x00,
1930 0xFF, 0xCC, 0xCC, 0x00,
1931 0xFF, 0xCC, 0x99, 0x00,
1932 0xFF, 0xCC, 0x66, 0x00,
1933 0xFF, 0xCC, 0x33, 0x00,
1934 0xFF, 0xCC, 0x00, 0x00,
1935 0xFF, 0x99, 0xFF, 0x00,
1936 0xFF, 0x99, 0xCC, 0x00,
1937 0xFF, 0x99, 0x99, 0x00,
1938 0xFF, 0x99, 0x66, 0x00,
1939 0xFF, 0x99, 0x33, 0x00,
1940 0xFF, 0x99, 0x00, 0x00,
1941 0xFF, 0x66, 0xFF, 0x00,
1942 0xFF, 0x66, 0xCC, 0x00,
1943 0xFF, 0x66, 0x99, 0x00,
1944 0xFF, 0x66, 0x66, 0x00,
1945 0xFF, 0x66, 0x33, 0x00,
1946 0xFF, 0x66, 0x00, 0x00,
1947 0xFF, 0x33, 0xFF, 0x00,
1948 0xFF, 0x33, 0xCC, 0x00,
1949 0xFF, 0x33, 0x99, 0x00,
1950 0xFF, 0x33, 0x66, 0x00,
1951 0xFF, 0x33, 0x33, 0x00,
1952 0xFF, 0x33, 0x00, 0x00,
1953 0xFF, 0x00, 0xFF, 0x00,
1954 0xFF, 0x00, 0xCC, 0x00,
1955 0xFF, 0x00, 0x99, 0x00,
1956 0xFF, 0x00, 0x66, 0x00,
1957 0xFF, 0x00, 0x33, 0x00,
1958 0xFF, 0x00, 0x00, 0x00,
1959 0xCC, 0xFF, 0xFF, 0x00,
1960 0xCC, 0xFF, 0xCC, 0x00,
1961 0xCC, 0xFF, 0x99, 0x00,
1962 0xCC, 0xFF, 0x66, 0x00,
1963 0xCC, 0xFF, 0x33, 0x00,
1964 0xCC, 0xFF, 0x00, 0x00,
1965 0xCC, 0xCC, 0xFF, 0x00,
1966 0xCC, 0xCC, 0xCC, 0x00,
1967 0xCC, 0xCC, 0x99, 0x00,
1968 0xCC, 0xCC, 0x66, 0x00,
1969 0xCC, 0xCC, 0x33, 0x00,
1970 0xCC, 0xCC, 0x00, 0x00,
1971 0xCC, 0x99, 0xFF, 0x00,
1972 0xCC, 0x99, 0xCC, 0x00,
1973 0xCC, 0x99, 0x99, 0x00,
1974 0xCC, 0x99, 0x66, 0x00,
1975 0xCC, 0x99, 0x33, 0x00,
1976 0xCC, 0x99, 0x00, 0x00,
1977 0xCC, 0x66, 0xFF, 0x00,
1978 0xCC, 0x66, 0xCC, 0x00,
1979 0xCC, 0x66, 0x99, 0x00,
1980 0xCC, 0x66, 0x66, 0x00,
1981 0xCC, 0x66, 0x33, 0x00,
1982 0xCC, 0x66, 0x00, 0x00,
1983 0xCC, 0x33, 0xFF, 0x00,
1984 0xCC, 0x33, 0xCC, 0x00,
1985 0xCC, 0x33, 0x99, 0x00,
1986 0xCC, 0x33, 0x66, 0x00,
1987 0xCC, 0x33, 0x33, 0x00,
1988 0xCC, 0x33, 0x00, 0x00,
1989 0xCC, 0x00, 0xFF, 0x00,
1990 0xCC, 0x00, 0xCC, 0x00,
1991 0xCC, 0x00, 0x99, 0x00,
1992 0xCC, 0x00, 0x66, 0x00,
1993 0xCC, 0x00, 0x33, 0x00,
1994 0xCC, 0x00, 0x00, 0x00,
1995 0x99, 0xFF, 0xFF, 0x00,
1996 0x99, 0xFF, 0xCC, 0x00,
1997 0x99, 0xFF, 0x99, 0x00,
1998 0x99, 0xFF, 0x66, 0x00,
1999 0x99, 0xFF, 0x33, 0x00,
2000 0x99, 0xFF, 0x00, 0x00,
2001 0x99, 0xCC, 0xFF, 0x00,
2002 0x99, 0xCC, 0xCC, 0x00,
2003 0x99, 0xCC, 0x99, 0x00,
2004 0x99, 0xCC, 0x66, 0x00,
2005 0x99, 0xCC, 0x33, 0x00,
2006 0x99, 0xCC, 0x00, 0x00,
2007 0x99, 0x99, 0xFF, 0x00,
2008 0x99, 0x99, 0xCC, 0x00,
2009 0x99, 0x99, 0x99, 0x00,
2010 0x99, 0x99, 0x66, 0x00,
2011 0x99, 0x99, 0x33, 0x00,
2012 0x99, 0x99, 0x00, 0x00,
2013 0x99, 0x66, 0xFF, 0x00,
2014 0x99, 0x66, 0xCC, 0x00,
2015 0x99, 0x66, 0x99, 0x00,
2016 0x99, 0x66, 0x66, 0x00,
2017 0x99, 0x66, 0x33, 0x00,
2018 0x99, 0x66, 0x00, 0x00,
2019 0x99, 0x33, 0xFF, 0x00,
2020 0x99, 0x33, 0xCC, 0x00,
2021 0x99, 0x33, 0x99, 0x00,
2022 0x99, 0x33, 0x66, 0x00,
2023 0x99, 0x33, 0x33, 0x00,
2024 0x99, 0x33, 0x00, 0x00,
2025 0x99, 0x00, 0xFF, 0x00,
2026 0x99, 0x00, 0xCC, 0x00,
2027 0x99, 0x00, 0x99, 0x00,
2028 0x99, 0x00, 0x66, 0x00,
2029 0x99, 0x00, 0x33, 0x00,
2030 0x99, 0x00, 0x00, 0x00,
2031 0x66, 0xFF, 0xFF, 0x00,
2032 0x66, 0xFF, 0xCC, 0x00,
2033 0x66, 0xFF, 0x99, 0x00,
2034 0x66, 0xFF, 0x66, 0x00,
2035 0x66, 0xFF, 0x33, 0x00,
2036 0x66, 0xFF, 0x00, 0x00,
2037 0x66, 0xCC, 0xFF, 0x00,
2038 0x66, 0xCC, 0xCC, 0x00,
2039 0x66, 0xCC, 0x99, 0x00,
2040 0x66, 0xCC, 0x66, 0x00,
2041 0x66, 0xCC, 0x33, 0x00,
2042 0x66, 0xCC, 0x00, 0x00,
2043 0x66, 0x99, 0xFF, 0x00,
2044 0x66, 0x99, 0xCC, 0x00,
2045 0x66, 0x99, 0x99, 0x00,
2046 0x66, 0x99, 0x66, 0x00,
2047 0x66, 0x99, 0x33, 0x00,
2048 0x66, 0x99, 0x00, 0x00,
2049 0x66, 0x66, 0xFF, 0x00,
2050 0x66, 0x66, 0xCC, 0x00,
2051 0x66, 0x66, 0x99, 0x00,
2052 0x66, 0x66, 0x66, 0x00,
2053 0x66, 0x66, 0x33, 0x00,
2054 0x66, 0x66, 0x00, 0x00,
2055 0x66, 0x33, 0xFF, 0x00,
2056 0x66, 0x33, 0xCC, 0x00,
2057 0x66, 0x33, 0x99, 0x00,
2058 0x66, 0x33, 0x66, 0x00,
2059 0x66, 0x33, 0x33, 0x00,
2060 0x66, 0x33, 0x00, 0x00,
2061 0x66, 0x00, 0xFF, 0x00,
2062 0x66, 0x00, 0xCC, 0x00,
2063 0x66, 0x00, 0x99, 0x00,
2064 0x66, 0x00, 0x66, 0x00,
2065 0x66, 0x00, 0x33, 0x00,
2066 0x66, 0x00, 0x00, 0x00,
2067 0x33, 0xFF, 0xFF, 0x00,
2068 0x33, 0xFF, 0xCC, 0x00,
2069 0x33, 0xFF, 0x99, 0x00,
2070 0x33, 0xFF, 0x66, 0x00,
2071 0x33, 0xFF, 0x33, 0x00,
2072 0x33, 0xFF, 0x00, 0x00,
2073 0x33, 0xCC, 0xFF, 0x00,
2074 0x33, 0xCC, 0xCC, 0x00,
2075 0x33, 0xCC, 0x99, 0x00,
2076 0x33, 0xCC, 0x66, 0x00,
2077 0x33, 0xCC, 0x33, 0x00,
2078 0x33, 0xCC, 0x00, 0x00,
2079 0x33, 0x99, 0xFF, 0x00,
2080 0x33, 0x99, 0xCC, 0x00,
2081 0x33, 0x99, 0x99, 0x00,
2082 0x33, 0x99, 0x66, 0x00,
2083 0x33, 0x99, 0x33, 0x00,
2084 0x33, 0x99, 0x00, 0x00,
2085 0x33, 0x66, 0xFF, 0x00,
2086 0x33, 0x66, 0xCC, 0x00,
2087 0x33, 0x66, 0x99, 0x00,
2088 0x33, 0x66, 0x66, 0x00,
2089 0x33, 0x66, 0x33, 0x00,
2090 0x33, 0x66, 0x00, 0x00,
2091 0x33, 0x33, 0xFF, 0x00,
2092 0x33, 0x33, 0xCC, 0x00,
2093 0x33, 0x33, 0x99, 0x00,
2094 0x33, 0x33, 0x66, 0x00,
2095 0x33, 0x33, 0x33, 0x00,
2096 0x33, 0x33, 0x00, 0x00,
2097 0x33, 0x00, 0xFF, 0x00,
2098 0x33, 0x00, 0xCC, 0x00,
2099 0x33, 0x00, 0x99, 0x00,
2100 0x33, 0x00, 0x66, 0x00,
2101 0x33, 0x00, 0x33, 0x00,
2102 0x33, 0x00, 0x00, 0x00,
2103 0x00, 0xFF, 0xFF, 0x00,
2104 0x00, 0xFF, 0xCC, 0x00,
2105 0x00, 0xFF, 0x99, 0x00,
2106 0x00, 0xFF, 0x66, 0x00,
2107 0x00, 0xFF, 0x33, 0x00,
2108 0x00, 0xFF, 0x00, 0x00,
2109 0x00, 0xCC, 0xFF, 0x00,
2110 0x00, 0xCC, 0xCC, 0x00,
2111 0x00, 0xCC, 0x99, 0x00,
2112 0x00, 0xCC, 0x66, 0x00,
2113 0x00, 0xCC, 0x33, 0x00,
2114 0x00, 0xCC, 0x00, 0x00,
2115 0x00, 0x99, 0xFF, 0x00,
2116 0x00, 0x99, 0xCC, 0x00,
2117 0x00, 0x99, 0x99, 0x00,
2118 0x00, 0x99, 0x66, 0x00,
2119 0x00, 0x99, 0x33, 0x00,
2120 0x00, 0x99, 0x00, 0x00,
2121 0x00, 0x66, 0xFF, 0x00,
2122 0x00, 0x66, 0xCC, 0x00,
2123 0x00, 0x66, 0x99, 0x00,
2124 0x00, 0x66, 0x66, 0x00,
2125 0x00, 0x66, 0x33, 0x00,
2126 0x00, 0x66, 0x00, 0x00,
2127 0x00, 0x33, 0xFF, 0x00,
2128 0x00, 0x33, 0xCC, 0x00,
2129 0x00, 0x33, 0x99, 0x00,
2130 0x00, 0x33, 0x66, 0x00,
2131 0x00, 0x33, 0x33, 0x00,
2132 0x00, 0x33, 0x00, 0x00,
2133 0x00, 0x00, 0xFF, 0x00,
2134 0x00, 0x00, 0xCC, 0x00,
2135 0x00, 0x00, 0x99, 0x00,
2136 0x00, 0x00, 0x66, 0x00,
2137 0x00, 0x00, 0x33, 0x00,
2138 0xEE, 0x00, 0x00, 0x00,
2139 0xDD, 0x00, 0x00, 0x00,
2140 0xBB, 0x00, 0x00, 0x00,
2141 0xAA, 0x00, 0x00, 0x00,
2142 0x88, 0x00, 0x00, 0x00,
2143 0x77, 0x00, 0x00, 0x00,
2144 0x55, 0x00, 0x00, 0x00,
2145 0x44, 0x00, 0x00, 0x00,
2146 0x22, 0x00, 0x00, 0x00,
2147 0x11, 0x00, 0x00, 0x00,
2148 0x00, 0xEE, 0x00, 0x00,
2149 0x00, 0xDD, 0x00, 0x00,
2150 0x00, 0xBB, 0x00, 0x00,
2151 0x00, 0xAA, 0x00, 0x00,
2152 0x00, 0x88, 0x00, 0x00,
2153 0x00, 0x77, 0x00, 0x00,
2154 0x00, 0x55, 0x00, 0x00,
2155 0x00, 0x44, 0x00, 0x00,
2156 0x00, 0x22, 0x00, 0x00,
2157 0x00, 0x11, 0x00, 0x00,
2158 0x00, 0x00, 0xEE, 0x00,
2159 0x00, 0x00, 0xDD, 0x00,
2160 0x00, 0x00, 0xBB, 0x00,
2161 0x00, 0x00, 0xAA, 0x00,
2162 0x00, 0x00, 0x88, 0x00,
2163 0x00, 0x00, 0x77, 0x00,
2164 0x00, 0x00, 0x55, 0x00,
2165 0x00, 0x00, 0x44, 0x00,
2166 0x00, 0x00, 0x22, 0x00,
2167 0x00, 0x00, 0x11, 0x00,
2168 0xEE, 0xEE, 0xEE, 0x00,
2169 0xDD, 0xDD, 0xDD, 0x00,
2170 0xBB, 0xBB, 0xBB, 0x00,
2171 0xAA, 0xAA, 0xAA, 0x00,
2172 0x88, 0x88, 0x88, 0x00,
2173 0x77, 0x77, 0x77, 0x00,
2174 0x55, 0x55, 0x55, 0x00,
2175 0x44, 0x44, 0x44, 0x00,
2176 0x22, 0x22, 0x22, 0x00,
2177 0x11, 0x11, 0x11, 0x00,
2178 0x00, 0x00, 0x00, 0x00
2179];
2180
58309c73
KS		 2181#[cfg(test)]
2182mod test {
2183 use super::*;
2184 use std::fs::File;
2185
2186 #[test]
2187 fn test_mov_demux() {
886cde48 2188 // sample: https://samples.mplayerhq.hu/V-codecs/IV32/cubes.mov
58309c73
KS		 2189 let mut file = File::open("assets/Indeo/cubes.mov").unwrap();
2190 let mut fr = FileReader::new_read(&mut file);
2191 let mut br = ByteReader::new(&mut fr);
2192 let mut dmx = MOVDemuxer::new(&mut br);
2193 let mut sm = StreamManager::new();
2194 let mut si = SeekIndex::new();
2195 dmx.open(&mut sm, &mut si).unwrap();
2196
2197 loop {
2198 let pktres = dmx.get_frame(&mut sm);
2199 if let Err(e) = pktres {
2200 if e == DemuxerError::EOF { break; }
2201 panic!("error");
2202 }
2203 let pkt = pktres.unwrap();
2204 println!("Got {}", pkt);
2205 }
2206 }
0a0456a8
KS		 2207
2208 #[test]
2209 fn test_dash_demux() {
886cde48 2210 // sample: a stream downloaded with youtube-dl
0a0456a8
KS		 2211 let mut file = File::open("assets/ITU/dash.m4a").unwrap();
2212 let mut fr = FileReader::new_read(&mut file);
2213 let mut br = ByteReader::new(&mut fr);
2214 let mut dmx = MOVDemuxer::new(&mut br);
2215 let mut sm = StreamManager::new();
2216 let mut si = SeekIndex::new();
2217 dmx.open(&mut sm, &mut si).unwrap();
2218
2219 loop {
2220 let pktres = dmx.get_frame(&mut sm);
2221 if let Err(e) = pktres {
2222 if e == DemuxerError::EOF { break; }
2223 panic!("error");
2224 }
2225 let pkt = pktres.unwrap();
2226 println!("Got {}", pkt);
2227 }
2228 }
88fd1059
KS		 2229
2230 #[test]
2231 fn test_macbinary_demux() {
2232 // sample from King's Quest VI Macintosh edition
2233 let mut file = File::open("assets/QT/Halfdome.bin").unwrap();
2234 let mut fr = FileReader::new_read(&mut file);
2235 let mut br = ByteReader::new(&mut fr);
2236 let mut dmx = MOVDemuxer::new_macbinary(&mut br);
2237 let mut sm = StreamManager::new();
2238 let mut si = SeekIndex::new();
2239 dmx.open(&mut sm, &mut si).unwrap();
2240
2241 loop {
2242 let pktres = dmx.get_frame(&mut sm);
2243 if let Err(e) = pktres {
2244 if e == DemuxerError::EOF { break; }
2245 panic!("error");
2246 }
2247 let pkt = pktres.unwrap();
2248 println!("Got {}", pkt);
2249 }
2250 }
58309c73 2251}
NihAV is a research multimedia framework