X-Git-Url: https://git.nihav.org/?p=nihav.git;a=blobdiff_plain;f=nihav-commonfmt%2Fsrc%2Fdemuxers%2Fmov.rs;h=90ca6c5eb0726a1a34ce74f9315c252dc00fb550;hp=8e448faae2416783665f29bedb48f4ce6c882a4c;hb=379524159c95f1c3639976ccf35f9d47cd9732ac;hpb=5317ee9cf0160ca62988c898526f3e4018bb6f27 diff --git a/nihav-commonfmt/src/demuxers/mov.rs b/nihav-commonfmt/src/demuxers/mov.rs index 8e448fa..90ca6c5 100644 --- a/nihav-commonfmt/src/demuxers/mov.rs +++ b/nihav-commonfmt/src/demuxers/mov.rs @@ -78,6 +78,8 @@ const ROOT_CHUNK_HANDLERS: &[RootChunkHandler] = &[ RootChunkHandler { ctype: mktag!(b"ftyp"), parse: read_ftyp }, RootChunkHandler { ctype: mktag!(b"mdat"), parse: read_mdat }, RootChunkHandler { ctype: mktag!(b"moov"), parse: read_moov }, + RootChunkHandler { ctype: mktag!(b"moof"), parse: read_moof }, + RootChunkHandler { ctype: mktag!(b"sidx"), parse: read_sidx }, ]; fn print_cname(ctype: u32, size: u64, off: u64, depth: u8) { @@ -187,6 +189,10 @@ fn read_mdat(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> De Ok(size) } +fn read_sidx(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64) -> DemuxerResult { + Ok(0) +} + fn read_moov(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult { dmx.read_moov(strmgr, size)?; Ok(size) @@ -198,6 +204,8 @@ const MOOV_CHUNK_HANDLERS: &[RootChunkHandler] = &[ RootChunkHandler { ctype: mktag!(b"ctab"), parse: read_ctab }, 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 { @@ -280,6 +288,14 @@ fn read_meta(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> De Ok(size) } +fn read_mvex(_dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, _size: u64) -> DemuxerResult { + 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; @@ -287,16 +303,55 @@ fn read_trak(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> Dem validate!(track.tkhd_found && track.stsd_found); validate!(strmgr.get_stream_by_id(track.track_id).is_none()); dmx.cur_track += 1; - let mut str = None; - std::mem::swap(&mut track.stream, &mut str); - if let Some(stream) = str { - let str_id = strmgr.add_stream(stream).unwrap(); - track.track_str_id = str_id; - } dmx.tracks.push(track); Ok(size) } +fn read_moof(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult { + dmx.moof_off = dmx.src.tell() - 8; + dmx.read_moof(strmgr, size)?; + Ok(size) +} + +const MOOF_CHUNK_HANDLERS: &[RootChunkHandler] = &[ + RootChunkHandler { ctype: mktag!(b"mfhd"), parse: read_mfhd }, + RootChunkHandler { ctype: mktag!(b"traf"), parse: read_traf }, + RootChunkHandler { ctype: mktag!(b"meta"), parse: read_meta }, +]; + +fn read_mfhd(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult { + const KNOWN_MFHD_SIZE: u64 = 8; + validate!(size >= KNOWN_MFHD_SIZE); + let version = dmx.src.read_byte()?; + validate!(version == 0); + let flags = dmx.src.read_u24be()?; + validate!(flags == 0); + let _seq_no = dmx.src.read_u32be()?; + + Ok(KNOWN_MFHD_SIZE) +} + +fn read_traf(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult { + let mut buf = [0u8; 16]; + dmx.src.peek_buf(&mut buf)?; + validate!(&buf[4..8] == b"tfhd"); + let track_id = read_u32be(&buf[12..16])?; + let mut track = None; + for trk in dmx.tracks.iter_mut() { + if trk.track_id == track_id { + track = Some(trk); + break; + } + } + if let Some(track) = track { + track.moof_off = dmx.moof_off; + track.read_traf(&mut dmx.src, size)?; + Ok(size) + } else { + Ok(0) + } +} + const TRAK_CHUNK_HANDLERS: &[TrackChunkHandler] = &[ TrackChunkHandler { ctype: mktag!(b"clip"), parse: skip_chunk }, TrackChunkHandler { ctype: mktag!(b"matt"), parse: skip_chunk }, @@ -634,15 +689,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]))) { @@ -655,18 +714,38 @@ 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; - } - track.tb_den = sample_rate >> 16; + 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; + }, + }; + track.tb_den = sample_rate; track.raw_audio = match &fcc { b"NONE" | b"raw " | b"twos" | b"sowt" | b"in24" | b"in32" | b"fl32" | b"fl64" | @@ -675,7 +754,7 @@ fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult b"MAC3" | b"MAC6" => true, _ => false, }; - let ahdr = NAAudioInfo::new(sample_rate >> 16, nchannels as u8, soniton, block_align); + 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; @@ -710,19 +789,9 @@ fn read_stts(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult let _count = br.read_u32be()?; let tb_num = br.read_u32be()?; validate!(tb_num != 0); - track.tb_div = tb_num; - if let Some(ref mut stream) = track.stream { - let tb_den = stream.tb_den; - let (tb_num, tb_den) = reduce_timebase(tb_num * stream.tb_num, tb_den); - stream.duration /= u64::from(track.tb_div); - stream.tb_num = tb_num; - stream.tb_den = tb_den; - track.tb_num = tb_num; - track.tb_den = tb_den; - track.duration /= track.tb_div; - } + 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()?; @@ -836,6 +905,138 @@ fn read_ctts(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult Ok(size) } +const TRAF_CHUNK_HANDLERS: &[TrackChunkHandler] = &[ + TrackChunkHandler { ctype: mktag!(b"tfhd"), parse: read_tfhd }, + TrackChunkHandler { ctype: mktag!(b"trun"), parse: read_trun }, + TrackChunkHandler { ctype: mktag!(b"sbgp"), parse: skip_chunk }, + TrackChunkHandler { ctype: mktag!(b"sgpd"), parse: skip_chunk }, + TrackChunkHandler { ctype: mktag!(b"subs"), parse: skip_chunk }, + TrackChunkHandler { ctype: mktag!(b"saiz"), parse: skip_chunk }, + TrackChunkHandler { ctype: mktag!(b"saio"), parse: skip_chunk }, + TrackChunkHandler { ctype: mktag!(b"tfdt"), parse: skip_chunk }, + TrackChunkHandler { ctype: mktag!(b"meta"), parse: skip_chunk }, +]; + +fn read_tfhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult { + validate!(size >= 8); + let start = br.tell(); + let _version = br.read_byte()?; + let flags = br.read_u24be()?; + let _track_id = br.read_u32be()?; + if (flags & 0x000001) != 0 { + let base_offset = br.read_u64be()?; + track.moof_off = base_offset; + } + if (flags & 0x000002) != 0 { + let _sample_description_index = br.read_u32be()?; + } + if (flags & 0x000008) != 0 { + let default_sample_duration = br.read_u32be()?; + if track.tb_div == 1 { + track.rescale(default_sample_duration); + } + } + if (flags & 0x000010) != 0 { + let _default_sample_size = br.read_u32be()?; + } + if (flags & 0x000020) != 0 { + let _default_sample_flags = br.read_u32be()?; + } + if (flags & 0x010000) != 0 { + } + /*if (flags & 0x020000) != 0 { // base offset is moof start + }*/ + Ok(br.tell() - start) +} + +fn read_trun(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult { + validate!(size >= 8); + let version = br.read_byte()?; + let flags = br.read_u24be()?; + let data_off_present = (flags & 0x000001) != 0; + let first_sample_flags = (flags & 0x000004) != 0; + let sample_duration_present = (flags & 0x000100) != 0; + let sample_size_present = (flags & 0x000200) != 0; + let sample_flags_present = (flags & 0x000400) != 0; + let sample_ct_off_present = (flags & 0x000800) != 0; + + let sample_count = br.read_u32be()? as usize; + + let mut hdr_size = 8; + let mut arr_size = 0; + if data_off_present { + hdr_size += 4; + } + if first_sample_flags { + hdr_size += 4; + } + if sample_duration_present { + arr_size += 4; + } + if sample_size_present { + arr_size += 4; + } + if sample_flags_present { + arr_size += 4; + } + if sample_ct_off_present { + arr_size += 4; + } + validate!(size == hdr_size + arr_size * (sample_count as u64)); + + let mut data_off = if data_off_present { + let off = br.read_u32be()? as i32; + let new_off = (track.moof_off as i64) + i64::from(off); + validate!(new_off > 0); + new_off as u64 + } else { + track.moof_off + }; + if first_sample_flags { + let _flags = br.read_u32be()?; + } + + if sample_size_present { + track.chunk_sizes.reserve(sample_count); + track.chunk_offsets.reserve(sample_count); + } + + if sample_ct_off_present { + if track.ctts_version != version { + track.ctts_version = version; + } + 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()?; + } + if sample_size_present { + let ssize = br.read_u32be()?; + track.chunk_sizes.push(ssize); + track.chunk_offsets.push(data_off); + data_off += u64::from(ssize); + } + if sample_flags_present { + let _flags = br.read_u32be()?; + } + if sample_ct_off_present { + let samp_offset = br.read_u32be()?; + if version == 0 { + track.ctts_map.add(1, samp_offset / track.tb_div); + } else { + track.ctts_map.add(1, ((samp_offset as i32) / (track.tb_div as i32)) as u32); + } + } + } + + Ok(size) +} + struct MOVDemuxer<'a> { src: &'a mut ByteReader<'a>, depth: usize, @@ -847,6 +1048,8 @@ struct MOVDemuxer<'a> { duration: u32, pal: Option>, + moof_off: u64, + print_chunks: bool, } @@ -882,11 +1085,14 @@ struct Track { stream: Option, cur_chunk: usize, cur_sample: usize, + cur_ts: Option, samples_left: usize, last_offset: u64, pal: Option>, timesearch: TimeSearcher, + moof_off: u64, + print_chunks: bool, } @@ -904,7 +1110,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 { @@ -942,7 +1148,10 @@ 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) { self.array.reserve(size); } fn add(&mut self, len: u32, val: T) { @@ -1019,11 +1228,14 @@ impl Track { depth: 0, cur_chunk: 0, cur_sample: 0, + cur_ts: None, samples_left: 0, last_offset: 0, pal: None, timesearch: TimeSearcher::new(), + moof_off: 0, + print_chunks: false, } } @@ -1031,6 +1243,20 @@ impl Track { read_chunk_list!(track; "mdia", read_mdia, MDIA_CHUNK_HANDLERS); read_chunk_list!(track; "minf", read_minf, MINF_CHUNK_HANDLERS); read_chunk_list!(track; "stbl", read_stbl, STBL_CHUNK_HANDLERS); + read_chunk_list!(track; "traf", read_traf, TRAF_CHUNK_HANDLERS); + fn rescale(&mut self, tb_num: u32) { + self.tb_div = tb_num; + if let Some(ref mut stream) = self.stream { + let tb_den = stream.tb_den; + let (tb_num, tb_den) = reduce_timebase(tb_num * stream.tb_num, tb_den); + stream.duration /= u64::from(self.tb_div); + stream.tb_num = tb_num; + stream.tb_den = tb_den; + self.tb_num = tb_num; + self.tb_den = tb_den; + self.duration /= self.tb_div; + } + } fn fill_seek_index(&self, seek_index: &mut SeekIndex) { if !self.keyframes.is_empty() { seek_index.mode = SeekIndexMode::Present; @@ -1171,9 +1397,11 @@ impl Track { self.bsize } } + #[allow(clippy::collapsible_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); @@ -1311,11 +1539,38 @@ impl Track { } } +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 str = strmgr.get_stream(track.track_str_id); + if str.is_none() { return Err(DemuxerError::InvalidData); } + let stream = str.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)?; 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 str_id = strmgr.add_stream(stream).unwrap(); + track.track_str_id = str_id; + } + } for track in self.tracks.iter() { track.fill_seek_index(seek_index); } @@ -1328,6 +1583,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(&mut 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; @@ -1336,16 +1615,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(&mut self.src, strmgr, track, pts, offset, size, first); } } Err(DemuxerError::EOF) @@ -1404,6 +1674,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() { @@ -1439,6 +1710,8 @@ impl<'a> MOVDemuxer<'a> { duration: 0, pal: None, + moof_off: 0, + print_chunks: false, } } @@ -1448,6 +1721,9 @@ impl<'a> MOVDemuxer<'a> { let ret = read_chunk_header(&mut self.src); if ret.is_err() { break; } let (ctype, size) = ret.unwrap(); + if self.print_chunks { + print_cname(ctype, size, self.src.tell(), 0); + } if IGNORED_CHUNKS.contains(&ctype) { self.src.skip64(size)?; continue; @@ -1467,6 +1743,7 @@ impl<'a> MOVDemuxer<'a> { Ok(()) } read_chunk_list!(root; "moov", read_moov, MOOV_CHUNK_HANDLERS); + read_chunk_list!(root; "moof", read_moof, MOOF_CHUNK_HANDLERS); } pub struct MOVDemuxerCreator { } @@ -1786,4 +2063,25 @@ mod test { println!("Got {}", pkt); } } + + #[test] + fn test_dash_demux() { + 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); + let mut dmx = MOVDemuxer::new(&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); + } + } }