X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-commonfmt%2Fsrc%2Fdemuxers%2Fmov.rs;h=87eb2f17a9ff366b9082a683480f08aecf8c3bcf;hb=e6aaad5c5273cd814b5748b7faf3751835a37217;hp=99a376243dfceb94141868731df031bde701c0ec;hpb=6bb2692727d9617c7f349c037761f8e83198f840;p=nihav.git diff --git a/nihav-commonfmt/src/demuxers/mov.rs b/nihav-commonfmt/src/demuxers/mov.rs index 99a3762..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 { @@ -278,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) } @@ -299,7 +305,7 @@ fn skip_chunk_mov(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64 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; @@ -345,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) @@ -567,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); @@ -606,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 => { @@ -689,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]))) { @@ -710,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; @@ -767,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()?; @@ -1027,6 +1061,8 @@ struct MOVDemuxer<'a> { moof_off: u64, print_chunks: bool, + + macbinary: bool, } struct Track { @@ -1124,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) { @@ -1241,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 { @@ -1290,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 @@ -1374,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; @@ -1447,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(); @@ -1464,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]; @@ -1475,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; @@ -1511,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) } } @@ -1522,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 { @@ -1536,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); } @@ -1576,7 +1703,7 @@ impl<'a> DemuxCore<'a> for MOVDemuxer<'a> { 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(&mut self.src, strmgr, track, pts, offset, size, first); + return process_packet(self.src, strmgr, track, pts, offset, size, first); } } } @@ -1591,7 +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() { - return process_packet(&mut self.src, strmgr, track, pts, offset, size, first); + return process_packet(self.src, strmgr, track, pts, offset, size, first); } } Err(DemuxerError::EOF) @@ -1603,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; } @@ -1620,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 { @@ -1675,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, @@ -1689,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 { @@ -1706,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); @@ -1731,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, @@ -2021,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); @@ -2042,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); @@ -2060,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); + } + } }