X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-core%2Fsrc%2Fdemuxers%2Fmod.rs;h=08bf8f7353a9eaff9a5a98ae93eade6193f7ffdf;hb=e6aaad5c5273cd814b5748b7faf3751835a37217;hp=23f27fbfa8d6c47eea22b546effba452a42a7ca5;hpb=817e487223b28379176a533f09485c27a68443f8;p=nihav.git

diff --git a/nihav-core/src/demuxers/mod.rs b/nihav-core/src/demuxers/mod.rs
index 23f27fb..08bf8f7 100644
--- a/nihav-core/src/demuxers/mod.rs
+++ b/nihav-core/src/demuxers/mod.rs
@@ -45,18 +45,18 @@ pub trait DemuxCore<'a>: NAOptionHandler {
 /// An auxiliary trait to make bytestream reader read packet data.
 pub trait NAPacketReader {
     /// Reads input and constructs a packet containing it.
-    fn read_packet(&mut self, str: NAStreamRef, ts: NATimeInfo, keyframe: bool, size: usize) -> DemuxerResult<NAPacket>;
+    fn read_packet(&mut self, strm: NAStreamRef, ts: NATimeInfo, keyframe: bool, size: usize) -> DemuxerResult<NAPacket>;
     /// Reads input into already existing packet.
     fn fill_packet(&mut self, pkt: &mut NAPacket) -> DemuxerResult<()>;
 }
 
 impl<'a> NAPacketReader for ByteReader<'a> {
-    fn read_packet(&mut self, str: NAStreamRef, ts: NATimeInfo, kf: bool, size: usize) -> DemuxerResult<NAPacket> {
+    fn read_packet(&mut self, strm: NAStreamRef, ts: NATimeInfo, kf: bool, size: usize) -> DemuxerResult<NAPacket> {
         let mut buf: Vec<u8> = Vec::with_capacity(size);
         if buf.capacity() < size { return Err(DemuxerError::MemoryError); }
         buf.resize(size, 0);
         self.read_buf(buf.as_mut_slice())?;
-        let pkt = NAPacket::new(str, ts, kf, buf);
+        let pkt = NAPacket::new(strm, ts, kf, buf);
         Ok(pkt)
     }
     fn fill_packet(&mut self, pkt: &mut NAPacket) -> DemuxerResult<()> {
@@ -181,9 +181,10 @@ impl<'a> Iterator for StreamIter<'a> {
 }
 
 /// Seeking modes.
-#[derive(Clone,Copy,PartialEq)]
+#[derive(Clone,Copy,PartialEq,Default)]
 pub enum SeekIndexMode {
     /// No seeking index present.
+    #[default]
     None,
     /// Seeking index is present.
     Present,
@@ -191,10 +192,6 @@ pub enum SeekIndexMode {
     Automatic,
 }
 
-impl Default for SeekIndexMode {
-    fn default() -> Self { SeekIndexMode::None }
-}
-
 /// A structure holding seeking information.
 #[derive(Clone,Copy,Default)]
 pub struct SeekEntry {
@@ -300,8 +297,8 @@ impl SeekIndex {
     }
     /// Adds a new stream to the index.
     pub fn stream_id_to_index(&self, id: u32) -> Option<usize> {
-        for (idx, str) in self.seek_info.iter().enumerate() {
-            if str.id == id {
+        for (idx, strm) in self.seek_info.iter().enumerate() {
+            if strm.id == id {
                 return Some(idx);
             }
         }
@@ -309,12 +306,7 @@ impl SeekIndex {
     }
     /// Returns stream reference for provided stream ID.
     pub fn get_stream_index(&mut self, id: u32) -> Option<&mut StreamSeekInfo> {
-        for stream in self.seek_info.iter_mut() {
-            if stream.id == id {
-                return Some(stream);
-            }
-        }
-        None
+        self.seek_info.iter_mut().find(|stream| stream.id == id)
     }
     /// Adds seeking information to the index.
     pub fn add_entry(&mut self, id: u32, entry: SeekEntry) {
@@ -354,10 +346,10 @@ pub struct Demuxer<'a> {
 
 impl<'a> Demuxer<'a> {
     /// Constructs a new `Demuxer` instance.
-    fn new(dmx: Box<dyn DemuxCore<'a> + 'a>, str: StreamManager, seek_idx: SeekIndex) -> Self {
+    fn new(dmx: Box<dyn DemuxCore<'a> + 'a>, strmgr: StreamManager, seek_idx: SeekIndex) -> Self {
         Demuxer {
             dmx,
-            streams:    str,
+            streams:    strmgr,
             seek_idx,
         }
     }
@@ -471,6 +463,16 @@ pub fn create_demuxer<'a>(dmxcr: &dyn DemuxerCreator, br: &'a mut ByteReader<'a>
     Ok(Demuxer::new(dmx, strmgr, seek_idx))
 }
 
+/// Creates demuxer for a provided bytestream with options applied right after its creation.
+pub fn create_demuxer_with_options<'a>(dmxcr: &dyn DemuxerCreator, br: &'a mut ByteReader<'a>, opts: &[NAOption]) -> DemuxerResult<Demuxer<'a>> {
+    let mut dmx = dmxcr.new_demuxer(br);
+    dmx.set_options(opts);
+    let mut strmgr = StreamManager::new();
+    let mut seek_idx = SeekIndex::new();
+    dmx.open(&mut strmgr, &mut seek_idx)?;
+    Ok(Demuxer::new(dmx, strmgr, seek_idx))
+}
+
 /// List of registered demuxers.
 #[derive(Default)]
 pub struct RegisteredDemuxers {
@@ -488,12 +490,7 @@ impl RegisteredDemuxers {
     }
     /// 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
+        self.dmxs.iter().find(|&&dmx| dmx.get_name() == name).copied()
     }
     /// Provides an iterator over currently registered demuxers.
     pub fn iter(&self) -> std::slice::Iter<&dyn DemuxerCreator> {
@@ -637,6 +634,16 @@ pub fn create_raw_demuxer<'a>(dmxcr: &dyn RawDemuxerCreator, br: &'a mut ByteRea
     Ok(RawDemuxer::new(dmx, strmgr, seek_idx))
 }
 
+/// Creates raw data demuxer for a provided bytestream with options applied right after its creation.
+pub fn create_raw_demuxer_with_options<'a>(dmxcr: &dyn RawDemuxerCreator, br: &'a mut ByteReader<'a>, opts: &[NAOption]) -> DemuxerResult<RawDemuxer<'a>> {
+    let mut dmx = dmxcr.new_demuxer(br);
+    dmx.set_options(opts);
+    let mut strmgr = StreamManager::new();
+    let mut seek_idx = SeekIndex::new();
+    dmx.open(&mut strmgr, &mut seek_idx)?;
+    Ok(RawDemuxer::new(dmx, strmgr, seek_idx))
+}
+
 /// List of registered demuxers.
 #[derive(Default)]
 pub struct RegisteredRawDemuxers {
@@ -654,12 +661,7 @@ impl RegisteredRawDemuxers {
     }
     /// Searches for a demuxer that supports requested container format.
     pub fn find_demuxer(&self, name: &str) -> Option<&dyn RawDemuxerCreator> {
-        for &dmx in self.dmxs.iter() {
-            if dmx.get_name() == name {
-                return Some(dmx);
-            }
-        }
-        None
+        self.dmxs.iter().find(|&&dmx| dmx.get_name() == name).copied()
     }
     /// Provides an iterator over currently registered demuxers.
     pub fn iter(&self) -> std::slice::Iter<&dyn RawDemuxerCreator> {