Struct gstreamer_editing_services::Clip

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

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 start and duration in their tracks, which will match the start and 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 child-added signal to be notified of their creation.

When a child is added to a clip, the timeline will select its tracks using select-tracks-for-object. Note that it may be the case that the child will still have no set track after this process. For example, if the timeline does not have a track of the corresponding 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 track-type(s), such as a UriClip, but you only want it to create a subset of these types, you should set the 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 track-type, you should connect to the timeline’s 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 in-point of the clip will control the in-point of its core children to be the same value if their has-internal-source is set to true.

The max-duration of the clip is the minimum max-duration of its core children. If you set its value to anything other than its current value, this will also set the max-duration of all its core children to the same value if their has-internal-source is set to true. As a special case, whilst a clip does not yet have any core children, its max-duration may be set to indicate what its value will be once they are created.

Effects

Some subclasses (SourceClip and BaseEffectClip) 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 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 active, then neither can any of its effects be 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 BaseEffectClip will refuse time effects, but a Source 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 duration-limit to change in value. However, if such an operation would ever cause the duration to shrink such that a clip’s Source 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 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.

⚠️ The following code is in c ⚠️

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.

Properties

duration-limit

The maximum duration that can be currently set for the clip, taking into account the in-point, max-duration, active, and track properties of its children, as well as any time effects. If there is no limit, this will be set to GST_CLOCK_TIME_NONE.

Note that whilst a clip has no children in any tracks, the limit will be unknown, and similarly set to GST_CLOCK_TIME_NONE.

If the duration-limit would ever go below the current duration of the clip due to a change in the above variables, its duration will be set to the new limit.

Readable

layer

The layer this clip lies in.

If you want to connect to this property’s notify signal, you should connect to it with g_signal_connect_after() since the signal emission may be stopped internally.

Readable

supported-formats

The TrackType-s that the clip supports, which it can create TrackElement-s for. Note that this can be a combination of TrackType flags to indicate support for several track-type elements.

Readable | Writeable | Construct

Container

height

The span of the container’s children’s priority values, which is the number of integers that lie between (inclusive) the minimum and maximum priorities found amongst the container’s children (maximum - minimum + 1).

Readable

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

ClipExt, GESContainerExt, TimelineElementExt, glib::ObjectExt, ExtractableExt, MetaContainerExt, [TimelineElementExtManual][trait@crate::prelude::TimelineElementExtManual]

Implementations

impl Clip

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

Trait Implementations

impl Clone for Clip

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Clip

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

Formats the value using the given formatter.

impl HasParamSpec for Clip

type ParamSpec = ParamSpecObject

type SetValue = Clip

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

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

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Clip

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

Feeds this value into the given Hasher.

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 Clip

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl ParentClassIs for Clip

type Parent = Container

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

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

This method tests for self and other values to be equal, and is used by ==.

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

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

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

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl StaticType for Clip

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Clip

impl IsA<Clip> for BaseEffectClip

impl IsA<Clip> for BaseTransitionClip

impl IsA<Clip> for EffectClip

impl IsA<Clip> for OperationClip

impl IsA<Clip> for OverlayClip

impl IsA<Clip> for SourceClip

impl IsA<Clip> for TestClip

impl IsA<Clip> for TextOverlayClip

impl IsA<Clip> for TitleClip

impl IsA<Clip> for TransitionClip

impl IsA<Clip> for UriClip

impl IsA<Container> for Clip

impl IsA<Extractable> for Clip

impl IsA<MetaContainer> for Clip

impl IsA<TimelineElement> for Clip