X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-core%2Fsrc%2Fcodecs%2Fmod.rs;h=1482a61f67ae5ca1ea64a1ea95e8d556aece90ee;hb=210f21b33136c0d4ed0c8e2dd02ffc7c9c518fc1;hp=2ae0c334766a0806bf281eb607fe50560b63d1cd;hpb=3983a2bb88a405cd581a0456a6f49471cb52f78f;p=nihav.git

diff --git a/nihav-core/src/codecs/mod.rs b/nihav-core/src/codecs/mod.rs
index 2ae0c33..1482a61 100644
--- a/nihav-core/src/codecs/mod.rs
+++ b/nihav-core/src/codecs/mod.rs
@@ -210,6 +210,13 @@ pub const ENC_MODE_CBR: u64 = 1 << 0;
 /// Encoding parameter flag to force constant framerate mode.
 pub const ENC_MODE_CFR: u64 = 1 << 1;
 
+/// Encoder supports constant bitrate mode.
+pub const ENC_CAPS_CBR: u64 = 1 << 0;
+/// Encoder supports skip frames.
+pub const ENC_CAPS_SKIPFRAME: u64 = 1 << 1;
+/// Encoder supports mid-stream parameters change.
+pub const ENC_CAPS_PARAMCHANGE: u64 = 1 << 2;
+
 /// Encoding parameters.
 #[derive(Clone,Copy,PartialEq)]
 pub struct EncodeParameters {
@@ -219,7 +226,7 @@ pub struct EncodeParameters {
     pub tb_num:     u32,
     /// Time base denominator. Ignored for audio.
     pub tb_den:     u32,
-    /// Bitrate in kilobits per second.
+    /// Bitrate in bits per second.
     pub bitrate:    u32,
     /// A collection of various boolean encoder settings like CBR mode.
     ///
@@ -300,6 +307,10 @@ pub trait NAEncoder: NAOptionHandler {
     /// // convert input into format defined in target_params, feed to the encoder, ...
     /// ```
     fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters>;
+    /// Queries encoder capabilities.
+    ///
+    /// See `ENC_CAPS_*` for examples.
+    fn get_capabilities(&self) -> u64;
     /// Initialises the encoder.
     fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef>;
     /// Takes a single frame for encoding.
@@ -351,3 +362,71 @@ impl RegisteredEncoders {
     }
 }
 
+/// Trait for packetisers (objects that form full packets from raw stream data).
+pub trait NAPacketiser {
+    /// Queues new raw stream data for parsing.
+    ///
+    /// Returns false is the internal buffer grows too large.
+    fn add_data(&mut self, src: &[u8]) -> bool;
+    /// Tries to retrieve stream information from the data.
+    ///
+    /// Returns [`NAStream`] reference on success (with stream ID set to `id`), [`ShortData`] when there is not enough data to parse the headers and other errors in case there was an error parsing the data.
+    ///
+    /// [`NAStream`]: ../frame/struct.NAStream.html
+    /// [`ShortData`]: ./enum.DecoderError.html#variant.ShortData
+    fn parse_stream(&mut self, id: u32) -> DecoderResult<NAStreamRef>;
+    /// Tries to discard junk data until the first possible packet header.
+    ///
+    /// Returns the number of bytes skipped.
+    fn skip_junk(&mut self) -> DecoderResult<usize>;
+    /// Tries to form full packet from the already queued data.
+    ///
+    /// The function should be called repeatedly until it returns nothing or an error.
+    fn get_packet(&mut self, stream: NAStreamRef) -> DecoderResult<Option<NAPacket>>;
+    /// Resets the internal buffer.
+    fn reset(&mut self);
+    /// Tells how much data is left in the internal buffer.
+    fn bytes_left(&self) -> usize;
+}
+
+/// Decoder information used during creating a packetiser for requested codec.
+#[derive(Clone,Copy)]
+pub struct PacketiserInfo {
+    /// Short packetiser name.
+    pub name: &'static str,
+    /// The function that creates a packetiser instance.
+    pub get_packetiser: fn () -> Box<dyn NAPacketiser + Send>,
+}
+
+/// Structure for registering known packetisers.
+///
+/// It is supposed to be filled using `register_all_packetisers()` from some decoders crate and then it can be used to create packetisers for the requested codecs.
+#[derive(Default)]
+pub struct RegisteredPacketisers {
+    packs:  Vec<PacketiserInfo>,
+}
+
+impl RegisteredPacketisers {
+    /// Constructs a new instance of `RegisteredPacketisers`.
+    pub fn new() -> Self {
+        Self { packs: Vec::new() }
+    }
+    /// Adds another packetiser to the registry.
+    pub fn add_packetiser(&mut self, pack: PacketiserInfo) {
+        self.packs.push(pack);
+    }
+    /// Searches for the packetiser for the provided name and returns a function for creating it on success.
+    pub fn find_packetiser(&self, name: &str) -> Option<fn () -> Box<dyn NAPacketiser + Send>> {
+        for &pack in self.packs.iter() {
+            if pack.name == name {
+                return Some(pack.get_packetiser);
+            }
+        }
+        None
+    }
+    /// Provides an iterator over currently registered packetiser.
+    pub fn iter(&self) -> std::slice::Iter<PacketiserInfo> {
+        self.packs.iter()
+    }
+}
+