X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-commonfmt%2Fsrc%2Fdemuxers%2Fmov.rs;h=87eb2f17a9ff366b9082a683480f08aecf8c3bcf;hb=e6aaad5c5273cd814b5748b7faf3751835a37217;hp=ce2b0bfc665509402f9db5629d03d2ccd0e8597c;hpb=6f2630992fe340ad1a122ec10c649f756e478185;p=nihav.git diff --git a/nihav-commonfmt/src/demuxers/mov.rs b/nihav-commonfmt/src/demuxers/mov.rs index ce2b0bf..87eb2f1 100644 --- a/nihav-commonfmt/src/demuxers/mov.rs +++ b/nihav-commonfmt/src/demuxers/mov.rs @@ -573,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); @@ -612,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 => { @@ -751,7 +755,9 @@ fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult track.bsize = (sample_size / 8) as usize; }, }; - track.tb_den = sample_rate; + if track.tb_den <= 1 { + track.tb_den = sample_rate; + } track.raw_audio = matches!(&fcc, b"NONE" | b"raw " | b"twos" | b"sowt" | b"in24" | b"in32" | b"fl32" | b"fl64" | @@ -1055,6 +1061,8 @@ struct MOVDemuxer<'a> { moof_off: u64, print_chunks: bool, + + macbinary: bool, } struct Track { @@ -1269,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 { @@ -1318,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 @@ -1402,7 +1410,8 @@ impl Track { } } #[allow(clippy::collapsible_if)] - fn seek(&mut self, pts: u64, tpoint: NATimePoint) -> DemuxerResult<()> { + #[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; @@ -1475,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(); @@ -1492,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]; @@ -1503,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; @@ -1539,7 +1579,9 @@ 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) } } @@ -1550,9 +1592,9 @@ fn process_packet(src: &mut ByteReader, strmgr: &StreamManager, track: &mut Trac } else { track.cur_ts = None; } - let str = strmgr.get_stream(track.track_str_id); - if str.is_none() { return Err(DemuxerError::InvalidData); } - let stream = str.unwrap(); + 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 { @@ -1564,17 +1606,74 @@ fn process_packet(src: &mut ByteReader, strmgr: &StreamManager, track: &mut Trac 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); } @@ -1631,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; } @@ -1648,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 { @@ -1703,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, @@ -1717,6 +1844,8 @@ impl<'a> MOVDemuxer<'a> { moof_off: 0, print_chunks: false, + + macbinary, } } fn read_root(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> { @@ -1759,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, @@ -2090,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); + } + } }