Struct gstreamer_editing_services::Clip [−][src]
pub struct Clip(_);
Expand description
Clip-s are the core objects of a Layer. Each clip may exist in
a single layer but may control several TrackElement-s that span
several Track-s. A clip will ensure that all its children share the
same property::TimelineElement::start and property::TimelineElement::duration in
their tracks, which will match the property::TimelineElement::start and
property::TimelineElement::duration of the clip itself. Therefore, changing
the timing of the clip will change the timing of the children, and a
change in the timing of a child will change the timing of the clip and
subsequently all its siblings. As such, a clip can be treated as a
singular object in its layer.
For most uses of a Timeline, it is often sufficient to only
interact with Clip-s directly, which will take care of creating and
organising the elements of the timeline’s tracks.
Core Children
In more detail, clips will usually have some core TrackElement
children, which are created by the clip when it is added to a layer in
a timeline. The type and form of these core children will depend on the
clip’s subclass. You can use TrackElementExt::is_core() to determine
whether a track element is considered such a core track element. Note,
if a core track element is part of a clip, it will always be treated as
a core child of the clip. You can connect to the
signal::Container::child-added signal to be notified of their creation.
When a child is added to a clip, the timeline will select its tracks
using signal::Timeline::select-tracks-for-object. Note that it may be the
case that the child will still have no set property::TrackElement::track
after this process. For example, if the timeline does not have a track
of the corresponding property::Track::track-type. A clip can safely contain
such children, which may have their track set later, although they will
play no functioning role in the timeline in the meantime.
If a clip may create track elements with various
property::TrackElement::track-type(s), such as a UriClip, but you only
want it to create a subset of these types, you should set the
property::Clip::supported-formats of the clip to the subset of types. This
should be done before adding the clip to a layer.
If a clip will produce several core elements of the same
property::TrackElement::track-type, you should connect to the timeline’s
signal::Timeline::select-tracks-for-object signal to coordinate which
tracks each element should land in. Note, no two core children within a
clip can share the same Track, so you should not select the same
track for two separate core children. Provided you stick to this rule,
it is still safe to select several tracks for the same core child, the
core child will be copied into the additional tracks. You can manually
add the child to more tracks later using ClipExt::add_child_to_track().
If you do not wish to use a core child, you can always select no track.
The property::TimelineElement::in-point of the clip will control the
property::TimelineElement::in-point of its core children to be the same
value if their property::TrackElement::has-internal-source is set to true.
The property::TimelineElement::max-duration of the clip is the minimum
property::TimelineElement::max-duration of its core children. If you set its
value to anything other than its current value, this will also set the
property::TimelineElement::max-duration of all its core children to the same
value if their property::TrackElement::has-internal-source is set to true.
As a special case, whilst a clip does not yet have any core children,
its property::TimelineElement::max-duration may be set to indicate what its
value will be once they are created.
Effects
Some subclasses (GESSourceClip and GESBaseEffectClip) may also allow
their objects to have additional non-core BaseEffect-s elements as
children. These are additional effects that are applied to the output
data of the core elements. They can be added to the clip using
ClipExt::add_top_effect(), which will take care of adding the effect to
the timeline’s tracks. The new effect will be placed between the clip’s
core track elements and its other effects. As such, the newly added
effect will be applied to any source data before the other existing
effects. You can change the ordering of effects using
ClipExt::set_top_effect_index().
Tracks are selected for top effects in the same way as core children.
If you add a top effect to a clip before it is part of a timeline, and
later add the clip to a timeline, the track selection for the top
effects will occur just after the track selection for the core
children. If you add a top effect to a clip that is already part of a
timeline, the track selection will occur immediately. Since a top
effect must be applied on top of a core child, if you use
signal::Timeline::select-tracks-for-object, you should ensure that the
added effects are destined for a Track that already contains a core
child.
In addition, if the core child in the track is not
property::TrackElement::active, then neither can any of its effects be
property::TrackElement::active. Therefore, if a core child is made in-active,
all of the additional effects in the same track will also become
in-active. Similarly, if an effect is set to be active, then the core
child will also become active, but other effects will be left alone.
Finally, if an active effect is added to the track of an in-active core
child, it will become in-active as well. Note, in contrast, setting a
core child to be active, or an effect to be in-active will not change
the other children in the same track.
Time Effects
Some effects also change the timing of their data (see BaseEffect
for what counts as a time effect). Note that a GESBaseEffectClip will
refuse time effects, but a GESSource will allow them.
When added to a clip, time effects may adjust the timing of other
children in the same track. Similarly, when changing the order of
effects, making them (in)-active, setting their time property values
or removing time effects. These can cause the property::Clip::duration-limit
to change in value. However, if such an operation would ever cause the
property::TimelineElement::duration to shrink such that a clip’s GESSource is
totally overlapped in the timeline, the operation would be prevented.
Note that the same can happen when adding non-time effects with a
finite property::TimelineElement::max-duration.
Therefore, when working with time effects, you should – more so than
usual – not assume that setting the properties of the clip’s children
will succeed. In particular, you should use
TimelineElementExt::set_child_property_full() when setting the time
properties.
If you wish to preserve the internal duration of a source in a clip during these time effect operations, you can do something like the following.
void
do_time_effect_change (GESClip * clip)
{
GList *tmp, *children;
GESTrackElement *source;
GstClockTime source_outpoint;
GstClockTime new_end;
GError *error = NULL;
// choose some active source in a track to preserve the internal
// duration of
source = ges_clip_get_track_element (clip, NULL, GES_TYPE_SOURCE);
// note its current internal end time
source_outpoint = ges_clip_get_internal_time_from_timeline_time (
clip, source, GES_TIMELINE_ELEMENT_END (clip), NULL);
// handle invalid out-point
// stop the children's control sources from clamping when their
// out-point changes with a change in the time effects
children = ges_container_get_children (GES_CONTAINER (clip), FALSE);
for (tmp = children; tmp; tmp = tmp->next)
ges_track_element_set_auto_clamp_control_source (tmp->data, FALSE);
// add time effect, or set their children properties, or move them around
...
// user can make sure that if a time effect changes one source, we should
// also change the time effect for another source. E.g. if
// "GstVideorate::rate" is set to 2.0, we also set "GstPitch::rate" to
// 2.0
// Note the duration of the clip may have already changed if the
// duration-limit of the clip dropped below its current value
new_end = ges_clip_get_timeline_time_from_internal_time (
clip, source, source_outpoint, &error);
// handle error
if (!ges_timeline_elemnet_edit_full (GES_TIMELINE_ELEMENT (clip),
-1, GES_EDIT_MODE_TRIM, GES_EDGE_END, new_end, &error))
// handle error
for (tmp = children; tmp; tmp = tmp->next)
ges_track_element_set_auto_clamp_control_source (tmp->data, TRUE);
g_list_free_full (children, gst_object_unref);
gst_object_unref (source);
}
This is an Abstract Base Class, you cannot instantiate it.
Implements
ClipExt, GESContainerExt, TimelineElementExt, glib::ObjectExt, ExtractableExt, [TimelineElementExtManual][trait@crate::prelude::TimelineElementExtManual]
Trait Implementations
This method returns an ordering between self and other values if one exists. Read more
This method tests less than (for self and other) and is used by the < operator. Read more
This method tests less than or equal to (for self and other) and is used by the <=
operator. Read more
This method tests greater than (for self and other) and is used by the > operator. Read more
Returns the type identifier of Self.
Auto Trait Implementations
impl RefUnwindSafe for Clipimpl UnwindSafe for ClipBlanket Implementations
Mutably borrows from an owned value. Read more
Upcasts an object to a superclass or interface T. Read more
Upcasts an object to a reference of its superclass or interface T. Read more
Tries to downcast to a subclass or interface implementor T. Read more
Tries to downcast to a reference of its subclass or interface implementor T. Read more
Tries to cast to an object of type T. This handles upcasting, downcasting
and casting between interface and interface implementors. All checks are performed at
runtime, while downcast and upcast will do many checks at compile-time already. Read more
Tries to cast to reference to an object of type T. This handles upcasting, downcasting
and casting between interface and interface implementors. All checks are performed at
runtime, while downcast and upcast will do many checks at compile-time already. Read more
Casts to T unconditionally. Read more
Casts to &T unconditionally. Read more
Returns true if the object is an instance of (can be cast to) T.
pub fn set_properties(
&self,
property_values: &[(&str, &dyn ToValue)]
) -> Result<(), BoolError>[src]pub fn set_properties_from_value(
&self,
property_values: &[(&str, Value)]
) -> Result<(), BoolError>[src]pub fn set_property<'a, N, V>(
&self,
property_name: N,
value: V
) -> Result<(), BoolError> where
V: ToValue,
N: Into<&'a str>, [src]pub fn set_property_from_value<'a, N>(
&self,
property_name: N,
value: &Value
) -> Result<(), BoolError> where
N: Into<&'a str>, [src]pub fn property<'a, N>(&self, property_name: N) -> Result<Value, BoolError> where
N: Into<&'a str>, [src]Safety Read more
Safety Read more
Safety Read more
Safety Read more
pub fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec) + Send + Sync, [src]pub fn connect_notify_local<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec), [src]pub unsafe fn connect_notify_unsafe<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec), [src]pub fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where
N: Into<&'a str>, [src]pub fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where
N: Into<&'a str>, [src]pub 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]Same as connect but takes a SignalId instead of a signal name.
pub 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]Same as connect_local but takes a SignalId instead of a signal name.
pub 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]Same as connect_unsafe but takes a SignalId instead of a signal name.
Emit signal by signal id.
Emit signal with details by signal id.
Emit signal by it’s name.
pub fn bind_property<'a, O, N, M>(
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
O: ObjectType,
N: Into<&'a str>,
M: Into<&'a str>, [src]Same as emit but takes Value for the arguments.
Same as emit_by_name but takes Value for the arguments.
Returns a SendValue clone of self.
impl<'a, T, C> FromValueOptional<'a> for T where
C: ValueTypeChecker<Error = ValueTypeMismatchOrNoneError>,
T: FromValue<'a, Checker = C>, [src]