X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-core%2Fsrc%2Fdemuxers%2Fmod.rs;h=46e06175e10924698da87cc5ac28f3b2cff321d4;hb=1ebf572dc8cdbf6e1440d90295b3e69eb76339df;hp=a0f67a84c7d984fad014ece751dbc6b8c1763b06;hpb=787b8d03074419d7f8e6b52daba02a3807444bc2;p=nihav.git diff --git a/nihav-core/src/demuxers/mod.rs b/nihav-core/src/demuxers/mod.rs index a0f67a8..46e0617 100644 --- a/nihav-core/src/demuxers/mod.rs +++ b/nihav-core/src/demuxers/mod.rs @@ -37,7 +37,9 @@ pub trait DemuxCore<'a>: NAOptionHandler { /// Demuxes a packet. fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult; /// Seeks to the requested time. - fn seek(&mut self, time: u64, seek_idx: &SeekIndex) -> DemuxerResult<()>; + fn seek(&mut self, time: NATimePoint, seek_idx: &SeekIndex) -> DemuxerResult<()>; + /// Returns container duration in milliseconds (zero if not available). + fn get_duration(&self) -> u64; } /// An auxiliary trait to make bytestream reader read packet data. @@ -88,12 +90,19 @@ impl StreamManager { /// Adds a new stream. pub fn add_stream(&mut self, stream: NAStream) -> Option { let stream_num = self.streams.len(); - let mut str = stream.clone(); + let mut str = stream; str.set_num(stream_num); self.streams.push(str.into_ref()); self.ignored.push(false); Some(stream_num) } + /// Adds a new stream from reference-counted object. + pub fn add_stream_ref(&mut self, stream: NAStreamRef) -> Option { + let stream_num = self.streams.len(); + self.streams.push(stream); + self.ignored.push(false); + Some(stream_num) + } /// Returns stream with the requested index. pub fn get_stream(&self, idx: usize) -> Option { if idx < self.streams.len() { @@ -222,16 +231,31 @@ impl StreamSeekInfo { self.entries.push(entry); } /// Searches for an appropriate seek position before requested time. - pub fn find_pos(&self, time: u64) -> Option { + pub fn find_pos(&self, time: NATimePoint) -> Option { + if time == NATimePoint::None { + return None; + } if !self.entries.is_empty() { // todo something faster like binary search let mut cand = None; for entry in self.entries.iter() { - if entry.time <= time { - cand = Some(*entry); - } else { - break; - } + match time { + NATimePoint::Milliseconds(ms) => { + if entry.time <= ms { + cand = Some(*entry); + } else { + break; + } + }, + NATimePoint::PTS(pts) => { + if entry.pts <= pts { + cand = Some(*entry); + } else { + break; + } + }, + NATimePoint::None => unreachable!(), + }; } cand } else { @@ -267,11 +291,11 @@ impl SeekIndex { pub fn new() -> Self { Self::default() } pub fn add_stream(&mut self, id: u32) -> usize { let ret = self.stream_id_to_index(id); - if ret.is_none() { + if let Some(res) = ret { + res + } else { self.seek_info.push(StreamSeekInfo::new(id)); self.seek_info.len() - 1 - } else { - ret.unwrap() } } /// Adds a new stream to the index. @@ -302,7 +326,7 @@ impl SeekIndex { self.seek_info[idx.unwrap()].filled = true; } /// Searches for a seek position before requested time. - pub fn find_pos(&self, time: u64) -> Option { + pub fn find_pos(&self, time: NATimePoint) -> Option { let mut cand = None; for str in self.seek_info.iter() { if !str.filled { continue; } @@ -382,8 +406,8 @@ impl<'a> Demuxer<'a> { } } } - /// Seeks to the requested time (in milliseconds) if possible. - pub fn seek(&mut self, time: u64) -> DemuxerResult<()> { + /// Seeks to the requested time if possible. + pub fn seek(&mut self, time: NATimePoint) -> DemuxerResult<()> { if self.seek_idx.skip_index { return Err(DemuxerError::NotPossible); } @@ -393,6 +417,25 @@ impl<'a> Demuxer<'a> { pub fn get_seek_index(&self) -> &SeekIndex { &self.seek_idx } + /// Returns media duration reported by container or its streams. + /// + /// Duration is in milliseconds and set to zero when it is not available. + pub fn get_duration(&self) -> u64 { + let duration = self.dmx.get_duration(); + if duration != 0 { + return duration; + } + let mut duration = 0; + for stream in self.streams.iter() { + if stream.duration > 0 { + let dur = NATimeInfo::ts_to_time(stream.duration, 1000, stream.tb_num, stream.tb_den); + if duration < dur { + duration = dur; + } + } + } + duration + } } impl<'a> NAOptionHandler for Demuxer<'a> { @@ -420,7 +463,7 @@ pub trait DemuxerCreator { } /// Creates demuxer for a provided bytestream. -pub fn create_demuxer<'a>(dmxcr: &DemuxerCreator, br: &'a mut ByteReader<'a>) -> DemuxerResult> { +pub fn create_demuxer<'a>(dmxcr: &dyn DemuxerCreator, br: &'a mut ByteReader<'a>) -> DemuxerResult> { let mut dmx = dmxcr.new_demuxer(br); let mut str = StreamManager::new(); let mut seek_idx = SeekIndex::new(); @@ -431,7 +474,7 @@ pub fn create_demuxer<'a>(dmxcr: &DemuxerCreator, br: &'a mut ByteReader<'a>) -> /// List of registered demuxers. #[derive(Default)] pub struct RegisteredDemuxers { - dmxs: Vec<&'static DemuxerCreator>, + dmxs: Vec<&'static dyn DemuxerCreator>, } impl RegisteredDemuxers { @@ -440,11 +483,177 @@ impl RegisteredDemuxers { Self { dmxs: Vec::new() } } /// Registers a new demuxer. - pub fn add_demuxer(&mut self, dmx: &'static DemuxerCreator) { + pub fn add_demuxer(&mut self, dmx: &'static dyn DemuxerCreator) { + self.dmxs.push(dmx); + } + /// Searches for a demuxer that supports requested container format. + pub fn find_demuxer(&self, name: &str) -> Option<&dyn DemuxerCreator> { + for &dmx in self.dmxs.iter() { + if dmx.get_name() == name { + return Some(dmx); + } + } + None + } + /// Provides an iterator over currently registered demuxers. + pub fn iter(&self) -> std::slice::Iter<&dyn DemuxerCreator> { + self.dmxs.iter() + } +} + +/// A trait for raw data demuxing operations. +pub trait RawDemuxCore<'a>: NAOptionHandler { + /// Opens the input stream, reads required headers and prepares everything for packet demuxing. + fn open(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()>; + /// Reads a piece of raw data. + fn get_data(&mut self, strmgr: &mut StreamManager) -> DemuxerResult; + /// Seeks to the requested time. + fn seek(&mut self, time: NATimePoint, seek_idx: &SeekIndex) -> DemuxerResult<()>; + /// Returns container duration in milliseconds (zero if not available). + fn get_duration(&self) -> u64; +} + +/// Demuxer structure with auxiliary data. +pub struct RawDemuxer<'a> { + dmx: Box + 'a>, + streams: StreamManager, + seek_idx: SeekIndex, +} + +impl<'a> RawDemuxer<'a> { + /// Constructs a new `Demuxer` instance. + fn new(dmx: Box + 'a>, strmgr: StreamManager, seek_idx: SeekIndex) -> Self { + Self { + dmx, + streams: strmgr, + seek_idx, + } + } + /// Returns a stream reference by its number. + pub fn get_stream(&self, idx: usize) -> Option { + self.streams.get_stream(idx) + } + /// Returns a stream reference by its ID. + pub fn get_stream_by_id(&self, id: u32) -> Option { + self.streams.get_stream_by_id(id) + } + /// Reports the total number of streams. + pub fn get_num_streams(&self) -> usize { + self.streams.get_num_streams() + } + /// Returns a reference to the internal stream manager. + pub fn get_stream_manager(&self) -> &StreamManager { + &self.streams + } + /// Returns an iterator over streams. + pub fn get_streams(&self) -> StreamIter { + self.streams.iter() + } + /// Returns 'ignored' marker for requested stream. + pub fn is_ignored_stream(&self, idx: usize) -> bool { + self.streams.is_ignored(idx) + } + /// Sets 'ignored' marker for requested stream. + pub fn set_ignored_stream(&mut self, idx: usize) { + self.streams.set_ignored(idx) + } + /// Clears 'ignored' marker for requested stream. + pub fn set_unignored_stream(&mut self, idx: usize) { + self.streams.set_unignored(idx) + } + + /// Demuxes a new piece of data from the container. + pub fn get_data(&mut self) -> DemuxerResult { + loop { + let res = self.dmx.get_data(&mut self.streams); + if self.streams.no_ign || res.is_err() { return res; } + let res = res.unwrap(); + let idx = res.get_stream().get_num(); + if !self.is_ignored_stream(idx) { + return Ok(res); + } + } + } + /// Seeks to the requested time if possible. + pub fn seek(&mut self, time: NATimePoint) -> DemuxerResult<()> { + if self.seek_idx.skip_index { + return Err(DemuxerError::NotPossible); + } + self.dmx.seek(time, &self.seek_idx) + } + /// Returns internal seek index. + pub fn get_seek_index(&self) -> &SeekIndex { + &self.seek_idx + } + /// Returns media duration reported by container or its streams. + /// + /// Duration is in milliseconds and set to zero when it is not available. + pub fn get_duration(&self) -> u64 { + let duration = self.dmx.get_duration(); + if duration != 0 { + return duration; + } + let mut duration = 0; + for stream in self.streams.iter() { + if stream.duration > 0 { + let dur = NATimeInfo::ts_to_time(stream.duration, 1000, stream.tb_num, stream.tb_den); + if duration < dur { + duration = dur; + } + } + } + duration + } +} + +impl<'a> NAOptionHandler for RawDemuxer<'a> { + fn get_supported_options(&self) -> &[NAOptionDefinition] { + self.dmx.get_supported_options() + } + fn set_options(&mut self, options: &[NAOption]) { + self.dmx.set_options(options); + } + fn query_option_value(&self, name: &str) -> Option { + self.dmx.query_option_value(name) + } +} + +/// The trait for creating raw data demuxers. +pub trait RawDemuxerCreator { + /// Creates new raw demuxer instance that will use `ByteReader` source as an input. + fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box + 'a>; + /// Tries to check whether the input can be demuxed with the demuxer. + fn check_format(&self, br: &mut ByteReader) -> bool; + /// Returns the name of current raw data demuxer creator (equal to the container name it can demux). + fn get_name(&self) -> &'static str; +} + +/// Creates raw data demuxer for a provided bytestream. +pub fn create_raw_demuxer<'a>(dmxcr: &dyn RawDemuxerCreator, br: &'a mut ByteReader<'a>) -> DemuxerResult> { + let mut dmx = dmxcr.new_demuxer(br); + let mut str = StreamManager::new(); + let mut seek_idx = SeekIndex::new(); + dmx.open(&mut str, &mut seek_idx)?; + Ok(RawDemuxer::new(dmx, str, seek_idx)) +} + +/// List of registered demuxers. +#[derive(Default)] +pub struct RegisteredRawDemuxers { + dmxs: Vec<&'static dyn RawDemuxerCreator>, +} + +impl RegisteredRawDemuxers { + /// Constructs a new `RegisteredDemuxers` instance. + pub fn new() -> Self { + Self { dmxs: Vec::new() } + } + /// Registers a new demuxer. + pub fn add_demuxer(&mut self, dmx: &'static dyn RawDemuxerCreator) { self.dmxs.push(dmx); } /// Searches for a demuxer that supports requested container format. - pub fn find_demuxer(&self, name: &str) -> Option<&DemuxerCreator> { + pub fn find_demuxer(&self, name: &str) -> Option<&dyn RawDemuxerCreator> { for &dmx in self.dmxs.iter() { if dmx.get_name() == name { return Some(dmx); @@ -452,4 +661,8 @@ impl RegisteredDemuxers { } None } + /// Provides an iterator over currently registered demuxers. + pub fn iter(&self) -> std::slice::Iter<&dyn RawDemuxerCreator> { + self.dmxs.iter() + } }