/// Demuxes a packet.
fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket>;
/// 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.
/// Adds a new stream.
pub fn add_stream(&mut self, stream: NAStream) -> Option<usize> {
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<usize> {
+ 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<NAStreamRef> {
if idx < self.streams.len() {
self.entries.push(entry);
}
/// Searches for an appropriate seek position before requested time.
- pub fn find_pos(&self, time: u64) -> Option<SeekEntry> {
+ pub fn find_pos(&self, time: NATimePoint) -> Option<SeekEntry> {
+ 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 {
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.
self.seek_info[idx.unwrap()].filled = true;
}
/// Searches for a seek position before requested time.
- pub fn find_pos(&self, time: u64) -> Option<SeekIndexResult> {
+ pub fn find_pos(&self, time: NATimePoint) -> Option<SeekIndexResult> {
let mut cand = None;
for str in self.seek_info.iter() {
if !str.filled { continue; }
}
}
}
- /// 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);
}
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> {
}
/// Creates demuxer for a provided bytestream.
-pub fn create_demuxer<'a>(dmxcr: &DemuxerCreator, br: &'a mut ByteReader<'a>) -> DemuxerResult<Demuxer<'a>> {
+pub fn create_demuxer<'a>(dmxcr: &dyn DemuxerCreator, br: &'a mut ByteReader<'a>) -> DemuxerResult<Demuxer<'a>> {
let mut dmx = dmxcr.new_demuxer(br);
let mut str = StreamManager::new();
let mut seek_idx = SeekIndex::new();
/// List of registered demuxers.
#[derive(Default)]
pub struct RegisteredDemuxers {
- dmxs: Vec<&'static DemuxerCreator>,
+ dmxs: Vec<&'static dyn DemuxerCreator>,
}
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<&DemuxerCreator> {
+ 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()
+ }
}