[−][src]Struct gstreamer_video::VideoDecoder

pub struct VideoDecoder(_, _);

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. The ownership of the frame is given to the handle_frame callback.
If codec processing results in decoded data, the subclass should call VideoDecoder::finish_frame to have decoded data pushed. downstream. Otherwise, the subclass must call VideoDecoder::drop_frame, 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 VideoDecoder::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 VideoDecoder::finish_frame. This is done via VideoDecoder::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 VideoDecoder::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 VideoDecoder::have_frame to separate the data belonging to each video frame.
Accept data in handle_frame and provide decoded results to VideoDecoder::finish_frame, or call VideoDecoder::drop_frame.

Implements

VideoDecoderExt, gst::ElementExt, gst::ObjectExt, glib::object::ObjectExt, VideoDecoderExtManual

Trait Implementations

`impl Clone for VideoDecoder`[src]

`fn clone(&self) -> VideoDecoder`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Debug for VideoDecoder`[src]

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

`impl Eq for VideoDecoder`[src]

`impl Hash for VideoDecoder`[src]

`fn hash<H: Hasher>(&self, state: &mut H)`[src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` 1.3.0[src]

`impl IsA<Element> for VideoDecoder`[src]

`impl IsA<Object> for VideoDecoder`[src]

`impl Ord for VideoDecoder`[src]

`fn cmp(&self, other: &VideoDecoder) -> Ordering`[src]

`#[must_use]fn max(self, other: Self) -> Self`1.21.0[src]

`#[must_use]fn min(self, other: Self) -> Self`1.21.0[src]

`#[must_use]fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<T: ObjectType> PartialEq<T> for VideoDecoder`[src]

`fn eq(&self, other: &T) -> bool`[src]

`#[must_use]fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

`impl<T: ObjectType> PartialOrd<T> for VideoDecoder`[src]

`fn partial_cmp(&self, other: &T) -> Option<Ordering>`[src]

`#[must_use]fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

`#[must_use]fn le(&self, other: &Rhs) -> bool`1.0.0[src]

`#[must_use]fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

`#[must_use]fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

`impl Send for VideoDecoder`[src]

`impl StaticType for VideoDecoder`[src]

`fn static_type() -> Type`[src]

`impl Sync for VideoDecoder`[src]

Auto Trait Implementations

`impl RefUnwindSafe for VideoDecoder`

`impl Unpin for VideoDecoder`

`impl UnwindSafe for VideoDecoder`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<Super, Sub> CanDowncast for Super where Sub: IsA<Super>, Super: IsA<Super>,` [src]

`impl<T> Cast for T where T: ObjectType,` [src]

`fn upcast<T>(self) -> T where Self: IsA<T>, T: ObjectType,` [src]

`fn upcast_ref<T>(&self) -> &T where Self: IsA<T>, T: ObjectType,` [src]

`fn downcast<T>(self) -> Result<T, Self> where Self: CanDowncast<T>, T: ObjectType,` [src]

`fn downcast_ref<T>(&self) -> Option<&T> where Self: CanDowncast<T>, T: ObjectType,` [src]

`fn dynamic_cast<T>(self) -> Result<T, Self> where T: ObjectType,` [src]

`fn dynamic_cast_ref<T>(&self) -> Option<&T> where T: ObjectType,` [src]

`unsafe fn unsafe_cast<T>(self) -> T where T: ObjectType,` [src]

`unsafe fn unsafe_cast_ref<T>(&self) -> &T where T: ObjectType,` [src]

`impl<O> ElementExt for O where O: IsA<Element>,` [src]

`fn abort_state(&self)`[src]

`fn add_pad(&self, pad: &P) -> Result<(), BoolError> where P: IsA<Pad>,` [src]

`fn create_all_pads(&self)`[src]

`fn foreach_pad(&self, func: P) -> bool where P: FnMut(&Element, &Pad) -> bool,` [src]

`fn foreach_sink_pad(&self, func: P) -> bool where P: FnMut(&Element, &Pad) -> bool,` [src]

`fn foreach_src_pad(&self, func: P) -> bool where P: FnMut(&Element, &Pad) -> bool,` [src]

`fn get_base_time(&self) -> ClockTime`[src]

`fn get_bus(&self) -> Option<Bus>`[src]

`fn get_clock(&self) -> Option<Clock>`[src]

`fn get_compatible_pad(&self, pad: &P, caps: Option<&Caps>) -> Option<Pad> where P: IsA<Pad>,` [src]

`fn get_compatible_pad_template( &self, compattempl: &PadTemplate ) -> Option<PadTemplate>`[src]

`fn get_context(&self, context_type: &str) -> Option<Context>`[src]

`fn get_contexts(&self) -> Vec<Context>`[src]

`fn get_factory(&self) -> Option<ElementFactory>`[src]

`fn get_request_pad(&self, name: &str) -> Option<Pad>`[src]

`fn get_start_time(&self) -> ClockTime`[src]

`fn get_static_pad(&self, name: &str) -> Option<Pad>`[src]

`fn is_locked_state(&self) -> bool`[src]

`fn link(&self, dest: &P) -> Result<(), BoolError> where P: IsA<Element>,` [src]

`fn link_filtered( &self, dest: &P, filter: Option<&Caps> ) -> Result<(), BoolError> where P: IsA<Element>,` [src]

`fn link_pads( &self, srcpadname: Option<&str>, dest: &P, destpadname: Option<&str> ) -> Result<(), BoolError> where P: IsA<Element>,` [src]

`fn link_pads_filtered( &self, srcpadname: Option<&str>, dest: &P, destpadname: Option<&str>, filter: Option<&Caps> ) -> Result<(), BoolError> where P: IsA<Element>,` [src]

`fn link_pads_full( &self, srcpadname: Option<&str>, dest: &P, destpadname: Option<&str>, flags: PadLinkCheck ) -> Result<(), BoolError> where P: IsA<Element>,` [src]

`fn lost_state(&self)`[src]

`fn no_more_pads(&self)`[src]

`fn provide_clock(&self) -> Option<Clock>`[src]

`fn release_request_pad(&self, pad: &P) where P: IsA<Pad>,` [src]

`fn remove_pad(&self, pad: &P) -> Result<(), BoolError> where P: IsA<Pad>,` [src]

`fn request_pad( &self, templ: &PadTemplate, name: Option<&str>, caps: Option<&Caps> ) -> Option<Pad>`[src]

`fn set_base_time(&self, time: ClockTime)`[src]

`fn set_bus(&self, bus: Option<&Bus>)`[src]

`fn set_clock(&self, clock: Option<&P>) -> Result<(), BoolError> where P: IsA<Clock>,` [src]

`fn set_context(&self, context: &Context)`[src]

`fn set_locked_state(&self, locked_state: bool) -> bool`[src]

`fn set_start_time(&self, time: ClockTime)`[src]

`fn sync_state_with_parent(&self) -> Result<(), BoolError>`[src]

`fn unlink(&self, dest: &P) where P: IsA<Element>,` [src]

`fn unlink_pads(&self, srcpadname: &str, dest: &P, destpadname: &str) where P: IsA<Element>,` [src]

`fn connect_no_more_pads<F>(&self, f: F) -> SignalHandlerId where F: 'static + Send + Sync + Fn(&O),` [src]

`fn connect_pad_added<F>(&self, f: F) -> SignalHandlerId where F: 'static + Send + Sync + Fn(&O, &Pad),` [src]

`fn connect_pad_removed<F>(&self, f: F) -> SignalHandlerId where F: 'static + Send + Sync + Fn(&O, &Pad),` [src]

`impl<O> ElementExtManual for O where O: IsA<Element>,` [src]

`fn get_element_class(&self) -> &ElementClass`[src]

`fn change_state( &self, transition: StateChange ) -> Result<StateChangeSuccess, StateChangeError>`[src]

`fn continue_state( &self, ret: StateChangeReturn ) -> Result<StateChangeSuccess, StateChangeError>`[src]

`fn get_state( &self, timeout: ClockTime ) -> (Result<StateChangeSuccess, StateChangeError>, State, State)`[src]

`fn set_state( &self, state: State ) -> Result<StateChangeSuccess, StateChangeError>`[src]

`fn query(&self, query: &mut QueryRef) -> bool`[src]

`fn send_event(&self, event: Event) -> bool`[src]

`fn get_metadata<'a>(&self, key: &str) -> Option<&'a str>`[src]

`fn get_pad_template(&self, name: &str) -> Option<PadTemplate>`[src]

`fn get_pad_template_list(&self) -> Vec<PadTemplate>`[src]

`fn set_element_flags(&self, flags: ElementFlags)`[src]

`fn unset_element_flags(&self, flags: ElementFlags)`[src]

`fn get_element_flags(&self) -> ElementFlags`[src]

`fn message_full<T>( &self, type_: ElementMessageType, code: T, message: Option<&str>, debug: Option<&str>, file: &str, function: &str, line: u32 ) where T: MessageErrorDomain,` [src]

`fn message_full_with_details<T>( &self, type_: ElementMessageType, code: T, message: Option<&str>, debug: Option<&str>, file: &str, function: &str, line: u32, structure: Structure ) where T: MessageErrorDomain,` [src]

`fn post_message(&self, message: Message) -> Result<(), BoolError>`[src]

`fn post_error_message(&self, msg: ErrorMessage)`[src]

`fn iterate_pads(&self) -> Iterator<Pad>`[src]

`fn iterate_sink_pads(&self) -> Iterator<Pad>`[src]

`fn iterate_src_pads(&self) -> Iterator<Pad>`[src]

`fn get_pads(&self) -> Vec<Pad>`[src]

`fn get_sink_pads(&self) -> Vec<Pad>`[src]

`fn get_src_pads(&self) -> Vec<Pad>`[src]

`fn num_pads(&self) -> u16`[src]

`fn num_sink_pads(&self) -> u16`[src]

`fn num_src_pads(&self) -> u16`[src]

`fn add_property_deep_notify_watch( &self, property_name: Option<&str>, include_value: bool ) -> NotifyWatchId`[src]

`fn add_property_notify_watch( &self, property_name: Option<&str>, include_value: bool ) -> NotifyWatchId`[src]

`fn remove_property_notify_watch(&self, watch_id: NotifyWatchId)`[src]

`fn query_convert<V, U>(&self, src_val: V) -> Option where U: SpecificFormattedValue, V: Into<GenericFormattedValue>,` [src]

`fn query_convert_generic<V>( &self, src_val: V, dest_format: Format ) -> Option<GenericFormattedValue> where V: Into<GenericFormattedValue>,` [src]

`fn query_duration<T>(&self) -> Option<T> where T: SpecificFormattedValue,` [src]

`fn query_duration_generic( &self, format: Format ) -> Option<GenericFormattedValue>`[src]

`fn query_position<T>(&self) -> Option<T> where T: SpecificFormattedValue,` [src]

`fn query_position_generic( &self, format: Format ) -> Option<GenericFormattedValue>`[src]

`fn seek<V>( &self, rate: f64, flags: SeekFlags, start_type: SeekType, start: V, stop_type: SeekType, stop: V ) -> Result<(), BoolError> where V: Into<GenericFormattedValue>,` [src]

`fn seek_simple<V>( &self, seek_flags: SeekFlags, seek_pos: V ) -> Result<(), BoolError> where V: Into<GenericFormattedValue>,` [src]

`fn call_async<F>(&self, func: F) where F: FnOnce(&O) + Send + 'static,` [src]

`fn call_async_future<F, T>( &self, func: F ) -> Pin<Box<dyn Future<Output = T> + 'static + Send + Unpin>> where F: FnOnce(&O) -> T + Send + 'static, T: Send + 'static,` [src]

`fn get_current_running_time(&self) -> ClockTime`[src]

`fn get_current_clock_time(&self) -> ClockTime`[src]

`fn get_current_state(&self) -> State`[src]

`fn get_pending_state(&self) -> State`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<O> GObjectExtManualGst for O where O: IsA<Object>,` [src]

`fn set_property_from_str(&self, name: &str, value: &str)`[src]

`impl<O> GstObjectExt for O where O: IsA<Object>,` [src]

`fn default_error(&self, error: &Error, debug: Option<&str>)`[src]

`fn get_control_rate(&self) -> ClockTime`[src]

`fn get_name(&self) -> GString`[src]

`fn get_parent(&self) -> Option<Object>`[src]

`fn get_path_string(&self) -> GString`[src]

`fn has_active_control_bindings(&self) -> bool`[src]

`fn has_ancestor(&self, ancestor: &P) -> bool where P: IsA<Object>,` [src]

`fn has_as_ancestor(&self, ancestor: &P) -> bool where P: IsA<Object>,` [src]

`fn has_as_parent(&self, parent: &P) -> bool where P: IsA<Object>,` [src]

`fn set_control_binding_disabled(&self, property_name: &str, disabled: bool)`[src]

`fn set_control_bindings_disabled(&self, disabled: bool)`[src]

`fn set_control_rate(&self, control_rate: ClockTime)`[src]

`fn set_parent(&self, parent: &P) -> Result<(), BoolError> where P: IsA<Object>,` [src]

`fn suggest_next_sync(&self) -> ClockTime`[src]

`fn sync_values(&self, timestamp: ClockTime) -> Result<(), BoolError>`[src]

`fn unparent(&self)`[src]

`fn connect_property_parent_notify<F>(&self, f: F) -> SignalHandlerId where F: 'static + Send + Sync + Fn(&O),` [src]

`impl<O> GstObjectExtManual for O where O: IsA<Object>,` [src]

`fn connect_deep_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where F: 'static + Send + Sync + Fn(&O, &Object, &ParamSpec),` [src]

`fn set_object_flags(&self, flags: ObjectFlags)`[src]

`fn unset_object_flags(&self, flags: ObjectFlags)`[src]

`fn get_object_flags(&self) -> ObjectFlags`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> ObjectExt for T where T: ObjectType,` [src]

`fn is(&self) -> bool where U: StaticType,` [src]

`fn get_type(&self) -> Type`[src]

`fn get_object_class(&self) -> &ObjectClass`[src]

`fn set_properties( &self, property_values: &[(&str, &dyn ToValue)] ) -> Result<(), BoolError>`[src]

`fn set_property<'a, N>( &self, property_name: N, value: &dyn ToValue ) -> Result<(), BoolError> where N: Into<&'a str>,` [src]

`fn get_property<'a, N>(&self, property_name: N) -> Result<Value, BoolError> where N: Into<&'a str>,` [src]

`unsafe fn set_qdata<QD>(&self, key: Quark, value: QD) where QD: 'static,` [src]

`unsafe fn get_qdata<QD>(&self, key: Quark) -> Option<&QD> where QD: 'static,` [src]

`unsafe fn steal_qdata<QD>(&self, key: Quark) -> Option<QD> where QD: 'static,` [src]

`unsafe fn set_data<QD>(&self, key: &str, value: QD) where QD: 'static,` [src]

`unsafe fn get_data<QD>(&self, key: &str) -> Option<&QD> where QD: 'static,` [src]

`unsafe fn steal_data<QD>(&self, key: &str) -> Option<QD> where QD: 'static,` [src]

`fn block_signal(&self, handler_id: &SignalHandlerId)`[src]

`fn unblock_signal(&self, handler_id: &SignalHandlerId)`[src]

`fn stop_signal_emission(&self, signal_name: &str)`[src]

`fn disconnect(&self, handler_id: SignalHandlerId)`[src]

`fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where F: 'static + Send + Sync + Fn(&T, &ParamSpec),` [src]

`unsafe fn connect_notify_unsafe<F>( &self, name: Option<&str>, f: F ) -> SignalHandlerId where F: Fn(&T, &ParamSpec),` [src]

`fn notify<'a, N>(&self, property_name: N) where N: Into<&'a str>,` [src]

`fn notify_by_pspec(&self, pspec: &ParamSpec)`[src]

`fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where N: Into<&'a str>,` [src]

`fn get_property_type<'a, N>(&self, property_name: N) -> Option<Type> where N: Into<&'a str>,` [src]

`fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where N: Into<&'a str>,` [src]

`fn list_properties(&self) -> Vec<ParamSpec>`[src]

`fn connect<'a, N, F>( &self, signal_name: N, after: bool, callback: F ) -> Result<SignalHandlerId, BoolError> where F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static, N: Into<&'a str>,` [src]

`fn connect_local<'a, N, F>( &self, signal_name: N, after: bool, callback: F ) -> Result<SignalHandlerId, BoolError> where F: Fn(&[Value]) -> Option<Value> + 'static, N: Into<&'a str>,` [src]

`unsafe fn connect_unsafe<'a, N, F>( &self, signal_name: N, after: bool, callback: F ) -> Result<SignalHandlerId, BoolError> where F: Fn(&[Value]) -> Option<Value>, N: Into<&'a str>,` [src]

`fn emit<'a, N>( &self, signal_name: N, args: &[&dyn ToValue] ) -> Result<Option<Value>, BoolError> where N: Into<&'a str>,` [src]

`fn downgrade(&self) -> WeakRef<T>`[src]

`fn bind_property<'a, O, N, M>( &'a self, source_property: N, target: &'a O, target_property: M ) -> BindingBuilder<'a> where M: Into<&'a str>, N: Into<&'a str>, O: ObjectType,` [src]

`fn ref_count(&self) -> u32`[src]

`impl<'a, T> ToGlibContainerFromSlice<'a, *const GList> for T where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,` [src]

`type Storage = (Option<List>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)`

`fn to_glib_none_from_slice( t: &'a [T] ) -> (const GList, <T as ToGlibContainerFromSlice<'a, const GList>>::Storage)`[src]

`fn to_glib_container_from_slice( _t: &'a [T] ) -> (const GList, <T as ToGlibContainerFromSlice<'a, const GList>>::Storage)`[src]

`fn to_glib_full_from_slice(_t: &[T]) -> *const GList`[src]

`impl<'a, T> ToGlibContainerFromSlice<'a, *const GPtrArray> for T where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,` [src]

`type Storage = (Option<PtrArray>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)`

`fn to_glib_none_from_slice( t: &'a [T] ) -> (const GPtrArray, <T as ToGlibContainerFromSlice<'a, const GPtrArray>>::Storage)`[src]

`fn to_glib_container_from_slice( _t: &'a [T] ) -> (const GPtrArray, <T as ToGlibContainerFromSlice<'a, const GPtrArray>>::Storage)`[src]

`fn to_glib_full_from_slice(_t: &[T]) -> *const GPtrArray`[src]

`impl<'a, T> ToGlibContainerFromSlice<'a, *mut GArray> for T where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,` [src]

`type Storage = (Option<Array>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)`

`fn to_glib_none_from_slice( t: &'a [T] ) -> (mut GArray, <T as ToGlibContainerFromSlice<'a, mut GArray>>::Storage)`[src]

`fn to_glib_container_from_slice( t: &'a [T] ) -> (mut GArray, <T as ToGlibContainerFromSlice<'a, mut GArray>>::Storage)`[src]

`fn to_glib_full_from_slice(t: &[T]) -> *mut GArray`[src]

`impl<'a, T> ToGlibContainerFromSlice<'a, *mut GList> for T where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,` [src]

`type Storage = (Option<List>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)`

`fn to_glib_none_from_slice( t: &'a [T] ) -> (mut GList, <T as ToGlibContainerFromSlice<'a, mut GList>>::Storage)`[src]

`fn to_glib_container_from_slice( t: &'a [T] ) -> (mut GList, <T as ToGlibContainerFromSlice<'a, mut GList>>::Storage)`[src]

`fn to_glib_full_from_slice(t: &[T]) -> *mut GList`[src]

`impl<'a, T> ToGlibContainerFromSlice<'a, *mut GPtrArray> for T where T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,` [src]

`type Storage = (Option<PtrArray>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)`

`fn to_glib_none_from_slice( t: &'a [T] ) -> (mut GPtrArray, <T as ToGlibContainerFromSlice<'a, mut GPtrArray>>::Storage)`[src]

`fn to_glib_container_from_slice( t: &'a [T] ) -> (mut GPtrArray, <T as ToGlibContainerFromSlice<'a, mut GPtrArray>>::Storage)`[src]

`fn to_glib_full_from_slice(t: &[T]) -> *mut GPtrArray`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T> ToSendValue for T where T: ToValue + SetValue + Send + ?Sized,` [src]

`fn to_send_value(&self) -> SendValue`[src]

`impl<T> ToValue for T where T: SetValue + ?Sized,` [src]

`fn to_value(&self) -> Value`[src]

`fn to_value_type(&self) -> Type`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

[−][src]Struct gstreamer_video::VideoDecoder

Configuration

Data processing

Shutdown phase

Additional Notes

Implements

Trait Implementations

impl Clone for VideoDecoder[src]

fn clone(&self) -> VideoDecoder[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

impl Debug for VideoDecoder[src]

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

impl Eq for VideoDecoder[src]

impl Hash for VideoDecoder[src]

fn hash<__H: Hasher>(&self, state: &mut __H)[src]

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

impl IsA<Element> for VideoDecoder[src]

impl IsA<Object> for VideoDecoder[src]

impl Ord for VideoDecoder[src]

fn cmp(&self, other: &VideoDecoder) -> Ordering[src]

#[must_use]fn max(self, other: Self) -> Self1.21.0[src]

#[must_use]fn min(self, other: Self) -> Self1.21.0[src]

#[must_use]fn clamp(self, min: Self, max: Self) -> Self[src]

impl<T: ObjectType> PartialEq<T> for VideoDecoder[src]

fn eq(&self, other: &T) -> bool[src]

#[must_use]fn ne(&self, other: &Rhs) -> bool1.0.0[src]

impl<T: ObjectType> PartialOrd<T> for VideoDecoder[src]

fn partial_cmp(&self, other: &T) -> Option<Ordering>[src]

#[must_use]fn lt(&self, other: &Rhs) -> bool1.0.0[src]

#[must_use]fn le(&self, other: &Rhs) -> bool1.0.0[src]

#[must_use]fn gt(&self, other: &Rhs) -> bool1.0.0[src]

#[must_use]fn ge(&self, other: &Rhs) -> bool1.0.0[src]

impl Send for VideoDecoder[src]

impl StaticType for VideoDecoder[src]

fn static_type() -> Type[src]

impl Sync for VideoDecoder[src]

Auto Trait Implementations

impl RefUnwindSafe for VideoDecoder

impl Unpin for VideoDecoder

impl UnwindSafe for VideoDecoder

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

fn borrow_mut(&mut self) -> &mut T[src]

impl<Super, Sub> CanDowncast<Sub> for Super where Sub: IsA<Super>, Super: IsA<Super>, [src]

impl<T> Cast for T where T: ObjectType, [src]

fn upcast<T>(self) -> T where Self: IsA<T>, T: ObjectType, [src]

fn upcast_ref<T>(&self) -> &T where Self: IsA<T>, T: ObjectType, [src]

fn downcast<T>(self) -> Result<T, Self> where Self: CanDowncast<T>, T: ObjectType, [src]

fn downcast_ref<T>(&self) -> Option<&T> where Self: CanDowncast<T>, T: ObjectType, [src]

fn dynamic_cast<T>(self) -> Result<T, Self> where T: ObjectType, [src]

fn dynamic_cast_ref<T>(&self) -> Option<&T> where T: ObjectType, [src]

unsafe fn unsafe_cast<T>(self) -> T where T: ObjectType, [src]

unsafe fn unsafe_cast_ref<T>(&self) -> &T where T: ObjectType, [src]

impl<O> ElementExt for O where O: IsA<Element>, [src]

fn abort_state(&self)[src]

fn add_pad<P>(&self, pad: &P) -> Result<(), BoolError> where P: IsA<Pad>, [src]

fn create_all_pads(&self)[src]

fn foreach_pad<P>(&self, func: P) -> bool where P: FnMut(&Element, &Pad) -> bool, [src]

fn foreach_sink_pad<P>(&self, func: P) -> bool where P: FnMut(&Element, &Pad) -> bool, [src]

fn foreach_src_pad<P>(&self, func: P) -> bool where P: FnMut(&Element, &Pad) -> bool, [src]

fn get_base_time(&self) -> ClockTime[src]

fn get_bus(&self) -> Option<Bus>[src]

fn get_clock(&self) -> Option<Clock>[src]

fn get_compatible_pad<P>(&self, pad: &P, caps: Option<&Caps>) -> Option<Pad> where P: IsA<Pad>, [src]

fn get_compatible_pad_template( &self, compattempl: &PadTemplate) -> Option<PadTemplate>[src]

fn get_context(&self, context_type: &str) -> Option<Context>[src]

fn get_contexts(&self) -> Vec<Context>[src]

fn get_factory(&self) -> Option<ElementFactory>[src]

fn get_request_pad(&self, name: &str) -> Option<Pad>[src]

fn get_start_time(&self) -> ClockTime[src]

fn get_static_pad(&self, name: &str) -> Option<Pad>[src]

fn is_locked_state(&self) -> bool[src]

fn link<P>(&self, dest: &P) -> Result<(), BoolError> where P: IsA<Element>, [src]

fn link_filtered<P>( &self, dest: &P, filter: Option<&Caps>) -> Result<(), BoolError> where P: IsA<Element>, [src]

fn link_pads<P>( &self, srcpadname: Option<&str>, dest: &P, destpadname: Option<&str>) -> Result<(), BoolError> where P: IsA<Element>, [src]

fn link_pads_filtered<P>( &self, srcpadname: Option<&str>, dest: &P, destpadname: Option<&str>, filter: Option<&Caps>) -> Result<(), BoolError> where P: IsA<Element>, [src]