X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-commonfmt%2Fsrc%2Fdemuxers%2Fmov.rs;h=87eb2f17a9ff366b9082a683480f08aecf8c3bcf;hb=e6aaad5c5273cd814b5748b7faf3751835a37217;hp=9a77496fc2717e70ba563b2756adacd18ae65ba6;hpb=0a0456a8355d0bd06c8f8612bfd3326868a6b25f;p=nihav.git diff --git a/nihav-commonfmt/src/demuxers/mov.rs b/nihav-commonfmt/src/demuxers/mov.rs index 9a77496..87eb2f1 100644 --- a/nihav-commonfmt/src/demuxers/mov.rs +++ b/nihav-commonfmt/src/demuxers/mov.rs @@ -43,10 +43,11 @@ fn read_chunk_header(br: &mut ByteReader) -> DemuxerResult<(u32, u64)> { fn read_palette(br: &mut ByteReader, size: u64, pal: &mut [u8; 1024]) -> DemuxerResult { let _seed = br.read_u32be()?; - let _flags = br.read_u16be()?; + let flags = br.read_u16be()?; let palsize = (br.read_u16be()? as usize) + 1; validate!(palsize <= 256); - validate!((palsize as u64) * 8 + 8 == size); + validate!(flags == 0 || flags == 0x4000 || flags == 0x8000); + validate!((palsize as u64) * 8 + 8 <= size); for i in 0..palsize { let a = br.read_u16be()?; let r = br.read_u16be()?; @@ -55,7 +56,12 @@ fn read_palette(br: &mut ByteReader, size: u64, pal: &mut [u8; 1024]) -> Demuxer pal[i * 4] = (r >> 8) as u8; pal[i * 4 + 1] = (g >> 8) as u8; pal[i * 4 + 2] = (b >> 8) as u8; - pal[i * 4 + 3] = (a >> 8) as u8; + if flags == 0x8000 { + pal[i * 4 + 3] = (a >> 8) as u8; + } + } + if flags == 0x4000 { + br.read_skip(8)?; } Ok(size) } @@ -86,8 +92,8 @@ fn print_cname(ctype: u32, size: u64, off: u64, depth: u8) { for _ in 0..depth { print!(" "); } let tag = [(ctype >> 24) as u8, (ctype >> 16) as u8, (ctype >> 8) as u8, ctype as u8]; let mut printable = true; - for &ch in tag.iter() { - if ch < 0x20 || ch > 0x7F { + for ch in tag.iter() { + if !(0x20..=0x7F).contains(ch) { printable = false; break; } @@ -107,7 +113,7 @@ macro_rules! read_chunk_list { validate!(self.depth < 32); let list_end = self.src.tell() + size; while self.src.tell() < list_end { - let ret = read_chunk_header(&mut self.src); + let ret = read_chunk_header(self.src); if ret.is_err() { break; } let (ctype, size) = ret.unwrap(); if self.print_chunks { @@ -205,6 +211,7 @@ const MOOV_CHUNK_HANDLERS: &[RootChunkHandler] = &[ RootChunkHandler { ctype: mktag!(b"trak"), parse: read_trak }, RootChunkHandler { ctype: mktag!(b"meta"), parse: read_meta }, RootChunkHandler { ctype: mktag!(b"mvex"), parse: read_mvex }, + RootChunkHandler { ctype: mktag!(b"iods"), parse: skip_chunk_mov }, ]; fn read_mvhd(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult { @@ -277,7 +284,7 @@ fn read_cmov(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> Dem fn read_ctab(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult { let mut pal = [0; 1024]; - let size = read_palette(&mut dmx.src, size, &mut pal)?; + let size = read_palette(dmx.src, size, &mut pal)?; dmx.pal = Some(Arc::new(pal)); Ok(size) } @@ -291,10 +298,14 @@ fn read_mvex(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64) -> Ok(0) } +fn skip_chunk_mov(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64) -> DemuxerResult { + Ok(0) +} + fn read_trak(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult { let mut track = Track::new(dmx.cur_track as u32, dmx.tb_den); track.print_chunks = dmx.print_chunks; - track.read_trak(&mut dmx.src, size)?; + track.read_trak(dmx.src, size)?; validate!(track.tkhd_found && track.stsd_found); validate!(strmgr.get_stream_by_id(track.track_id).is_none()); dmx.cur_track += 1; @@ -340,7 +351,7 @@ fn read_traf(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> De } if let Some(track) = track { track.moof_off = dmx.moof_off; - track.read_traf(&mut dmx.src, size)?; + track.read_traf(dmx.src, size)?; Ok(size) } else { Ok(0) @@ -562,6 +573,7 @@ fn parse_audio_edata(br: &mut ByteReader, start_pos: u64, size: u64) -> DemuxerR } } +#[allow(clippy::neg_cmp_op_on_partial_ord)] fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult { const KNOWN_STSD_SIZE: u64 = 24; validate!(size >= KNOWN_STSD_SIZE); @@ -601,22 +613,25 @@ fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult let ctable_id = br.read_u16be()?; let grayscale = depth > 0x20 || depth == 1; let depth = if grayscale { depth & 0x1F } else { depth }; - validate!(depth <= 8 || (ctable_id == 0xFFFF)); if ctable_id == 0 { let max_pal_size = start_pos + size - br.tell(); - let mut pal = [0; 1024]; - read_palette(br, max_pal_size, &mut pal)?; - track.pal = Some(Arc::new(pal)); + if depth <= 8 { + let mut pal = [0; 1024]; + read_palette(br, max_pal_size, &mut pal)?; + track.pal = Some(Arc::new(pal)); + } else { + br.read_skip(max_pal_size as usize)?; + } } else if (depth <= 8) && !grayscale { match depth & 0x1F { 2 => { let mut pal = [0; 1024]; - (&mut pal[..4 * 4]).copy_from_slice(&MOV_DEFAULT_PAL_2BIT); + pal[..4 * 4].copy_from_slice(&MOV_DEFAULT_PAL_2BIT); track.pal = Some(Arc::new(pal)); }, 4 => { let mut pal = [0; 1024]; - (&mut pal[..16 * 4]).copy_from_slice(&MOV_DEFAULT_PAL_4BIT); + pal[..16 * 4].copy_from_slice(&MOV_DEFAULT_PAL_4BIT); track.pal = Some(Arc::new(pal)); }, 8 => { @@ -684,15 +699,19 @@ fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult let sver = br.read_u16be()?; let _revision = br.read_u16le()?; let _vendor = br.read_u32be()?; - let nchannels = br.read_u16be()?; - validate!(nchannels <= 64); + let mut nchannels = br.read_u16be()?; + if sver != 2 { + validate!(nchannels <= 64); + } let sample_size = br.read_u16be()?; validate!(sample_size <= 128); let _compr_id = br.read_u16be()?; let packet_size = br.read_u16be()? as usize; validate!(packet_size == 0); - let sample_rate = br.read_u32be()?; - validate!(sample_rate > (1 << 16)); + let mut sample_rate = br.read_u32be()? >> 16; + if sver != 2 { + validate!(sample_rate > 0); + } let cname = if let Some(name) = find_codec_from_mov_audio_fourcc(&fcc) { name } 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]))) { @@ -705,27 +724,47 @@ fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult soniton.signed = false; } let block_align = 1; - if sver == 1 { - let samples_per_packet = br.read_u32be()?; - let _bytes_per_packet = br.read_u32be()?; - let bytes_per_frame = br.read_u32be()?; - let _bytes_per_sample = br.read_u32be()?; - track.bsize = bytes_per_frame as usize; - track.frame_samples = samples_per_packet as usize; - track.tb_num = samples_per_packet; - } else { - track.bsize = (sample_size / 8) as usize; + match sver { + 1 => { + let samples_per_packet = br.read_u32be()?; + let _bytes_per_packet = br.read_u32be()?; + let bytes_per_frame = br.read_u32be()?; + let _bytes_per_sample = br.read_u32be()?; + track.bsize = bytes_per_frame as usize; + track.frame_samples = samples_per_packet as usize; + track.tb_num = samples_per_packet; + }, + 2 => { + br.read_u32be()?; // some size + let srate = br.read_f64be()?; + validate!(srate > 1.0); + sample_rate = srate as u32; + let channels = br.read_u32be()?; + validate!(channels > 0 && channels < 255); + nchannels = channels as u16; + br.read_u32be()?; // always 0x7F000000 + let _bits_per_csample = br.read_u32be()?; + let _codec_flags = br.read_u32be()?; + let bytes_per_frame = br.read_u32be()?; + let samples_per_packet = br.read_u32be()?; + track.bsize = bytes_per_frame as usize; + track.frame_samples = samples_per_packet as usize; + track.tb_num = samples_per_packet; + }, + _ => { + track.bsize = (sample_size / 8) as usize; + }, + }; + if track.tb_den <= 1 { + track.tb_den = sample_rate; } - track.tb_den = sample_rate >> 16; - track.raw_audio = match &fcc { + track.raw_audio = matches!(&fcc, b"NONE" | b"raw " | b"twos" | b"sowt" | b"in24" | b"in32" | b"fl32" | b"fl64" | b"ima4" | b"ms\x00\x02" | b"ms\x00\x21" | b"alaw" | b"ulaw" | - b"MAC3" | b"MAC6" => true, - _ => false, - }; - let ahdr = NAAudioInfo::new(sample_rate >> 16, nchannels as u8, soniton, block_align); + b"MAC3" | b"MAC6"); + let ahdr = NAAudioInfo::new(sample_rate, nchannels as u8, soniton, block_align); let edata = parse_audio_edata(br, start_pos, size)?; codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata); track.channels = nchannels as usize; @@ -762,7 +801,7 @@ fn read_stts(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult validate!(tb_num != 0); track.rescale(tb_num); } else { - track.time_to_sample.truncate(0); + track.time_to_sample.clear(); track.time_to_sample.reserve(entries); for _ in 0..entries { let count = br.read_u32be()?; @@ -979,6 +1018,9 @@ fn read_trun(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult track.ctts_map.reserve(sample_count); } + if track.chunk_offsets.len() < (std::u32::MAX as usize) { + track.keyframes.push((track.chunk_offsets.len() + 1) as u32); + } for _ in 0..sample_count { if sample_duration_present { let _duration = br.read_u32be()?; @@ -1019,6 +1061,8 @@ struct MOVDemuxer<'a> { moof_off: u64, print_chunks: bool, + + macbinary: bool, } struct Track { @@ -1053,6 +1097,7 @@ struct Track { stream: Option, cur_chunk: usize, cur_sample: usize, + cur_ts: Option, samples_left: usize, last_offset: u64, pal: Option>, @@ -1077,7 +1122,7 @@ impl TimeSearcher { fn reset(&mut self) { *self = Self::default(); } - fn map_time(&mut self, sample: u32, tts: &Vec<(u32, u32)>) -> u64 { + fn map_time(&mut self, sample: u32, tts: &[(u32, u32)]) -> u64 { if tts.is_empty() { u64::from(sample) } else if sample >= self.sbase { @@ -1115,7 +1160,7 @@ struct RLESearcher { impl RLESearcher { fn new() -> Self { Self::default() } fn resize(&mut self, size: usize) { - self.array.truncate(0); + self.array.clear(); self.array.reserve(size); } fn reserve(&mut self, size: usize) { @@ -1195,6 +1240,7 @@ impl Track { depth: 0, cur_chunk: 0, cur_sample: 0, + cur_ts: None, samples_left: 0, last_offset: 0, pal: None, @@ -1231,7 +1277,7 @@ impl Track { for kf_time in self.keyframes.iter() { let pts = tsearch.map_time(*kf_time - 1, &self.time_to_sample); let time = NATimeInfo::ts_to_time(pts, 1000, self.tb_num, self.tb_den); - seek_index.add_entry(self.track_no as u32, SeekEntry { time, pts: u64::from(*kf_time - 1), pos: 0 }); + seek_index.add_entry(self.track_no, SeekEntry { time, pts: u64::from(*kf_time - 1), pos: 0 }); } } fn calculate_chunk_size(&self, nsamp: usize) -> usize { @@ -1280,7 +1326,7 @@ impl Track { Some(dts) } } else { - None + Some(pts_val) }; let mut pts = NATimeInfo::new(Some(pts_val), dts, None, self.tb_num, self.tb_den); if self.chunk_offsets.len() == self.chunk_sizes.len() { // simple one-to-one mapping @@ -1363,9 +1409,12 @@ impl Track { self.bsize } } - fn seek(&mut self, pts: u64, tpoint: NATimePoint) -> DemuxerResult<()> { + #[allow(clippy::collapsible_if)] + #[allow(clippy::collapsible_else_if)] + fn seek(&mut self, pts: u64, tpoint: NATimePoint) -> DemuxerResult { self.cur_sample = pts as usize; self.samples_left = 0; + self.cur_ts = None; if self.stream_type == StreamType::Audio { if let NATimePoint::Milliseconds(ms) = tpoint { let exp_pts = NATimeInfo::time_to_ts(ms, 1000, self.tb_num, self.tb_den); @@ -1435,6 +1484,25 @@ impl Track { } else if self.chunk_offsets.len() == self.chunk_sizes.len() { self.cur_chunk = self.cur_sample; } else { + if !self.time_to_sample.is_empty() { + let mut remaining = exp_pts; + let mut abs_csamp = 0; + for &(count, scount) in self.time_to_sample.iter() { + let count = u64::from(count); + let scount = u64::from(scount); + let nblk = remaining / scount; + if nblk < count { + abs_csamp += nblk; + break; + } + remaining -= count * scount; + abs_csamp += count; + } + self.cur_sample = abs_csamp as usize; + } else { + self.cur_sample = exp_pts as usize; + } + let tgt_sample = self.cur_sample; let mut csamp = 0; self.cur_chunk = 0; let mut cmap = self.sample_map.iter(); @@ -1452,6 +1520,9 @@ impl Track { csamp += cur_samps; if csamp > self.cur_sample { if self.cur_chunk >= self.chunk_offsets.len() { + self.cur_sample = csamp - cur_samps; + self.samples_left = 0; + self.cur_sample = csamp; return Err(DemuxerError::SeekError); } self.last_offset = self.chunk_offsets[self.cur_chunk]; @@ -1463,6 +1534,15 @@ impl Track { self.samples_left = cur_samps; self.last_offset = self.chunk_offsets[self.cur_chunk]; self.cur_chunk += 1; + + // try to refine sample position + if self.chunk_sizes.len() > self.chunk_offsets.len() { + for i in self.cur_sample..tgt_sample { + self.cur_sample += 1; + self.samples_left -= 1; + self.last_offset += u64::from(self.chunk_sizes[i]); + } + } } } else { self.cur_chunk = self.cur_sample; @@ -1499,23 +1579,101 @@ impl Track { self.samples_left = csamp + cur_samps - self.cur_sample; self.cur_chunk += 1; } - Ok(()) + let cur_pts = self.timesearch.map_time(self.cur_sample as u32, &self.time_to_sample); + let cur_time = NATimeInfo::ts_to_time(cur_pts, 1000, self.tb_num, self.tb_den); + Ok(cur_time) } } +fn process_packet(src: &mut ByteReader, strmgr: &StreamManager, track: &mut Track, pts: NATimeInfo, offset: u64, size: usize, first: bool) -> DemuxerResult { + if let Some(cpts) = pts.get_pts() { + let ts = NATimeInfo::ts_to_time(cpts, 1000, pts.tb_num, pts.tb_den); + track.cur_ts = Some(ts); + } else { + track.cur_ts = None; + } + let stream = strmgr.get_stream(track.track_str_id); + if stream.is_none() { return Err(DemuxerError::InvalidData); } + let stream = stream.unwrap(); + src.seek(SeekFrom::Start(offset))?; + let mut pkt = src.read_packet(stream, pts, false, size)?; + if let Some(ref pal) = track.pal { + let side_data = NASideData::Palette(first, pal.clone()); + pkt.add_side_data(side_data); + } + Ok(pkt) +} + impl<'a> DemuxCore<'a> for MOVDemuxer<'a> { fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> { - self.read_root(strmgr)?; + if !self.macbinary { + self.read_root(strmgr)?; + } else { + let ver = self.src.read_byte()?; + validate!(ver == 0); + self.src.read_skip(64)?; + let tag = self.src.read_tag()?; + validate!(&tag == b"MooV"); + self.src.read_skip(14)?; + let data_length = self.src.read_u32be()?; + validate!(data_length > 8); + let rsrc_length = self.src.read_u32be()?; + validate!(rsrc_length > 0); + self.src.read_skip(31)?; + let ver = self.src.read_byte()?; + validate!(ver == 0x81); + let ver = self.src.read_byte()?; + validate!(ver == 0x81); + //xxx: maybe check header CRC + + let rsrc_start = 0x80 + ((data_length + 0x7F) & !0x7F); + self.src.seek(SeekFrom::Start(rsrc_start.into()))?; + let rsrc_off = self.src.read_u32be()?; + let rsrc_map_off = self.src.read_u32be()?; + let rsrc_size = self.src.read_u32be()?; + let _rsrc_map_size = self.src.read_u32be()?; + validate!(rsrc_off >= 0x10); + validate!(rsrc_map_off >= rsrc_off + rsrc_size); + self.src.seek(SeekFrom::Current(i64::from(rsrc_off - 16)))?; + // I'm too lazy to parse resource map, so let's just iterate over resources for movie header + let end_pos = u64::from(rsrc_start + rsrc_off + rsrc_size); + let mut peek_buf = [0u8; 8]; + while self.src.tell() < end_pos { + let cur_size = self.src.read_u32be()?; + validate!(self.src.tell() + u64::from(cur_size) <= end_pos); + if cur_size > 8 { + let rsize = self.src.peek_u32be()?; + if rsize == cur_size { + self.src.peek_buf(&mut peek_buf)?; + if &peek_buf[4..] == b"moov" { + self.src.read_skip(8)?; + self.read_moov(strmgr, rsize.into())?; + self.mdat_pos = 8; + break; + } + } + } + self.src.read_skip(cur_size as usize)?; + } + } validate!(self.mdat_pos > 0); validate!(!self.tracks.is_empty()); for track in self.tracks.iter_mut() { - let mut str = None; - std::mem::swap(&mut track.stream, &mut str); - if let Some(stream) = str { + let mut strm = None; + std::mem::swap(&mut track.stream, &mut strm); + if let Some(stream) = strm { let str_id = strmgr.add_stream(stream).unwrap(); track.track_str_id = str_id; } } + if self.macbinary { + // patch data offsets + for track in self.tracks.iter_mut() { + for offset in track.chunk_offsets.iter_mut() { + *offset += 0x80; + } + } + } for track in self.tracks.iter() { track.fill_seek_index(seek_index); } @@ -1528,6 +1686,30 @@ impl<'a> DemuxCore<'a> for MOVDemuxer<'a> { if self.tracks.is_empty() { return Err(DemuxerError::EOF); } + let mut has_all_time = true; + let mut min_ts = std::u64::MAX; + for trk in self.tracks.iter() { + if let Some(ts) = trk.cur_ts { + min_ts = min_ts.min(ts); + } else { + has_all_time = false; + break; + } + } + if has_all_time { + for (trk_no, track) in self.tracks.iter_mut().enumerate() { + if let Some(ts) = track.cur_ts { + if ts == min_ts { + let first = track.cur_sample == 0; + if let Some((pts, offset, size)) = track.get_next_chunk() { + self.cur_track = trk_no + 1; + return process_packet(self.src, strmgr, track, pts, offset, size, first); + } + } + } + } + } + for _ in 0..self.tracks.len() { if self.cur_track >= self.tracks.len() { self.cur_track = 0; @@ -1536,16 +1718,7 @@ impl<'a> DemuxCore<'a> for MOVDemuxer<'a> { self.cur_track += 1; let first = track.cur_sample == 0; if let Some((pts, offset, size)) = track.get_next_chunk() { - let str = strmgr.get_stream(track.track_str_id); - if str.is_none() { return Err(DemuxerError::InvalidData); } - let stream = str.unwrap(); - self.src.seek(SeekFrom::Start(offset))?; - let mut pkt = self.src.read_packet(stream, pts, false, size)?; - if let Some(ref pal) = track.pal { - let side_data = NASideData::Palette(first, pal.clone()); - pkt.add_side_data(side_data); - } - return Ok(pkt); + return process_packet(self.src, strmgr, track, pts, offset, size, first); } } Err(DemuxerError::EOF) @@ -1557,7 +1730,7 @@ impl<'a> DemuxCore<'a> for MOVDemuxer<'a> { if let NATimePoint::Milliseconds(_) = time { let mut aonly = true; for track in self.tracks.iter() { - if track.stream_type != StreamType::Audio || !track.raw_audio { + if track.stream_type != StreamType::Audio { aonly = false; break; } @@ -1574,14 +1747,36 @@ impl<'a> DemuxCore<'a> for MOVDemuxer<'a> { let seek_info = ret.unwrap(); let tbn = self.tracks[seek_info.str_id as usize].tb_num; let tbd = self.tracks[seek_info.str_id as usize].tb_den; + let mut vpts = None; + let mut apts = None; for track in self.tracks.iter_mut() { let cur_pts = if track.track_id == seek_info.str_id { seek_info.pts } else { seek_info.pts * u64::from(tbn) * u64::from(track.tb_den) / (u64::from(tbd) * u64::from(track.tb_num)) }; - track.seek(cur_pts, time)?; + let actual_time = track.seek(cur_pts, time)?; + match track.stream_type { + StreamType::Video => vpts = Some(actual_time), + StreamType::Audio => apts = Some(actual_time), + _ => {}, + }; + } + /* For audio+video stream case when the post-seek actual times differ + by more than half a second try to seek audio to a closer position + to video. + */ + if let (true, Some(vtime), Some(atime)) = (self.tracks.len() == 2, vpts, apts) { + if vtime.max(atime) - vtime.min(atime) > 500 && atime != 0 { + for track in self.tracks.iter_mut() { + if track.stream_type == StreamType::Audio { + let new_pts = NATimeInfo::time_to_ts(vtime, 1000, track.tb_num, track.tb_den); + track.seek(new_pts, NATimePoint::Milliseconds(vtime))?; + } + } + } } + Ok(()) } fn get_duration(&self) -> u64 { @@ -1604,6 +1799,7 @@ const DEMUXER_OPTIONS: &[NAOptionDefinition] = &[ impl<'a> NAOptionHandler for MOVDemuxer<'a> { fn get_supported_options(&self) -> &[NAOptionDefinition] { DEMUXER_OPTIONS } + #[allow(clippy::single_match)] fn set_options(&mut self, options: &[NAOption]) { for option in options.iter() { for opt_def in DEMUXER_OPTIONS.iter() { @@ -1628,6 +1824,12 @@ impl<'a> NAOptionHandler for MOVDemuxer<'a> { impl<'a> MOVDemuxer<'a> { fn new(io: &'a mut ByteReader<'a>) -> Self { + Self::new_common(io, false) + } + fn new_macbinary(io: &'a mut ByteReader<'a>) -> Self { + Self::new_common(io, true) + } + fn new_common(io: &'a mut ByteReader<'a>, macbinary: bool) -> Self { MOVDemuxer { src: io, depth: 0, @@ -1642,12 +1844,14 @@ impl<'a> MOVDemuxer<'a> { moof_off: 0, print_chunks: false, + + macbinary, } } fn read_root(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> { self.depth = 0; while self.src.left() != 0 { - let ret = read_chunk_header(&mut self.src); + let ret = read_chunk_header(self.src); if ret.is_err() { break; } let (ctype, size) = ret.unwrap(); if self.print_chunks { @@ -1659,7 +1863,7 @@ impl<'a> MOVDemuxer<'a> { } let handler = ROOT_CHUNK_HANDLERS.iter().find(|x| x.ctype == ctype); let read_size; - if let Some(ref handler) = handler { + if let Some(handler) = handler { read_size = (handler.parse)(self, strmgr, size)?; } else { println!("skipping unknown chunk {:08X} size {}", ctype, size); @@ -1684,6 +1888,15 @@ impl DemuxerCreator for MOVDemuxerCreator { fn get_name(&self) -> &'static str { "mov" } } +pub struct MacBinaryMOVDemuxerCreator { } + +impl DemuxerCreator for MacBinaryMOVDemuxerCreator { + fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box + 'a> { + Box::new(MOVDemuxer::new_macbinary(br)) + } + fn get_name(&self) -> &'static str { "mov-macbin" } +} + const MOV_DEFAULT_PAL_2BIT: [u8; 4 * 4] = [ 0x93, 0x65, 0x5E, 0x00, 0xFF, 0xFF, 0xFF, 0x00, @@ -1974,6 +2187,7 @@ mod test { #[test] fn test_mov_demux() { + // sample: https://samples.mplayerhq.hu/V-codecs/IV32/cubes.mov let mut file = File::open("assets/Indeo/cubes.mov").unwrap(); let mut fr = FileReader::new_read(&mut file); let mut br = ByteReader::new(&mut fr); @@ -1995,6 +2209,7 @@ mod test { #[test] fn test_dash_demux() { + // sample: a stream downloaded with youtube-dl let mut file = File::open("assets/ITU/dash.m4a").unwrap(); let mut fr = FileReader::new_read(&mut file); let mut br = ByteReader::new(&mut fr); @@ -2013,4 +2228,26 @@ mod test { println!("Got {}", pkt); } } + + #[test] + fn test_macbinary_demux() { + // sample from King's Quest VI Macintosh edition + let mut file = File::open("assets/QT/Halfdome.bin").unwrap(); + let mut fr = FileReader::new_read(&mut file); + let mut br = ByteReader::new(&mut fr); + let mut dmx = MOVDemuxer::new_macbinary(&mut br); + let mut sm = StreamManager::new(); + let mut si = SeekIndex::new(); + dmx.open(&mut sm, &mut si).unwrap(); + + loop { + let pktres = dmx.get_frame(&mut sm); + if let Err(e) = pktres { + if e == DemuxerError::EOF { break; } + panic!("error"); + } + let pkt = pktres.unwrap(); + println!("Got {}", pkt); + } + } }