Struct gstreamer_editing_services::Effect

pub struct Effect { /* private fields */ }

Any GStreamer filter can be used as effects in GES. The only restriction we have is that effects element should have a single sinkpad (which will be requested if necessary) and a single srcpad.

Note that gesaudiomixer and gescompositor can be used as effects even though they can have several sinkpads.

GES specific effects:

• gesvideoscale: GES implements a specific scaling bin that allows specifying where scaling will happen inside the chain of effects. By default scaling can happen either in the source (if the source doesn’t have a specific size, like videotestsrc or mixing has been disabled) or in the mixing element otherwise, when adding that element as an effect, GES guarantees that the scaling will happen in it. This can be useful for example if you want to crop the video before scaling or apply rounding corners to the video after scaling, etc…

Note: GES always adds converters (audioconvert ! audioresample ! audioconvert for audio effects and videoconvert for video effects) to make it simpler for end users.

Properties

bin-description

The description of the effect bin with a gst-launch-style pipeline description.

Example: “videobalance saturation=1.5 hue=+0.5”

Readable | Writeable | Construct Only

TrackElement

active

Whether the effect of the element should be applied in its track. If set to false, it will not be used in the output of the track.

Readable | Writeable

auto-clamp-control-sources

Whether the control sources on the element (see TrackElementExt::set_control_source()) will be automatically updated whenever the in-point or out-point of the element change in value.

See TrackElementExt::clamp_control_source() for how this is done per control source.

Default value: true

Readable | Writeable

has-internal-source

This property is used to determine whether the ‘internal time’ properties of the element have any meaning. In particular, unless this is set to true, the in-point and max-duration can not be set to any value other than the default 0 and GST_CLOCK_TIME_NONE, respectively.

If an element has some internal timed source gst::Element that it reads stream data from as part of its function in a Track, then you’ll likely want to set this to true to allow the in-point and max-duration to be set.

The default value is determined by the GESTrackElementClass default_has_internal_source class property. For most GESSourceClass-es, this will be true, with the exception of those that have a potentially static source, such as GESImageSourceClass and GESTitleSourceClass. Otherwise, this will usually be false.

For most Operation-s you will likely want to leave this set to false. The exception may be for an operation that reads some stream data from some private internal source as part of manipulating the input data from the usual linked upstream TrackElement.

For example, you may want to set this to true for a TrackType::VIDEO operation that wraps a textoverlay that reads from a subtitle file and places its text on top of the received video data. The in-point of the element would be used to shift the initial seek time on the textoverlay away from 0, and the max-duration could be set to reflect the time at which the subtitle file runs out of data.

Note that GES can not support track elements that have both internal content and manipulate the timing of their data streams (time effects).

Readable | Writeable

track

The track that this element belongs to, or None if it does not belong to a track.

Readable

track-type

The track type of the element, which determines the type of track the element can be added to (see track-type). This should correspond to the type of data that the element can produce or process.

Readable | Writeable | Construct

TimelineElement

duration

The duration that the element is in effect for in the timeline (a time difference in nanoseconds using the time coordinates of the timeline). For example, for a source element, this would determine for how long it should output its internal content for. For an operation element, this would determine for how long its effect should be applied to any source content.

Readable | Writeable

in-point

The initial offset to use internally when outputting content (in nanoseconds, but in the time coordinates of the internal content).

For example, for a VideoUriSource that references some media file, the “internal content” is the media file data, and the in-point would correspond to some timestamp in the media file. When playing the timeline, and when the element is first reached at timeline-time start, it will begin outputting the data from the timestamp in-point onwards, until it reaches the end of its duration in the timeline.

For elements that have no internal content, this should be kept as 0.

Readable | Writeable

max-duration

The full duration of internal content that is available (a time difference in nanoseconds using the time coordinates of the internal content).

This will act as a cap on the in-point of the element (which is in the same time coordinates), and will sometimes be used to limit the duration of the element in the timeline.

For example, for a VideoUriSource that references some media file, this would be the length of the media file.

For elements that have no internal content, or whose content is indefinite, this should be kept as GST_CLOCK_TIME_NONE.

Readable | Writeable | Construct

name

The name of the element. This should be unique within its timeline.

Readable | Writeable | Construct

parent

The parent container of the element.

Readable | Writeable

priority

The priority of the element.

Readable | Writeable

serialize

Whether the element should be serialized.

Readable | Writeable

start

The starting position of the element in the timeline (in nanoseconds and in the time coordinates of the timeline). For example, for a source element, this would determine the time at which it should start outputting its internal content. For an operation element, this would determine the time at which it should start applying its effect to any source content.

Readable | Writeable

timeline

The timeline that the element lies within.

Readable | Writeable

Implements

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

GLib type: GObject with reference counted clone semantics.

Implementations

impl Effect

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

pub fn new(bin_description: &str) -> Result<Effect, BoolError>

Creates a new Effect from the description of the bin. It should be possible to determine the type of the effect through the element ‘klass’ metadata of the GstElements that will be created. In that corner case, you should use: ges_asset_request (GES_TYPE_EFFECT, “audio your ! bin ! description”, NULL); and extract that asset to be in full control.

bin_description

The gst-launch like bin description of the effect

Returns

a newly created Effect, or None if something went wrong.

Trait Implementations

impl Clone for Effect

fn clone(&self) -> Self

Makes a clone of this shared reference.

This increments the strong reference count of the object. Dropping the object will decrement it again.

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

Performs copy-assignment from source.

impl Debug for Effect

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

Formats the value using the given formatter.

impl HasParamSpec for Effect

type ParamSpec = ParamSpecObject

type SetValue = Effect

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

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

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Effect

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

where H: Hasher,

Hashes the memory address of this object.

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 Ord for Effect

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

Comparison for two GObjects.

Compares the memory addresses of the provided objects.

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 Effect

type Parent = BaseEffect

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

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

Equality for two GObjects.

Two GObjects are equal if their memory addresses are equal.

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

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

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

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

Partial comparison for two GObjects.

Compares the memory addresses of the provided objects.

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl StaticType for Effect

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Effect

impl IsA<BaseEffect> for Effect

impl IsA<Extractable> for Effect

impl IsA<MetaContainer> for Effect

impl IsA<Operation> for Effect

impl IsA<TimelineElement> for Effect

impl IsA<TrackElement> for Effect