X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-core%2Fsrc%2Fcodecs%2Fmod.rs;h=b6a1820d6bcf6bb87b3c9cad6f0c41aea7af6dc4;hb=7f754c49a843d9b63885a1fa7e06f4d2cf6ccc5f;hp=86441e6031ef20dfe118cff8069e98ca8159b11f;hpb=20766f15236404c4eb336229d4a9d202d107bb99;p=nihav.git diff --git a/nihav-core/src/codecs/mod.rs b/nihav-core/src/codecs/mod.rs index 86441e6..b6a1820 100644 --- a/nihav-core/src/codecs/mod.rs +++ b/nihav-core/src/codecs/mod.rs @@ -4,6 +4,7 @@ use crate::io::byteio::ByteIOError; use crate::io::bitreader::BitReaderError; use crate::io::codebook::CodebookError; pub use crate::options::*; +pub use std::str::FromStr; /// A list specifying general decoding errors. #[derive(Debug,Clone,Copy,PartialEq)] @@ -17,6 +18,8 @@ pub enum DecoderError { TryAgain, /// Invalid input data was provided. InvalidData, + /// Checksum verification failed. + ChecksumError, /// Provided input turned out to be incomplete. ShortData, /// Decoder could not decode provided frame because it references some missing previous frame. @@ -77,7 +80,7 @@ impl Default for NADecoderSupport { } /// Decoder trait. -pub trait NADecoder { +pub trait NADecoder: NAOptionHandler { /// Initialises the decoder. /// /// It takes [`NADecoderSupport`] allocated by the caller and `NACodecInfoRef` provided by demuxer. @@ -101,7 +104,7 @@ pub struct DecoderInfo { /// Structure for registering known decoders. /// -/// It is supposed to be filled using `register_all_codecs()` from some decoders crate and then it can be used to create decoders for the requested codecs. +/// It is supposed to be filled using `register_all_decoders()` from some decoders crate and then it can be used to create decoders for the requested codecs. #[derive(Default)] pub struct RegisteredDecoders { decs: Vec, @@ -131,6 +134,46 @@ impl RegisteredDecoders { } } +/// Frame skipping mode for decoders. +#[derive(Clone,Copy,PartialEq,Debug)] +pub enum FrameSkipMode { + /// Decode all frames. + None, + /// Decode all key frames. + KeyframesOnly, + /// Decode only intra frames. + IntraOnly, +} + +impl Default for FrameSkipMode { + fn default() -> Self { + FrameSkipMode::None + } +} + +impl FromStr for FrameSkipMode { + type Err = DecoderError; + + fn from_str(s: &str) -> Result { + match s { + FRAME_SKIP_OPTION_VAL_NONE => Ok(FrameSkipMode::None), + FRAME_SKIP_OPTION_VAL_KEYFRAME => Ok(FrameSkipMode::KeyframesOnly), + FRAME_SKIP_OPTION_VAL_INTRA => Ok(FrameSkipMode::IntraOnly), + _ => Err(DecoderError::InvalidData), + } + } +} + +impl ToString for FrameSkipMode { + fn to_string(&self) -> String { + match *self { + FrameSkipMode::None => FRAME_SKIP_OPTION_VAL_NONE.to_string(), + FrameSkipMode::KeyframesOnly => FRAME_SKIP_OPTION_VAL_KEYFRAME.to_string(), + FrameSkipMode::IntraOnly => FRAME_SKIP_OPTION_VAL_INTRA.to_string(), + } + } +} + /// A list specifying general encoding errors. #[derive(Debug,Clone,Copy,PartialEq)] #[allow(dead_code)] @@ -158,6 +201,10 @@ impl From for EncoderError { fn from(_: ByteIOError) -> Self { EncoderError::Bug } } +impl From for EncoderError { + fn from(_: AllocatorError) -> Self { EncoderError::AllocError } +} + /// Encoding parameter flag to force constant bitrate mode. pub const ENC_MODE_CBR: u64 = 1 << 0; /// Encoding parameter flag to force constant framerate mode. @@ -218,7 +265,7 @@ impl Default for EncodeParameters { /// while let Some(frame) = queue.get_frame() { /// // convert to the format encoder expects if required /// encoder.encode(frame)?; -/// while let Some(enc_pkt) = encoder.get_packet()? { +/// while let Ok(enc_pkt) = encoder.get_packet()? { /// // send encoded packet to a muxer for example /// } /// } @@ -274,7 +321,7 @@ pub struct EncoderInfo { /// Structure for registering known encoders. /// -/// It is supposed to be filled using `register_all_codecs()` from some encoders crate and then it can be used to create encoders for the requested codecs. +/// It is supposed to be filled using `register_all_decoders()` from some encoders crate and then it can be used to create encoders for the requested codecs. #[derive(Default)] pub struct RegisteredEncoders { encs: Vec, @@ -304,3 +351,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; + /// Tries to discard junk data until the first possible packet header. + /// + /// Returns the number of bytes skipped. + fn skip_junk(&mut self) -> DecoderResult; + /// 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>; + /// 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, +} + +/// 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, +} + +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 Box> { + 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 { + self.packs.iter() + } +} +