Struct gstreamer::Task

source · [−]

#[repr(transparent)]
pub struct Task { /* private fields */ }

Expand description

Task is used by Element and Pad to provide the data passing threads in a Pipeline.

A Pad will typically start a Task to push or pull data to/from the peer pads. Most source elements start a Task to push data. In some cases a demuxer element can start a Task to pull data from a peer element. This is typically done when the demuxer can perform random access on the upstream peer element for improved performance.

Although convenience functions exist on Pad to start/pause/stop tasks, it might sometimes be needed to create a Task manually if it is not related to a Pad.

Before the Task can be run, it needs a GRecMutex that can be set with [TaskExtManual::set_lock()][crate::prelude::TaskExtManual::set_lock()].

The task can be started, paused and stopped with TaskExt::start(), TaskExt::pause() and TaskExt::stop() respectively or with the TaskExt::set_state() function.

A Task will repeatedly call the GstTaskFunction with the user data that was provided when creating the task with [new()][Self::new()]. While calling the function it will acquire the provided lock. The provided lock is released when the task pauses or stops.

Stopping a task with TaskExt::stop() will not immediately make sure the task is not running anymore. Use TaskExt::join() to make sure the task is completely stopped and the thread is stopped.

After creating a Task, use gst_object_unref() to free its resources. This can only be done when the task is not running anymore.

Task functions can send a Message to send out-of-band data to the application. The application can receive messages from the Bus in its mainloop.

For debugging purposes, the task will configure its object name as the thread name on Linux. Please note that the object name should be configured before the task is started; changing the object name after the task has been started, has no effect on the thread name.

Struct gstreamer::Task

Implements

Implementations

impl Task

pub const NONE: Option<&'static Task>

pub fn cleanup_all()

impl Task

pub fn builder<F: FnMut(&Task) + Send + 'static>(func: F) -> TaskBuilder<F>

Trait Implementations

impl Clone for Task

fn clone(&self) -> Self

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

impl Debug for Task

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

impl Hash for Task

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

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

impl Ord for Task

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

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

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

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

impl ParentClassIs for Task

type Parent = Object

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

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

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

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

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

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

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

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

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

impl StaticType for Task

fn static_type() -> Type

impl Eq for Task

impl IsA<Object> for Task

impl Send for Task

impl Sync for Task

Auto Trait Implementations

impl RefUnwindSafe for Task

impl Unpin for Task

impl UnwindSafe for Task

Blanket Implementations

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

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> Cast for T where T: ObjectType,

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

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

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

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

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

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

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

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

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T, U> Into<U> for T where U: From<T>,

pub fn into(self) -> U

impl<U> IsSubclassableExt for U where U: IsClass + ParentClassIs,

pub fn parent_class_init<T>(class: &mut Class<U>) where T: ObjectSubclass, <U as ParentClassIs>::Parent: IsSubclassable<T>,

pub fn parent_instance_init<T>(instance: &mut InitializingObject<T>) where T: ObjectSubclass, <U as ParentClassIs>::Parent: IsSubclassable<T>,

impl<T> ObjectExt for T where T: ObjectType,

pub fn is<U>(&self) -> bool where U: StaticType,

pub fn type_(&self) -> Type

pub fn object_class(&self) -> &Class<Object>

pub fn class(&self) -> &Class<T> where T: IsClass,

pub fn class_of<U>(&self) -> Option<&Class<U>> where U: IsClass,

pub fn interface<U>(&self) -> Option<InterfaceRef<'_, U>> where U: IsInterface,

pub fn try_set_property<V>( &self, property_name: &str, value: V) -> Result<(), BoolError> where V: ToValue,

pub fn set_property<V>(&self, property_name: &str, value: V) where V: ToValue,

pub fn try_set_property_from_value( &self, property_name: &str, value: &Value) -> Result<(), BoolError>

pub fn set_property_from_value(&self, property_name: &str, value: &Value)

pub fn try_set_properties( &self, property_values: &[(&str, &dyn ToValue)]) -> Result<(), BoolError>

pub fn set_properties(&self, property_values: &[(&str, &dyn ToValue)])

pub fn try_set_properties_from_value( &self, property_values: &[(&str, Value)]) -> Result<(), BoolError>

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

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

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

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T> Cast for T where
T: ObjectType,

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

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

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

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

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

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

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

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

impl<T, U> Into<U> for T where
U: From<T>,

impl<U> IsSubclassableExt for U where
U: IsClass + ParentClassIs,

pub fn parent_class_init<T>(class: &mut Class<U>) where
T: ObjectSubclass,
<U as ParentClassIs>::Parent: IsSubclassable<T>,

pub fn parent_instance_init<T>(instance: &mut InitializingObject<T>) where
T: ObjectSubclass,
<U as ParentClassIs>::Parent: IsSubclassable<T>,

impl<T> ObjectExt for T where
T: ObjectType,

pub fn is<U>(&self) -> bool where
U: StaticType,

pub fn class(&self) -> &Class<T> where
T: IsClass,

pub fn class_of<U>(&self) -> Option<&Class<U>> where
U: IsClass,

pub fn interface<U>(&self) -> Option<InterfaceRef<'_, U>> where
U: IsInterface,

pub fn try_set_property<V>(
&self,
property_name: &str,
value: V
) -> Result<(), BoolError> where
V: ToValue,

pub fn set_property<V>(&self, property_name: &str, value: V) where
V: ToValue,

pub fn try_set_property_from_value(
&self,
property_name: &str,
value: &Value
) -> Result<(), BoolError>

pub fn try_set_properties(
&self,
property_values: &[(&str, &dyn ToValue )]
) -> Result<(), BoolError>

pub fn set_properties(&self, property_values: &[(&str, &dyn ToValue )])

pub fn try_set_properties_from_value(
&self,
property_values: &[(&str, Value )]
) -> Result<(), BoolError>

pub fn set_properties_from_value(&self, property_values: &[(&str, Value )])

pub fn try_property<V>(&self, property_name: &str) -> Result<V, BoolError> where
V: 'static + for<'b> FromValue<'b>,

pub fn property<V>(&self, property_name: &str) -> V where
V: 'static + for<'b> FromValue<'b>,

pub fn try_property_value(
&self,
property_name: &str
) -> Result<Value, BoolError>

pub unsafe fn set_qdata<QD>(&self, key: Quark, value: QD) where
QD: 'static,

pub unsafe fn qdata<QD>(&self, key: Quark) -> Option<NonNull<QD>> where
QD: 'static,

pub unsafe fn steal_qdata<QD>(&self, key: Quark) -> Option<QD> where
QD: 'static,

pub unsafe fn set_data<QD>(&self, key: &str, value: QD) where
QD: 'static,

pub unsafe fn data<QD>(&self, key: &str) -> Option<NonNull<QD>> where
QD: 'static,

pub unsafe fn steal_data<QD>(&self, key: &str) -> Option<QD> where
QD: 'static,

pub fn try_connect<F>(
&self,
signal_name: &str,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: 'static + Fn(&[Value ]) -> Option<Value> + Send + Sync,

pub fn connect<F>(
&self,
signal_name: &str,
after: bool,
callback: F
) -> SignalHandlerId where
F: 'static + Fn(&[Value ]) -> Option<Value> + Send + Sync,

pub fn try_connect_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: 'static + Fn(&[Value ]) -> Option<Value> + Send + Sync,

pub fn connect_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> SignalHandlerId where
F: 'static + Fn(&[Value ]) -> Option<Value> + Send + Sync,

pub fn try_connect_local<F>(
&self,
signal_name: &str,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: 'static + Fn(&[Value ]) -> Option<Value>,

pub fn connect_local<F>(
&self,
signal_name: &str,
after: bool,
callback: F
) -> SignalHandlerId where
F: 'static + Fn(&[Value ]) -> Option<Value>,

pub fn try_connect_local_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: 'static + Fn(&[Value ]) -> Option<Value>,

pub fn connect_local_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> SignalHandlerId where
F: 'static + Fn(&[Value ]) -> Option<Value>,

pub unsafe fn try_connect_unsafe<F>(
&self,
signal_name: &str,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value ]) -> Option<Value>,

pub unsafe fn connect_unsafe<F>(
&self,
signal_name: &str,
after: bool,
callback: F
) -> SignalHandlerId where
F: Fn(&[Value ]) -> Option<Value>,

pub unsafe fn try_connect_unsafe_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value ]) -> Option<Value>,

pub fn try_connect_closure(
&self,
signal_name: &str,
after: bool,
closure: RustClosure
) -> Result<SignalHandlerId, BoolError>

pub fn connect_closure(
&self,
signal_name: &str,
after: bool,
closure: RustClosure
) -> SignalHandlerId

pub fn try_connect_closure_id(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
closure: RustClosure
) -> Result<SignalHandlerId, BoolError>

pub fn connect_closure_id(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
closure: RustClosure
) -> SignalHandlerId

pub unsafe fn connect_unsafe_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> SignalHandlerId where
F: Fn(&[Value ]) -> Option<Value>,

pub fn try_emit<R>(
&self,
signal_id: SignalId,
args: &[&dyn ToValue ]
) -> Result<R, BoolError> where
R: TryFromClosureReturnValue,

pub fn emit<R>(&self, signal_id: SignalId, args: &[&dyn ToValue ]) -> R where
R: TryFromClosureReturnValue,

pub fn try_emit_with_values(
&self,
signal_id: SignalId,
args: &[Value ]
) -> Result<Option<Value>, BoolError>

pub fn emit_with_values(
&self,
signal_id: SignalId,
args: &[Value ]
) -> Option<Value>

pub fn try_emit_by_name<R>(
&self,
signal_name: &str,
args: &[&dyn ToValue ]
) -> Result<R, BoolError> where
R: TryFromClosureReturnValue,

pub fn emit_by_name<R>(&self, signal_name: &str, args: &[&dyn ToValue ]) -> R where
R: TryFromClosureReturnValue,

pub fn try_emit_by_name_with_values(
&self,
signal_name: &str,
args: &[Value ]
) -> Result<Option<Value>, BoolError>

pub fn emit_by_name_with_values(
&self,
signal_name: &str,
args: &[Value ]
) -> Option<Value>

pub fn try_emit_by_name_with_details<R>(
&self,
signal_name: &str,
details: Quark,
args: &[&dyn ToValue ]
) -> Result<R, BoolError> where
R: TryFromClosureReturnValue,

pub fn emit_by_name_with_details<R>(
&self,
signal_name: &str,
details: Quark,
args: &[&dyn ToValue ]
) -> R where
R: TryFromClosureReturnValue,

pub fn try_emit_by_name_with_details_and_values(
&self,
signal_name: &str,
details: Quark,
args: &[Value ]
) -> Result<Option<Value>, BoolError>

pub fn emit_by_name_with_details_and_values(
&self,
signal_name: &str,
details: Quark,
args: &[Value ]
) -> Option<Value>

pub fn try_emit_with_details<R>(
&self,
signal_id: SignalId,
details: Quark,
args: &[&dyn ToValue ]
) -> Result<R, BoolError> where
R: TryFromClosureReturnValue,

pub fn emit_with_details<R>(
&self,
signal_id: SignalId,
details: Quark,
args: &[&dyn ToValue ]
) -> R where
R: TryFromClosureReturnValue,

pub fn try_emit_with_details_and_values(
&self,
signal_id: SignalId,
details: Quark,
args: &[Value ]
) -> Result<Option<Value>, BoolError>

pub fn emit_with_details_and_values(
&self,
signal_id: SignalId,
details: Quark,
args: &[Value ]
) -> Option<Value>

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

pub fn connect_notify_local<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec),

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

pub fn bind_property<O>(
&'a self,
source_property: &'a str,
target: &'a O,
target_property: &'a str
) -> BindingBuilder<'a> where
O: ObjectType,