nihav-core/src/muxers/mod.rs

   1 //! Muxer definitions.
   2 pub use crate::frame::*;
   3 pub use crate::io::byteio::*;
   4 pub use crate::demuxers::{StreamManager, StreamIter};
   5 pub use crate::options::*;
   6
   7 /// A list specifying general muxing errors.
   8 #[derive(Debug,Clone,Copy,PartialEq)]
   9 #[allow(dead_code)]
  10 pub enum MuxerError {
  11     /// An invalid argument was provided to the muxer.
  12     InvalidArgument,
  13     /// Trying to mux data without header being written.
  14     NotCreated,
  15     /// Muxer encountered invalid input packet.
  16     InvalidData,
  17     /// Input stream cannot be stored in this container format.
  18     UnsupportedFormat,
  19     /// Data writing error.
  20     IOError,
  21     /// Feature is not implemented.
  22     NotImplemented,
  23     /// Allocation failed.
  24     MemoryError,
  25     /// Operation cannot succeed in principle (e.g. seeking in an output stream not supporting seeking).
  26     NotPossible,
  27 }
  28
  29 /// A specialised `Result` type for muxing operations.
  30 pub type MuxerResult<T> = Result<T, MuxerError>;
  31
  32 /// Muxer capabilities.
  33 #[derive(Clone,Copy,Debug,PartialEq)]
  34 pub enum MuxerCapabilities {
  35     /// Muxer accepts single video stream with certain codec.
  36     ///
  37     /// Codec name `"any"` means various codecs are supported.
  38     SingleVideo(&'static str),
  39     /// Muxer accepts single audio stream with certain codec.
  40     ///
  41     /// Codec name `"any"` means various codecs are supported.
  42     SingleAudio(&'static str),
  43     /// Muxer accepts single video stream and single audio stream with defined codecs.
  44     SingleVideoAndAudio(&'static str, &'static str),
  45     /// Muxer accepts only video streams but can mux several video streams.
  46     OnlyVideo,
  47     /// Muxer accepts only audio streams but can mux several video streams..
  48     OnlyAudio,
  49     /// Muxer accepts variable amount of streams of any type.
  50     Universal,
  51 }
  52
  53 impl From<ByteIOError> for MuxerError {
  54     fn from(_: ByteIOError) -> Self { MuxerError::IOError }
  55 }
  56
  57 /// A trait for muxing operations.
  58 pub trait MuxCore<'a>: NAOptionHandler {
  59     /// Prepares everything for packet muxing.
  60     fn create(&mut self, strmgr: &StreamManager) -> MuxerResult<()>;
  61     /// Queues a packet for muxing.
  62     fn mux_frame(&mut self, strmgr: &StreamManager, pkt: NAPacket) -> MuxerResult<()>;
  63     /// Flushes the current muxing state.
  64     fn flush(&mut self) -> MuxerResult<()>;
  65     /// Finishes muxing and writes necessary header and trailer information if needed.
  66     fn end(&mut self) -> MuxerResult<()>;
  67 }
  68
  69 /// Muxer structure with auxiliary data.
  70 pub struct Muxer<'a> {
  71     mux:        Box<dyn MuxCore<'a> + 'a>,
  72     streams:    StreamManager,
  73 }
  74
  75 impl<'a> Muxer<'a> {
  76     /// Constructs a new `Muxer` instance.
  77     fn new(mux: Box<dyn MuxCore<'a> + 'a>, str: StreamManager) -> Self {
  78         Muxer {
  79             mux,
  80             streams:    str,
  81         }
  82     }
  83     /// Returns a stream reference by its number.
  84     pub fn get_stream(&self, idx: usize) -> Option<NAStreamRef> {
  85         self.streams.get_stream(idx)
  86     }
  87     /// Returns a stream reference by its ID.
  88     pub fn get_stream_by_id(&self, id: u32) -> Option<NAStreamRef> {
  89         self.streams.get_stream_by_id(id)
  90     }
  91     /// Reports the total number of streams.
  92     pub fn get_num_streams(&self) -> usize {
  93         self.streams.get_num_streams()
  94     }
  95     /// Returns an iterator over streams.
  96     pub fn get_streams(&self) -> StreamIter {
  97         self.streams.iter()
  98     }
  99
 100     /// Demuxes a new packet from the container.
 101     pub fn mux_frame(&mut self, pkt: NAPacket) -> MuxerResult<()> {
 102         self.mux.mux_frame(&self.streams, pkt)
 103     }
 104     /// Returns internal seek index.
 105     pub fn flush(&mut self) -> MuxerResult<()> {
 106         self.mux.flush()
 107     }
 108     /// Finishes muxing and writes necessary header and trailer information if needed.
 109     pub fn end(mut self) -> MuxerResult<()> {
 110         self.mux.end()
 111     }
 112 }
 113
 114 /// The trait for creating muxers.
 115 pub trait MuxerCreator {
 116     /// Creates new muxer instance that will use `ByteWriter` for output.
 117     fn new_muxer<'a>(&self, bw: &'a mut ByteWriter<'a>) -> Box<dyn MuxCore<'a> + 'a>;
 118     /// Returns the name of current muxer creator (equal to the container name it can create).
 119     fn get_name(&self) -> &'static str;
 120     /// Returns muxer capabilities for the current muxer.
 121     fn get_capabilities(&self) -> MuxerCapabilities;
 122 }
 123
 124 /// Creates muxer for a provided bytestream writer.
 125 pub fn create_muxer<'a>(mxcr: &MuxerCreator, str: StreamManager, bw: &'a mut ByteWriter<'a>) -> MuxerResult<Muxer<'a>> {
 126     let mut mux = mxcr.new_muxer(bw);
 127     mux.create(&str)?;
 128     Ok(Muxer::new(mux, str))
 129 }
 130
 131 /// List of registered muxers.
 132 #[derive(Default)]
 133 pub struct RegisteredMuxers {
 134     muxes:  Vec<&'static MuxerCreator>,
 135 }
 136
 137 impl RegisteredMuxers {
 138     /// Constructs a new `RegisteredMuxers` instance.
 139     pub fn new() -> Self {
 140         Self { muxes: Vec::new() }
 141     }
 142     /// Registers a new muxer.
 143     pub fn add_muxer(&mut self, mux: &'static MuxerCreator) {
 144         self.muxes.push(mux);
 145     }
 146     /// Searches for a muxer that supports requested container format.
 147     pub fn find_muxer(&self, name: &str) -> Option<&MuxerCreator> {
 148         for &mux in self.muxes.iter() {
 149             if mux.get_name() == name {
 150                 return Some(mux);
 151             }
 152         }
 153         None
 154     }
 155 }