/// 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<()> {
/// Adds a new stream.
pub fn add_stream(&mut self, stream: NAStream) -> Option<usize> {
let stream_num = self.streams.len();
- let mut str = stream;
- str.set_num(stream_num);
- self.streams.push(str.into_ref());
+ let mut stream = stream;
+ stream.set_num(stream_num);
+ self.streams.push(stream.into_ref());
self.ignored.push(false);
Some(stream_num)
}
}
/// 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);
}
}
}
/// Returns stream reference for provided stream ID.
pub fn get_stream_index(&mut self, id: u32) -> Option<&mut StreamSeekInfo> {
- for str in self.seek_info.iter_mut() {
- if str.id == id {
- return Some(str);
+ for stream in self.seek_info.iter_mut() {
+ if stream.id == id {
+ return Some(stream);
}
}
None
/// Searches for a seek position before requested time.
pub fn find_pos(&self, time: NATimePoint) -> Option<SeekIndexResult> {
let mut cand = None;
- for str in self.seek_info.iter() {
- if !str.filled { continue; }
- let res = str.find_pos(time);
+ for stream in self.seek_info.iter() {
+ if !stream.filled { continue; }
+ let res = stream.find_pos(time);
if res.is_none() { continue; }
let res = res.unwrap();
if cand.is_none() {
- cand = Some(SeekIndexResult { pts: res.pts, pos: res.pos, str_id: str.id });
+ cand = Some(SeekIndexResult { pts: res.pts, pos: res.pos, str_id: stream.id });
} else if let Some(entry) = cand {
if res.pos < entry.pos {
- cand = Some(SeekIndexResult { pts: res.pts, pos: res.pos, str_id: str.id });
+ cand = Some(SeekIndexResult { pts: res.pts, pos: res.pos, str_id: stream.id });
}
}
}
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,
}
}
/// Creates demuxer for a provided bytestream.
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 strmgr = StreamManager::new();
+ let mut seek_idx = SeekIndex::new();
+ dmx.open(&mut strmgr, &mut seek_idx)?;
+ 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 str, &mut seek_idx)?;
- Ok(Demuxer::new(dmx, str, seek_idx))
+ dmx.open(&mut strmgr, &mut seek_idx)?;
+ Ok(Demuxer::new(dmx, strmgr, seek_idx))
}
/// List of registered demuxers.
/// Creates raw data demuxer for a provided bytestream.
pub fn create_raw_demuxer<'a>(dmxcr: &dyn RawDemuxerCreator, br: &'a mut ByteReader<'a>) -> DemuxerResult<RawDemuxer<'a>> {
let mut dmx = dmxcr.new_demuxer(br);
- let mut str = StreamManager::new();
+ 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))
+}
+
+/// 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 str, &mut seek_idx)?;
- Ok(RawDemuxer::new(dmx, str, seek_idx))
+ dmx.open(&mut strmgr, &mut seek_idx)?;
+ Ok(RawDemuxer::new(dmx, strmgr, seek_idx))
}
/// List of registered demuxers.