Struct gstreamer_editing_services::BaseEffect

source · [−]

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

Expand description

A BaseEffect is some operation that applies an effect to the data it receives.

Time Effects

Some operations will change the timing of the stream data they receive in some way. In particular, the gst::Element that they wrap could alter the times of the segment they receive in a gst::EventType::Segment event, or the times of a seek they receive in a gst::EventType::Seek event. Such operations would be considered time effects since they translate the times they receive on their source to different times at their sink, and vis versa. This introduces two sets of time coordinates for the event: (internal) sink coordinates and (internal) source coordinates, where segment times are translated from the sink coordinates to the source coordinates, and seek times are translated from the source coordinates to the sink coordinates.

If you use such an effect in GES, you will need to inform GES of the properties that control the timing with BaseEffectExt::register_time_property(), and the effect’s timing behaviour using ges_base_effect_set_time_translation_funcs().

Note that a time effect should not have its property::TrackElement::has-internal-source set to true.

In addition, note that GES only fully supports time effects whose mapping from the source to sink coordinates (those applied to seeks) obeys:

Maps the time 0 to 0. So initial time-shifting effects are excluded.
Is monotonically increasing. So reversing effects, and effects that jump backwards in the stream are excluded.
Can handle a reasonable GstClockTime, relative to the project. So this would exclude a time effect with an extremely large speed-up that would cause the converted GstClockTime seeks to overflow.
Is ‘continuously reversible’. This essentially means that for every time in the sink coordinates, we can, to ‘good enough’ accuracy, calculate the corresponding time in the source coordinates. Moreover, this should correspond to how segment times are translated from sink to source.
Only depends on the registered time properties, rather than the state of the gst::Element or the data it receives. This would exclude, say, an effect that would speedup if there is more red in the image it receives.

Note that a constant-rate-change effect that is not extremely fast or slow would satisfy these conditions. For such effects, you may wish to use ges_effect_class_register_rate_property().

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

Implements

BaseEffectExt, [OperationExt][trait@crate::prelude::OperationExt], TrackElementExt, TimelineElementExt, glib::ObjectExt, ExtractableExt, MetaContainerExt, [TimelineElementExtManual][trait@crate::prelude::TimelineElementExtManual]

Struct gstreamer_editing_services::BaseEffect

Time Effects

Implements

Implementations

impl BaseEffect

pub const NONE: Option<&'static BaseEffect>

Trait Implementations

impl Clone for BaseEffect

fn clone(&self) -> Self

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

impl Debug for BaseEffect

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

impl Hash for BaseEffect

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 BaseEffect

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 BaseEffect

type Parent = Operation

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

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

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

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

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 BaseEffect

fn static_type() -> Type

impl Eq for BaseEffect

impl IsA<BaseEffect> for Effect

impl IsA<Extractable> for BaseEffect

impl IsA<MetaContainer> for BaseEffect

impl IsA<Operation> for BaseEffect

impl IsA<TimelineElement> for BaseEffect

impl IsA<TrackElement> for BaseEffect

Auto Trait Implementations

impl RefUnwindSafe for BaseEffect

impl !Send for BaseEffect

impl !Sync for BaseEffect

impl Unpin for BaseEffect

impl UnwindSafe for BaseEffect

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<O> GObjectExtManualGst for O where O: IsA<Object>,

pub fn try_set_property_from_str( &self, name: &str, value: &str) -> Result<(), BoolError>

pub fn set_property_from_str(&self, name: &str, value: &str)

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,

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<O> GObjectExtManualGst for O where
O: IsA<Object>,

pub fn try_set_property_from_str(
&self,
name: &str,
value: &str
) -> Result<(), BoolError>

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),