Struct gstreamer_video::VideoDecoder

pub struct VideoDecoder { /* private fields */ }

This base class is for video decoders turning encoded data into raw video frames.

The GstVideoDecoder base class and derived subclasses should cooperate as follows:

Configuration

• Initially, GstVideoDecoder calls start when the decoder element is activated, which allows the subclass to perform any global setup.

• GstVideoDecoder calls set_format to inform the subclass of caps describing input video data that it is about to receive, including possibly configuration data. While unlikely, it might be called more than once, if changing input parameters require reconfiguration.

• Incoming data buffers are processed as needed, described in Data Processing below.

• GstVideoDecoder calls stop at end of all processing.

Data processing

• The base class gathers input data, and optionally allows subclass to parse this into subsequently manageable chunks, typically corresponding to and referred to as ‘frames’.

• Each input frame is provided in turn to the subclass’ handle_frame callback.

• When the subclass enables the subframe mode with gst_video_decoder_set_subframe_mode, the base class will provide to the subclass the same input frame with different input buffers to the subclass handle_frame callback. During this call, the subclass needs to take ownership of the input_buffer as VideoCodecFrame will have been changed before the next subframe buffer is received. The subclass will call gst_video_decoder_have_last_subframe when a new input frame can be created by the base class. Every subframe will share the same VideoCodecFrame to write the decoding result. The subclass is responsible to protect its access.

• If codec processing results in decoded data, the subclass should call VideoDecoderExt::finish_frame() to have decoded data pushed downstream. In subframe mode the subclass should call VideoDecoderExt::finish_subframe() until the last subframe where it should call VideoDecoderExt::finish_frame(). The subclass can detect the last subframe using GST_VIDEO_BUFFER_FLAG_MARKER on buffers or using its own logic to collect the subframes. In case of decoding failure, the subclass must call VideoDecoderExt::drop_frame() or VideoDecoderExt::drop_subframe(), to allow the base class to do timestamp and offset tracking, and possibly to requeue the frame for a later attempt in the case of reverse playback.

Shutdown phase

• The GstVideoDecoder class calls stop to inform the subclass that data parsing will be stopped.

Additional Notes

• Seeking/Flushing

• When the pipeline is seeked or otherwise flushed, the subclass is informed via a call to its reset callback, with the hard parameter set to true. This indicates the subclass should drop any internal data queues and timestamps and prepare for a fresh set of buffers to arrive for parsing and decoding.

• End Of Stream

• At end-of-stream, the subclass parse function may be called some final times with the at_eos parameter set to true, indicating that the element should not expect any more data to be arriving, and it should parse and remaining frames and call VideoDecoderExt::have_frame() if possible.

The subclass is responsible for providing pad template caps for source and sink pads. The pads need to be named “sink” and “src”. It also needs to provide information about the output caps, when they are known. This may be when the base class calls the subclass’ set_format function, though it might be during decoding, before calling VideoDecoderExt::finish_frame(). This is done via VideoDecoderExtManual::set_output_state()

The subclass is also responsible for providing (presentation) timestamps (likely based on corresponding input ones). If that is not applicable or possible, the base class provides limited framerate based interpolation.

Similarly, the base class provides some limited (legacy) seeking support if specifically requested by the subclass, as full-fledged support should rather be left to upstream demuxer, parser or alike. This simple approach caters for seeking and duration reporting using estimated input bitrates. To enable it, a subclass should call VideoDecoderExt::set_estimate_rate() to enable handling of incoming byte-streams.

The base class provides some support for reverse playback, in particular in case incoming data is not packetized or upstream does not provide fragments on keyframe boundaries. However, the subclass should then be prepared for the parsing and frame processing stage to occur separately (in normal forward processing, the latter immediately follows the former), The subclass also needs to ensure the parsing stage properly marks keyframes, unless it knows the upstream elements will do so properly for incoming data.

The bare minimum that a functional subclass needs to implement is:

• Provide pad templates

• Inform the base class of output caps via VideoDecoderExtManual::set_output_state()

• Parse input data, if it is not considered packetized from upstream Data will be provided to parse which should invoke VideoDecoderExt::add_to_frame() and VideoDecoderExt::have_frame() to separate the data belonging to each video frame.

• Accept data in handle_frame and provide decoded results to VideoDecoderExt::finish_frame(), or call VideoDecoderExt::drop_frame().

This is an Abstract Base Class, you cannot instantiate it.

Properties

automatic-request-sync-point-flags

GstVideoDecoderRequestSyncPointFlags to use for the automatically requested sync points if automatic-request-sync-points is enabled.

Readable | Writeable

automatic-request-sync-points

If set to true the decoder will automatically request sync points when it seems like a good idea, e.g. if the first frames are not key frames or if packet loss was reported by upstream.

Readable | Writeable

discard-corrupted-frames

If set to true the decoder will discard frames that are marked as corrupted instead of outputting them.

Readable | Writeable

max-errors

Maximum number of tolerated consecutive decode errors. See VideoDecoderExt::set_max_errors() for more details.

Readable | Writeable

min-force-key-unit-interval

Minimum interval between force-key-unit events sent upstream by the decoder. Setting this to 0 will cause every event to be handled, setting this to GST_CLOCK_TIME_NONE will cause every event to be ignored.

See gst_video_event_new_upstream_force_key_unit() for more details about force-key-unit events.

Readable | Writeable

qos

If set to true the decoder will handle QoS events received from downstream elements. This includes dropping output frames which are detected as late using the metrics reported by those events.

Readable | Writeable

Object

name

Readable | Writeable | Construct

parent

The parent of the object. Please note, that when changing the ‘parent’ property, we don’t emit notify and deep-notify signals due to locking issues. In some cases one can use GstBin::element-added or GstBin::element-removed signals on the parent to achieve a similar effect.

Readable | Writeable

Implements

VideoDecoderExt, gst::prelude::ElementExt, gst::prelude::ObjectExt, [trait@glib::ObjectExt], VideoDecoderExtManual

Implementations

impl VideoDecoder

pub const NONE: Option<&'static VideoDecoder> = None

Trait Implementations

impl Clone for VideoDecoder

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VideoDecoder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HasParamSpec for VideoDecoder

type ParamSpec = ParamSpecObject

type SetValue = VideoDecoder

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecObjectBuilder<'_, VideoDecoder>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for VideoDecoder

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: VideoDecoderImpl> IsSubclassable<T> for VideoDecoder

fn class_init(klass: &mut Class<Self>)

Override the virtual methods of this class for the given subclass and do other class initialization.

fn instance_init(instance: &mut InitializingObject<T>)

Instance specific initialization.

impl Ord for VideoDecoder

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl ParentClassIs for VideoDecoder

type Parent = Element

impl<OT: ObjectType> PartialEq<OT> for VideoDecoder

fn eq(&self, other: &OT) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT: ObjectType> PartialOrd<OT> for VideoDecoder

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for VideoDecoder

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for VideoDecoder

impl IsA<Element> for VideoDecoder

impl IsA<Object> for VideoDecoder

impl Send for VideoDecoder

impl Sync for VideoDecoder