1 //! Demuxer definitions.
2 pub use crate::frame::*;
3 pub use crate::io::byteio::*;
4 pub use crate::options::*;
6 /// A list specifying general demuxing errors.
7 #[derive(Debug,Clone,Copy,PartialEq)]
9 pub enum DemuxerError {
10 /// Reader got to end of stream.
12 /// Demuxer encountered empty container.
14 /// Demuxer encountered invalid input data.
16 /// Data reading error.
18 /// Feature is not implemented.
20 /// Allocation failed.
22 /// The operation should be repeated.
26 /// Operation cannot succeed in principle (e.g. seeking in a format not supporting seeking).
30 /// A specialised `Result` type for demuxing operations.
31 pub type DemuxerResult<T> = Result<T, DemuxerError>;
33 /// A trait for demuxing operations.
34 pub trait DemuxCore<'a>: NAOptionHandler {
35 /// Opens the input stream, reads required headers and prepares everything for packet demuxing.
36 fn open(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()>;
38 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket>;
39 /// Seeks to the requested time.
40 fn seek(&mut self, time: NATimePoint, seek_idx: &SeekIndex) -> DemuxerResult<()>;
41 /// Returns container duration in milliseconds (zero if not available).
42 fn get_duration(&self) -> u64;
45 /// An auxiliary trait to make bytestream reader read packet data.
46 pub trait NAPacketReader {
47 /// Reads input and constructs a packet containing it.
48 fn read_packet(&mut self, strm: NAStreamRef, ts: NATimeInfo, keyframe: bool, size: usize) -> DemuxerResult<NAPacket>;
49 /// Reads input into already existing packet.
50 fn fill_packet(&mut self, pkt: &mut NAPacket) -> DemuxerResult<()>;
53 impl<'a> NAPacketReader for ByteReader<'a> {
54 fn read_packet(&mut self, strm: NAStreamRef, ts: NATimeInfo, kf: bool, size: usize) -> DemuxerResult<NAPacket> {
55 let mut buf: Vec<u8> = Vec::with_capacity(size);
56 if buf.capacity() < size { return Err(DemuxerError::MemoryError); }
58 self.read_buf(buf.as_mut_slice())?;
59 let pkt = NAPacket::new(strm, ts, kf, buf);
62 fn fill_packet(&mut self, pkt: &mut NAPacket) -> DemuxerResult<()> {
63 let mut refbuf = pkt.get_buffer();
64 let buf = refbuf.as_mut().unwrap();
65 self.read_buf(buf.as_mut_slice())?;
70 /// An auxiliary structure for operations with individual streams inside the container.
72 pub struct StreamManager {
73 streams: Vec<NAStreamRef>,
79 /// Constructs a new instance of `StreamManager`.
80 pub fn new() -> Self {
87 /// Returns stream iterator.
88 pub fn iter(&self) -> StreamIter { StreamIter::new(&self.streams) }
90 /// Adds a new stream.
91 pub fn add_stream(&mut self, stream: NAStream) -> Option<usize> {
92 let stream_num = self.streams.len();
93 let mut stream = stream;
94 stream.set_num(stream_num);
95 self.streams.push(stream.into_ref());
96 self.ignored.push(false);
99 /// Adds a new stream from reference-counted object.
100 pub fn add_stream_ref(&mut self, stream: NAStreamRef) -> Option<usize> {
101 let stream_num = self.streams.len();
102 self.streams.push(stream);
103 self.ignored.push(false);
106 /// Returns stream with the requested index.
107 pub fn get_stream(&self, idx: usize) -> Option<NAStreamRef> {
108 if idx < self.streams.len() {
109 Some(self.streams[idx].clone())
114 /// Returns stream with the requested stream ID.
115 pub fn get_stream_by_id(&self, id: u32) -> Option<NAStreamRef> {
116 for i in 0..self.streams.len() {
117 if self.streams[i].get_id() == id {
118 return Some(self.streams[i].clone());
123 /// Returns the number of known streams.
124 pub fn get_num_streams(&self) -> usize { self.streams.len() }
125 /// Reports whether the stream is marked as ignored.
126 pub fn is_ignored(&self, idx: usize) -> bool {
129 } else if idx < self.ignored.len() {
135 /// Reports whether the stream with certain ID is marked as ignored.
136 pub fn is_ignored_id(&self, id: u32) -> bool {
137 for i in 0..self.streams.len() {
138 if self.streams[i].get_id() == id {
139 return self.ignored[i];
144 /// Marks requested stream as ignored.
145 pub fn set_ignored(&mut self, idx: usize) {
146 if idx < self.ignored.len() {
147 self.ignored[idx] = true;
151 /// Clears the ignored mark for the requested stream.
152 pub fn set_unignored(&mut self, idx: usize) {
153 if idx < self.ignored.len() {
154 self.ignored[idx] = false;
160 pub struct StreamIter<'a> {
161 streams: &'a [NAStreamRef],
165 impl<'a> StreamIter<'a> {
166 /// Constructs a new instance of `StreamIter`.
167 pub fn new(streams: &'a [NAStreamRef]) -> Self {
168 StreamIter { streams, pos: 0 }
172 impl<'a> Iterator for StreamIter<'a> {
173 type Item = NAStreamRef;
175 fn next(&mut self) -> Option<Self::Item> {
176 if self.pos >= self.streams.len() { return None; }
177 let ret = self.streams[self.pos].clone();
184 #[derive(Clone,Copy,PartialEq,Default)]
185 pub enum SeekIndexMode {
186 /// No seeking index present.
189 /// Seeking index is present.
191 /// Seeking index should be constructed by the demuxer if possible.
195 /// A structure holding seeking information.
196 #[derive(Clone,Copy,Default)]
197 pub struct SeekEntry {
198 /// Time in milliseconds.
202 /// Position in file.
206 /// Seeking information for individual streams.
208 pub struct StreamSeekInfo {
211 /// Index is present.
213 /// Packet seeking information.
214 pub entries: Vec<SeekEntry>,
217 impl StreamSeekInfo {
218 /// Constructs a new `StreamSeekInfo` instance.
219 pub fn new(id: u32) -> Self {
226 /// Adds new seeking point.
227 pub fn add_entry(&mut self, entry: SeekEntry) {
228 self.entries.push(entry);
230 /// Searches for an appropriate seek position before requested time.
231 pub fn find_pos(&self, time: NATimePoint) -> Option<SeekEntry> {
232 if time == NATimePoint::None {
235 if !self.entries.is_empty() {
236 // todo something faster like binary search
238 for entry in self.entries.iter() {
240 NATimePoint::Milliseconds(ms) => {
241 if entry.time <= ms {
247 NATimePoint::PTS(pts) => {
248 if entry.pts <= pts {
254 NATimePoint::None => unreachable!(),
264 /// Structure for holding seeking point search results.
265 #[derive(Clone,Copy,Default)]
266 pub struct SeekIndexResult {
269 /// Position in file.
275 /// Seek information for the whole container.
277 pub struct SeekIndex {
278 /// Seek information for individual streams.
279 pub seek_info: Vec<StreamSeekInfo>,
280 /// Seeking index mode.
281 pub mode: SeekIndexMode,
282 /// Ignore index flag.
283 pub skip_index: bool,
287 /// Constructs a new `SeekIndex` instance.
288 pub fn new() -> Self { Self::default() }
289 pub fn add_stream(&mut self, id: u32) -> usize {
290 let ret = self.stream_id_to_index(id);
291 if let Some(res) = ret {
294 self.seek_info.push(StreamSeekInfo::new(id));
295 self.seek_info.len() - 1
298 /// Adds a new stream to the index.
299 pub fn stream_id_to_index(&self, id: u32) -> Option<usize> {
300 for (idx, strm) in self.seek_info.iter().enumerate() {
307 /// Returns stream reference for provided stream ID.
308 pub fn get_stream_index(&mut self, id: u32) -> Option<&mut StreamSeekInfo> {
309 self.seek_info.iter_mut().find(|stream| stream.id == id)
311 /// Adds seeking information to the index.
312 pub fn add_entry(&mut self, id: u32, entry: SeekEntry) {
313 let mut idx = self.stream_id_to_index(id);
315 idx = Some(self.add_stream(id));
317 self.seek_info[idx.unwrap()].add_entry(entry);
318 self.seek_info[idx.unwrap()].filled = true;
320 /// Searches for a seek position before requested time.
321 pub fn find_pos(&self, time: NATimePoint) -> Option<SeekIndexResult> {
323 for stream in self.seek_info.iter() {
324 if !stream.filled { continue; }
325 let res = stream.find_pos(time);
326 if res.is_none() { continue; }
327 let res = res.unwrap();
329 cand = Some(SeekIndexResult { pts: res.pts, pos: res.pos, str_id: stream.id });
330 } else if let Some(entry) = cand {
331 if res.pos < entry.pos {
332 cand = Some(SeekIndexResult { pts: res.pts, pos: res.pos, str_id: stream.id });
340 /// Demuxer structure with auxiliary data.
341 pub struct Demuxer<'a> {
342 dmx: Box<dyn DemuxCore<'a> + 'a>,
343 streams: StreamManager,
347 impl<'a> Demuxer<'a> {
348 /// Constructs a new `Demuxer` instance.
349 fn new(dmx: Box<dyn DemuxCore<'a> + 'a>, strmgr: StreamManager, seek_idx: SeekIndex) -> Self {
356 /// Returns a stream reference by its number.
357 pub fn get_stream(&self, idx: usize) -> Option<NAStreamRef> {
358 self.streams.get_stream(idx)
360 /// Returns a stream reference by its ID.
361 pub fn get_stream_by_id(&self, id: u32) -> Option<NAStreamRef> {
362 self.streams.get_stream_by_id(id)
364 /// Reports the total number of streams.
365 pub fn get_num_streams(&self) -> usize {
366 self.streams.get_num_streams()
368 /// Returns a reference to the internal stream manager.
369 pub fn get_stream_manager(&self) -> &StreamManager {
372 /// Returns an iterator over streams.
373 pub fn get_streams(&self) -> StreamIter {
376 /// Returns 'ignored' marker for requested stream.
377 pub fn is_ignored_stream(&self, idx: usize) -> bool {
378 self.streams.is_ignored(idx)
380 /// Sets 'ignored' marker for requested stream.
381 pub fn set_ignored_stream(&mut self, idx: usize) {
382 self.streams.set_ignored(idx)
384 /// Clears 'ignored' marker for requested stream.
385 pub fn set_unignored_stream(&mut self, idx: usize) {
386 self.streams.set_unignored(idx)
389 /// Demuxes a new packet from the container.
390 pub fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
392 let res = self.dmx.get_frame(&mut self.streams);
393 if self.streams.no_ign || res.is_err() { return res; }
394 let res = res.unwrap();
395 let idx = res.get_stream().get_num();
396 if !self.is_ignored_stream(idx) {
401 /// Seeks to the requested time if possible.
402 pub fn seek(&mut self, time: NATimePoint) -> DemuxerResult<()> {
403 if self.seek_idx.skip_index {
404 return Err(DemuxerError::NotPossible);
406 self.dmx.seek(time, &self.seek_idx)
408 /// Returns internal seek index.
409 pub fn get_seek_index(&self) -> &SeekIndex {
412 /// Returns media duration reported by container or its streams.
414 /// Duration is in milliseconds and set to zero when it is not available.
415 pub fn get_duration(&self) -> u64 {
416 let duration = self.dmx.get_duration();
420 let mut duration = 0;
421 for stream in self.streams.iter() {
422 if stream.duration > 0 {
423 let dur = NATimeInfo::ts_to_time(stream.duration, 1000, stream.tb_num, stream.tb_den);
433 impl<'a> NAOptionHandler for Demuxer<'a> {
434 fn get_supported_options(&self) -> &[NAOptionDefinition] {
435 self.dmx.get_supported_options()
437 fn set_options(&mut self, options: &[NAOption]) {
438 self.dmx.set_options(options);
440 fn query_option_value(&self, name: &str) -> Option<NAValue> {
441 self.dmx.query_option_value(name)
445 impl From<ByteIOError> for DemuxerError {
446 fn from(_: ByteIOError) -> Self { DemuxerError::IOError }
449 /// The trait for creating demuxers.
450 pub trait DemuxerCreator {
451 /// Creates new demuxer instance that will use `ByteReader` source as an input.
452 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a>;
453 /// Returns the name of current demuxer creator (equal to the container name it can demux).
454 fn get_name(&self) -> &'static str;
457 /// Creates demuxer for a provided bytestream.
458 pub fn create_demuxer<'a>(dmxcr: &dyn DemuxerCreator, br: &'a mut ByteReader<'a>) -> DemuxerResult<Demuxer<'a>> {
459 let mut dmx = dmxcr.new_demuxer(br);
460 let mut strmgr = StreamManager::new();
461 let mut seek_idx = SeekIndex::new();
462 dmx.open(&mut strmgr, &mut seek_idx)?;
463 Ok(Demuxer::new(dmx, strmgr, seek_idx))
466 /// Creates demuxer for a provided bytestream with options applied right after its creation.
467 pub fn create_demuxer_with_options<'a>(dmxcr: &dyn DemuxerCreator, br: &'a mut ByteReader<'a>, opts: &[NAOption]) -> DemuxerResult<Demuxer<'a>> {
468 let mut dmx = dmxcr.new_demuxer(br);
469 dmx.set_options(opts);
470 let mut strmgr = StreamManager::new();
471 let mut seek_idx = SeekIndex::new();
472 dmx.open(&mut strmgr, &mut seek_idx)?;
473 Ok(Demuxer::new(dmx, strmgr, seek_idx))
476 /// List of registered demuxers.
478 pub struct RegisteredDemuxers {
479 dmxs: Vec<&'static dyn DemuxerCreator>,
482 impl RegisteredDemuxers {
483 /// Constructs a new `RegisteredDemuxers` instance.
484 pub fn new() -> Self {
485 Self { dmxs: Vec::new() }
487 /// Registers a new demuxer.
488 pub fn add_demuxer(&mut self, dmx: &'static dyn DemuxerCreator) {
491 /// Searches for a demuxer that supports requested container format.
492 pub fn find_demuxer(&self, name: &str) -> Option<&dyn DemuxerCreator> {
493 self.dmxs.iter().find(|&&dmx| dmx.get_name() == name).copied()
495 /// Provides an iterator over currently registered demuxers.
496 pub fn iter(&self) -> std::slice::Iter<&dyn DemuxerCreator> {
501 /// A trait for raw data demuxing operations.
502 pub trait RawDemuxCore<'a>: NAOptionHandler {
503 /// Opens the input stream, reads required headers and prepares everything for packet demuxing.
504 fn open(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()>;
505 /// Reads a piece of raw data.
506 fn get_data(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NARawData>;
507 /// Seeks to the requested time.
508 fn seek(&mut self, time: NATimePoint, seek_idx: &SeekIndex) -> DemuxerResult<()>;
509 /// Returns container duration in milliseconds (zero if not available).
510 fn get_duration(&self) -> u64;
513 /// Demuxer structure with auxiliary data.
514 pub struct RawDemuxer<'a> {
515 dmx: Box<dyn RawDemuxCore<'a> + 'a>,
516 streams: StreamManager,
520 impl<'a> RawDemuxer<'a> {
521 /// Constructs a new `Demuxer` instance.
522 fn new(dmx: Box<dyn RawDemuxCore<'a> + 'a>, strmgr: StreamManager, seek_idx: SeekIndex) -> Self {
529 /// Returns a stream reference by its number.
530 pub fn get_stream(&self, idx: usize) -> Option<NAStreamRef> {
531 self.streams.get_stream(idx)
533 /// Returns a stream reference by its ID.
534 pub fn get_stream_by_id(&self, id: u32) -> Option<NAStreamRef> {
535 self.streams.get_stream_by_id(id)
537 /// Reports the total number of streams.
538 pub fn get_num_streams(&self) -> usize {
539 self.streams.get_num_streams()
541 /// Returns a reference to the internal stream manager.
542 pub fn get_stream_manager(&self) -> &StreamManager {
545 /// Returns an iterator over streams.
546 pub fn get_streams(&self) -> StreamIter {
549 /// Returns 'ignored' marker for requested stream.
550 pub fn is_ignored_stream(&self, idx: usize) -> bool {
551 self.streams.is_ignored(idx)
553 /// Sets 'ignored' marker for requested stream.
554 pub fn set_ignored_stream(&mut self, idx: usize) {
555 self.streams.set_ignored(idx)
557 /// Clears 'ignored' marker for requested stream.
558 pub fn set_unignored_stream(&mut self, idx: usize) {
559 self.streams.set_unignored(idx)
562 /// Demuxes a new piece of data from the container.
563 pub fn get_data(&mut self) -> DemuxerResult<NARawData> {
565 let res = self.dmx.get_data(&mut self.streams);
566 if self.streams.no_ign || res.is_err() { return res; }
567 let res = res.unwrap();
568 let idx = res.get_stream().get_num();
569 if !self.is_ignored_stream(idx) {
574 /// Seeks to the requested time if possible.
575 pub fn seek(&mut self, time: NATimePoint) -> DemuxerResult<()> {
576 if self.seek_idx.skip_index {
577 return Err(DemuxerError::NotPossible);
579 self.dmx.seek(time, &self.seek_idx)
581 /// Returns internal seek index.
582 pub fn get_seek_index(&self) -> &SeekIndex {
585 /// Returns media duration reported by container or its streams.
587 /// Duration is in milliseconds and set to zero when it is not available.
588 pub fn get_duration(&self) -> u64 {
589 let duration = self.dmx.get_duration();
593 let mut duration = 0;
594 for stream in self.streams.iter() {
595 if stream.duration > 0 {
596 let dur = NATimeInfo::ts_to_time(stream.duration, 1000, stream.tb_num, stream.tb_den);
606 impl<'a> NAOptionHandler for RawDemuxer<'a> {
607 fn get_supported_options(&self) -> &[NAOptionDefinition] {
608 self.dmx.get_supported_options()
610 fn set_options(&mut self, options: &[NAOption]) {
611 self.dmx.set_options(options);
613 fn query_option_value(&self, name: &str) -> Option<NAValue> {
614 self.dmx.query_option_value(name)
618 /// The trait for creating raw data demuxers.
619 pub trait RawDemuxerCreator {
620 /// Creates new raw demuxer instance that will use `ByteReader` source as an input.
621 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn RawDemuxCore<'a> + 'a>;
622 /// Tries to check whether the input can be demuxed with the demuxer.
623 fn check_format(&self, br: &mut ByteReader) -> bool;
624 /// Returns the name of current raw data demuxer creator (equal to the container name it can demux).
625 fn get_name(&self) -> &'static str;
628 /// Creates raw data demuxer for a provided bytestream.
629 pub fn create_raw_demuxer<'a>(dmxcr: &dyn RawDemuxerCreator, br: &'a mut ByteReader<'a>) -> DemuxerResult<RawDemuxer<'a>> {
630 let mut dmx = dmxcr.new_demuxer(br);
631 let mut strmgr = StreamManager::new();
632 let mut seek_idx = SeekIndex::new();
633 dmx.open(&mut strmgr, &mut seek_idx)?;
634 Ok(RawDemuxer::new(dmx, strmgr, seek_idx))
637 /// Creates raw data demuxer for a provided bytestream with options applied right after its creation.
638 pub fn create_raw_demuxer_with_options<'a>(dmxcr: &dyn RawDemuxerCreator, br: &'a mut ByteReader<'a>, opts: &[NAOption]) -> DemuxerResult<RawDemuxer<'a>> {
639 let mut dmx = dmxcr.new_demuxer(br);
640 dmx.set_options(opts);
641 let mut strmgr = StreamManager::new();
642 let mut seek_idx = SeekIndex::new();
643 dmx.open(&mut strmgr, &mut seek_idx)?;
644 Ok(RawDemuxer::new(dmx, strmgr, seek_idx))
647 /// List of registered demuxers.
649 pub struct RegisteredRawDemuxers {
650 dmxs: Vec<&'static dyn RawDemuxerCreator>,
653 impl RegisteredRawDemuxers {
654 /// Constructs a new `RegisteredDemuxers` instance.
655 pub fn new() -> Self {
656 Self { dmxs: Vec::new() }
658 /// Registers a new demuxer.
659 pub fn add_demuxer(&mut self, dmx: &'static dyn RawDemuxerCreator) {
662 /// Searches for a demuxer that supports requested container format.
663 pub fn find_demuxer(&self, name: &str) -> Option<&dyn RawDemuxerCreator> {
664 self.dmxs.iter().find(|&&dmx| dmx.get_name() == name).copied()
666 /// Provides an iterator over currently registered demuxers.
667 pub fn iter(&self) -> std::slice::Iter<&dyn RawDemuxerCreator> {