GESClip

GESClip-s are the core objects of a GESLayer. Each clip may exist in a single layer but may control several GESTrackElement-s that span several GESTrack-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 GESTimeline, it is often sufficient to only interact with GESClip-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* GESTrackElement 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 ges_track_element_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 GESUriClip, 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 GESTrack, 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 ges_clip_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 (#GESSourceClip and GESBaseEffect) may also allow their objects to have additional non-core GESBaseEffect-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 ges_container_add, 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 ges_clip_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 GESTrack 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.

GESClip

GObject
    ╰──GInitiallyUnowned
        ╰──GESTimelineElement
            ╰──GESContainer
                ╰──GESClip
                    ╰──GESOperationClip
                    ╰──GESSourceClip

Members

parent (GESContainer) –
No description available

Class structure

GESClipClass

Fields
ABI._ges_reserved (gpointer *) –
No description available
ABI.abi.can_add_effects (gboolean) –

Whether the user can add additional non-core GESBaseEffect-s to clips from this class, to be applied to the output data of the core elements.


GES.ClipClass


GES.ClipClass


GESClip

GObject
    ╰──GInitiallyUnowned
        ╰──GESTimelineElement
            ╰──GESContainer
                ╰──GESClip
                    ╰──GESOperationClip
                    ╰──GESSourceClip

Members

parent (GESContainer) –
No description available

GESClip

GObject
    ╰──GInitiallyUnowned
        ╰──GESTimelineElement
            ╰──GESContainer
                ╰──GESClip
                    ╰──GESOperationClip
                    ╰──GESSourceClip

Members

parent (GESContainer) –
No description available

Methods

ges_clip_add_asset

GESTrackElement *
ges_clip_add_asset (GESClip * clip,
                    GESAsset * asset)

Extracts a GESTrackElement from an asset and adds it to the clip. This can be used to add effects that derive from the asset to the clip, but this method is not intended to be used to create the core elements of the clip.

Parameters:

clip

A GESClip

asset

An asset with GES_TYPE_TRACK_ELEMENT as its extractable-type

Returns ( [transfer: none] [allow-none] ) –

The newly created element, or NULL if an error occurred.


GES.Clip.prototype.add_asset

function GES.Clip.prototype.add_asset(asset: GES.Asset): {
    // javascript wrapper for 'ges_clip_add_asset'
}

Extracts a GES.TrackElement from an asset and adds it to the clip. This can be used to add effects that derive from the asset to the clip, but this method is not intended to be used to create the core elements of the clip.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

Returns ( GES.TrackElement ) –

The newly created element, or NULL (not introspectable) if an error occurred.


GES.Clip.add_asset

def GES.Clip.add_asset (self, asset):
    #python wrapper for 'ges_clip_add_asset'

Extracts a GES.TrackElement from an asset and adds it to the clip. This can be used to add effects that derive from the asset to the clip, but this method is not intended to be used to create the core elements of the clip.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

Returns ( GES.TrackElement ) –

The newly created element, or NULL (not introspectable) if an error occurred.


ges_clip_add_child_to_track

GESTrackElement *
ges_clip_add_child_to_track (GESClip * clip,
                             GESTrackElement * child,
                             GESTrack * track,
                             GError ** error)

Adds the track element child of the clip to a specific track.

If the given child is already in another track, this will create a copy of the child, add it to the clip, and add this copy to the track.

You should only call this whilst a clip is part of a GESTimeline, and for tracks that are in the same timeline.

This method is an alternative to using the select-tracks-for-object signal, but can be used to complement it when, say, you wish to copy a clip's children from one track into a new one.

When the child is a core child, it must be added to a track that does not already contain another core child of the same clip. If it is not a core child (an additional effect), then it must be added to a track that already contains one of the core children of the same clip.

This method can also fail if the adding the track element to the track would break a configuration rule of the corresponding GESTimeline, such as causing three sources to overlap at a single time, or causing a source to completely overlap another in the same track.

Note that err will not always be set upon failure.

Parameters:

clip

A GESClip

child

A child of clip

track

The track to add child to

error
No description available
Returns ( [transfer: none] ) –

The element that was added to track, either child or a copy of child, or NULL if the element could not be added.


GES.Clip.prototype.add_child_to_track

function GES.Clip.prototype.add_child_to_track(child: GES.TrackElement, track: GES.Track): {
    // javascript wrapper for 'ges_clip_add_child_to_track'
}

Adds the track element child of the clip to a specific track.

If the given child is already in another track, this will create a copy of the child, add it to the clip, and add this copy to the track.

You should only call this whilst a clip is part of a GES.Timeline, and for tracks that are in the same timeline.

This method is an alternative to using the select-tracks-for-object signal, but can be used to complement it when, say, you wish to copy a clip's children from one track into a new one.

When the child is a core child, it must be added to a track that does not already contain another core child of the same clip. If it is not a core child (an additional effect), then it must be added to a track that already contains one of the core children of the same clip.

This method can also fail if the adding the track element to the track would break a configuration rule of the corresponding GES.Timeline, such as causing three sources to overlap at a single time, or causing a source to completely overlap another in the same track.

Note that err will not always be set upon failure.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

child ( GES.TrackElement ) –

A child of clip

track ( GES.Track ) –

The track to add child to

Returns ( GES.TrackElement ) –

The element that was added to track, either child or a copy of child, or NULL (not introspectable) if the element could not be added.


GES.Clip.add_child_to_track

@raises(GLib.GError)
def GES.Clip.add_child_to_track (self, child, track):
    #python wrapper for 'ges_clip_add_child_to_track'

Adds the track element child of the clip to a specific track.

If the given child is already in another track, this will create a copy of the child, add it to the clip, and add this copy to the track.

You should only call this whilst a clip is part of a GES.Timeline, and for tracks that are in the same timeline.

This method is an alternative to using the select-tracks-for-object signal, but can be used to complement it when, say, you wish to copy a clip's children from one track into a new one.

When the child is a core child, it must be added to a track that does not already contain another core child of the same clip. If it is not a core child (an additional effect), then it must be added to a track that already contains one of the core children of the same clip.

This method can also fail if the adding the track element to the track would break a configuration rule of the corresponding GES.Timeline, such as causing three sources to overlap at a single time, or causing a source to completely overlap another in the same track.

Note that err will not always be set upon failure.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

child ( GES.TrackElement ) –

A child of clip

track ( GES.Track ) –

The track to add child to

Returns ( GES.TrackElement ) –

The element that was added to track, either child or a copy of child, or NULL (not introspectable) if the element could not be added.


ges_clip_find_track_element

GESTrackElement *
ges_clip_find_track_element (GESClip * clip,
                             GESTrack * track,
                             GType type)

Finds an element controlled by the clip. If track is given, then only the track elements in track are searched for. If type is given, then this function searches for a track element of the given type.

Note, if multiple track elements in the clip match the given criteria, this will return the element amongst them with the highest priority (numerically, the smallest). See ges_clip_find_track_elements if you wish to find all such elements.

Parameters:

clip

A GESClip

track ( [allow-none] ) –

The track to search in, or NULL to search in all tracks

type

The type of track element to search for, or G_TYPE_NONE to match any type

Returns ( [transfer: full] [nullable] ) –

The element controlled by clip, in track, and of the given type, or NULL if no such element could be found.


GES.Clip.prototype.find_track_element

function GES.Clip.prototype.find_track_element(track: GES.Track, type: GType): {
    // javascript wrapper for 'ges_clip_find_track_element'
}

Finds an element controlled by the clip. If track is given, then only the track elements in track are searched for. If type is given, then this function searches for a track element of the given type.

Note, if multiple track elements in the clip match the given criteria, this will return the element amongst them with the highest priority (numerically, the smallest). See GES.Clip.prototype.find_track_elements if you wish to find all such elements.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

track ( GES.Track ) –

The track to search in, or NULL (not introspectable) to search in all tracks

type ( GType ) –

The type of track element to search for, or G_TYPE_NONE to match any type

Returns ( GES.TrackElement ) –

The element controlled by clip, in track, and of the given type, or NULL (not introspectable) if no such element could be found.


GES.Clip.find_track_element

def GES.Clip.find_track_element (self, track, type):
    #python wrapper for 'ges_clip_find_track_element'

Finds an element controlled by the clip. If track is given, then only the track elements in track are searched for. If type is given, then this function searches for a track element of the given type.

Note, if multiple track elements in the clip match the given criteria, this will return the element amongst them with the highest priority (numerically, the smallest). See GES.Clip.find_track_elements if you wish to find all such elements.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

track ( GES.Track ) –

The track to search in, or NULL (not introspectable) to search in all tracks

type ( GType ) –

The type of track element to search for, or G_TYPE_NONE to match any type

Returns ( GES.TrackElement ) –

The element controlled by clip, in track, and of the given type, or NULL (not introspectable) if no such element could be found.


ges_clip_find_track_elements

GList *
ges_clip_find_track_elements (GESClip * clip,
                              GESTrack * track,
                              GESTrackType track_type,
                              GType type)

Finds the GESTrackElement-s controlled by the clip that match the given criteria. If track is given as NULL and track_type is given as GES_TRACK_TYPE_UNKNOWN, then the search will match all elements in any track, including those with no track, and of any track-type. Otherwise, if track is not NULL, but track_type is GES_TRACK_TYPE_UNKNOWN, then only the track elements in track are searched for. Otherwise, if track_type is not GES_TRACK_TYPE_UNKNOWN, but track is NULL, then only the track elements whose track-type matches track_type are searched for. Otherwise, when both are given, the track elements that match either criteria are searched for. Therefore, if you wish to only find elements in a specific track, you should give the track as track, but you should not give the track's track-type as track_type because this would also select elements from other tracks of the same type.

You may also give type to further restrict the search to track elements of the given type.

Parameters:

clip

A GESClip

track ( [allow-none] ) –

The track to search in, or NULL to search in all tracks

track_type

The track-type of the track element to search for, or GES_TRACK_TYPE_UNKNOWN to match any track type

type

The type of track element to search for, or G_TYPE_NONE to match any type

Returns ( [transfer: full] [element-type GESTrackElement] ) –

A list of all the GESTrackElement-s controlled by clip, in track or of the given track_type, and of the given type.


GES.Clip.prototype.find_track_elements

function GES.Clip.prototype.find_track_elements(track: GES.Track, track_type: GES.TrackType, type: GType): {
    // javascript wrapper for 'ges_clip_find_track_elements'
}

Finds the GES.TrackElement-s controlled by the clip that match the given criteria. If track is given as NULL (not introspectable) and track_type is given as GES.TrackType.UNKNOWN, then the search will match all elements in any track, including those with no track, and of any track-type. Otherwise, if track is not NULL (not introspectable), but track_type is GES.TrackType.UNKNOWN, then only the track elements in track are searched for. Otherwise, if track_type is not GES.TrackType.UNKNOWN, but track is NULL (not introspectable), then only the track elements whose track-type matches track_type are searched for. Otherwise, when both are given, the track elements that match either criteria are searched for. Therefore, if you wish to only find elements in a specific track, you should give the track as track, but you should not give the track's track-type as track_type because this would also select elements from other tracks of the same type.

You may also give type to further restrict the search to track elements of the given type.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

track ( GES.Track ) –

The track to search in, or NULL (not introspectable) to search in all tracks

track_type ( GES.TrackType ) –

The track-type of the track element to search for, or GES.TrackType.UNKNOWN to match any track type

type ( GType ) –

The type of track element to search for, or G_TYPE_NONE (not introspectable) to match any type

Returns ( [ GES.TrackElement ] ) –

A list of all the GES.TrackElement-s controlled by clip, in track or of the given track_type, and of the given type.


GES.Clip.find_track_elements

def GES.Clip.find_track_elements (self, track, track_type, type):
    #python wrapper for 'ges_clip_find_track_elements'

Finds the GES.TrackElement-s controlled by the clip that match the given criteria. If track is given as NULL (not introspectable) and track_type is given as GES.TrackType.UNKNOWN, then the search will match all elements in any track, including those with no track, and of any track_type. Otherwise, if track is not NULL (not introspectable), but track_type is GES.TrackType.UNKNOWN, then only the track elements in track are searched for. Otherwise, if track_type is not GES.TrackType.UNKNOWN, but track is NULL (not introspectable), then only the track elements whose track_type matches track_type are searched for. Otherwise, when both are given, the track elements that match either criteria are searched for. Therefore, if you wish to only find elements in a specific track, you should give the track as track, but you should not give the track's track_type as track_type because this would also select elements from other tracks of the same type.

You may also give type to further restrict the search to track elements of the given type.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

track ( GES.Track ) –

The track to search in, or NULL (not introspectable) to search in all tracks

track_type ( GES.TrackType ) –

The track-type of the track element to search for, or GES.TrackType.UNKNOWN to match any track type

type ( GType ) –

The type of track element to search for, or G_TYPE_NONE (not introspectable) to match any type

Returns ( [ GES.TrackElement ] ) –

A list of all the GES.TrackElement-s controlled by clip, in track or of the given track_type, and of the given type.


ges_clip_get_duration_limit

GstClockTime
ges_clip_get_duration_limit (GESClip * clip)

Gets the duration-limit of the clip.

Parameters:

clip

A GESClip

Returns

The duration-limit of clip.


GES.Clip.prototype.get_duration_limit

function GES.Clip.prototype.get_duration_limit(): {
    // javascript wrapper for 'ges_clip_get_duration_limit'
}

Gets the duration-limit of the clip.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

Returns ( Gst.ClockTime ) –

The duration-limit of clip.


GES.Clip.get_duration_limit

def GES.Clip.get_duration_limit (self):
    #python wrapper for 'ges_clip_get_duration_limit'

Gets the duration_limit of the clip.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

Returns ( Gst.ClockTime ) –

The duration-limit of clip.


ges_clip_get_layer

GESLayer *
ges_clip_get_layer (GESClip * clip)

Gets the layer of the clip.

Parameters:

clip

A GESClip

Returns ( [transfer: full] [nullable] ) –

The layer clip is in, or NULL if clip is not in any layer.


GES.Clip.prototype.get_layer

function GES.Clip.prototype.get_layer(): {
    // javascript wrapper for 'ges_clip_get_layer'
}

Gets the layer of the clip.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

Returns ( GES.Layer ) –

The layer clip is in, or NULL (not introspectable) if clip is not in any layer.


GES.Clip.get_layer

def GES.Clip.get_layer (self):
    #python wrapper for 'ges_clip_get_layer'

Gets the layer of the clip.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

Returns ( GES.Layer ) –

The layer clip is in, or NULL (not introspectable) if clip is not in any layer.


ges_clip_get_supported_formats

GESTrackType
ges_clip_get_supported_formats (GESClip * clip)

Gets the supported-formats of the clip.

Parameters:

clip

A GESClip

Returns

The GESTrackType-s supported by clip.


GES.Clip.prototype.get_supported_formats

function GES.Clip.prototype.get_supported_formats(): {
    // javascript wrapper for 'ges_clip_get_supported_formats'
}

Gets the supported-formats of the clip.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

Returns ( GES.TrackType ) –

The GES.TrackType-s supported by clip.


GES.Clip.get_supported_formats

def GES.Clip.get_supported_formats (self):
    #python wrapper for 'ges_clip_get_supported_formats'

Gets the supported_formats of the clip.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

Returns ( GES.TrackType ) –

The GES.TrackType-s supported by clip.


ges_clip_get_timeline_time_from_source_frame

GstClockTime
ges_clip_get_timeline_time_from_source_frame (GESClip * clip,
                                              GESFrameNumber frame_number,
                                              GError ** error)

This method allows you to convert a frame number into a GstClockTime, this can be used to either seek to a particular frame in the timeline or to later on edit self with that timestamp.

This method should be use specifically in the case where you want to trim the clip to a particular frame.

The returned timestamp is in the global GESTimeline time coordinates of self, not in the internal time coordinates. In practice, this means that you can not use that time to set the clip in-point but it can be used in the timeline editing API, for example as the position argument of the ges_timeline_element_edit method.

Note that you can get the frame timestamp of a particular clip asset with ges_clip_asset_get_frame_time.

Parameters:

clip

A GESClip

frame_number

The frame number to get the corresponding timestamp in the timeline coordinates

error
No description available
Returns

The timestamp corresponding to frame_number in the element source in the timeline coordinates.


GES.Clip.prototype.get_timeline_time_from_source_frame

function GES.Clip.prototype.get_timeline_time_from_source_frame(frame_number: GES.FrameNumber): {
    // javascript wrapper for 'ges_clip_get_timeline_time_from_source_frame'
}

This method allows you to convert a frame number into a Gst.ClockTime, this can be used to either seek to a particular frame in the timeline or to later on edit self with that timestamp.

This method should be use specifically in the case where you want to trim the clip to a particular frame.

The returned timestamp is in the global GES.Timeline time coordinates of self, not in the internal time coordinates. In practice, this means that you can not use that time to set the clip in-point but it can be used in the timeline editing API, for example as the position argument of the GES.TimelineElement.prototype.edit method.

Note that you can get the frame timestamp of a particular clip asset with GES.ClipAsset.prototype.get_frame_time.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

frame_number ( GES.FrameNumber ) –

The frame number to get the corresponding timestamp in the timeline coordinates

Returns ( Gst.ClockTime ) –

The timestamp corresponding to frame_number in the element source in the timeline coordinates.


GES.Clip.get_timeline_time_from_source_frame

@raises(GLib.GError)
def GES.Clip.get_timeline_time_from_source_frame (self, frame_number):
    #python wrapper for 'ges_clip_get_timeline_time_from_source_frame'

This method allows you to convert a frame number into a Gst.ClockTime, this can be used to either seek to a particular frame in the timeline or to later on edit self with that timestamp.

This method should be use specifically in the case where you want to trim the clip to a particular frame.

The returned timestamp is in the global GES.Timeline time coordinates of self, not in the internal time coordinates. In practice, this means that you can not use that time to set the clip in_point but it can be used in the timeline editing API, for example as the position argument of the GES.TimelineElement.edit method.

Note that you can get the frame timestamp of a particular clip asset with GES.ClipAsset.get_frame_time.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

frame_number ( GES.FrameNumber ) –

The frame number to get the corresponding timestamp in the timeline coordinates

Returns ( Gst.ClockTime ) –

The timestamp corresponding to frame_number in the element source in the timeline coordinates.


ges_clip_get_top_effect_index

gint
ges_clip_get_top_effect_index (GESClip * clip,
                               GESBaseEffect * effect)

Gets the internal index of an effect in the clip. The index of effects in a clip will run from 0 to n-1, where n is the total number of effects. If two effects share the same track, the effect with the numerically lower index will be applied to the source data after the other effect, i.e. output data will always flow from a higher index effect to a lower index effect.

Parameters:

clip

A GESClip

effect

The effect we want to get the index of

Returns

The index of effect in clip, or -1 if something went wrong.


GES.Clip.prototype.get_top_effect_index

function GES.Clip.prototype.get_top_effect_index(effect: GES.BaseEffect): {
    // javascript wrapper for 'ges_clip_get_top_effect_index'
}

Gets the internal index of an effect in the clip. The index of effects in a clip will run from 0 to n-1, where n is the total number of effects. If two effects share the same track, the effect with the numerically lower index will be applied to the source data after the other effect, i.e. output data will always flow from a higher index effect to a lower index effect.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

effect ( GES.BaseEffect ) –

The effect we want to get the index of

Returns ( gint ) –

The index of effect in clip, or -1 if something went wrong.


GES.Clip.get_top_effect_index

def GES.Clip.get_top_effect_index (self, effect):
    #python wrapper for 'ges_clip_get_top_effect_index'

Gets the internal index of an effect in the clip. The index of effects in a clip will run from 0 to n-1, where n is the total number of effects. If two effects share the same track, the effect with the numerically lower index will be applied to the source data after the other effect, i.e. output data will always flow from a higher index effect to a lower index effect.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

effect ( GES.BaseEffect ) –

The effect we want to get the index of

Returns ( gint ) –

The index of effect in clip, or -1 if something went wrong.


ges_clip_get_top_effect_position

gint
ges_clip_get_top_effect_position (GESClip * clip,
                                  GESBaseEffect * effect)

Parameters:

clip
No description available
effect
No description available
Returns
No description available

GES.Clip.prototype.get_top_effect_position

function GES.Clip.prototype.get_top_effect_position(effect: GES.BaseEffect): {
    // javascript wrapper for 'ges_clip_get_top_effect_position'
}

Parameters:

clip ( GES.Clip ) –
No description available
effect ( GES.BaseEffect ) –
No description available
Returns ( gint ) –
No description available

GES.Clip.get_top_effect_position

def GES.Clip.get_top_effect_position (self, effect):
    #python wrapper for 'ges_clip_get_top_effect_position'

Parameters:

clip ( GES.Clip ) –
No description available
effect ( GES.BaseEffect ) –
No description available
Returns ( gint ) –
No description available

ges_clip_get_top_effects

GList *
ges_clip_get_top_effects (GESClip * clip)

Gets the GESBaseEffect-s that have been added to the clip. The returned list is ordered by their internal index in the clip. See ges_clip_get_top_effect_index.

Parameters:

clip

A GESClip

Returns ( [transfer: full] [element-type GESTrackElement] ) –

A list of all GESBaseEffect-s that have been added to clip.


GES.Clip.prototype.get_top_effects

function GES.Clip.prototype.get_top_effects(): {
    // javascript wrapper for 'ges_clip_get_top_effects'
}

Gets the GES.BaseEffect-s that have been added to the clip. The returned list is ordered by their internal index in the clip. See GES.Clip.prototype.get_top_effect_index.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

Returns ( [ GES.TrackElement ] ) –

A list of all GES.BaseEffect-s that have been added to clip.


GES.Clip.get_top_effects

def GES.Clip.get_top_effects (self):
    #python wrapper for 'ges_clip_get_top_effects'

Gets the GES.BaseEffect-s that have been added to the clip. The returned list is ordered by their internal index in the clip. See GES.Clip.get_top_effect_index.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

Returns ( [ GES.TrackElement ] ) –

A list of all GES.BaseEffect-s that have been added to clip.


ges_clip_move_to_layer

gboolean
ges_clip_move_to_layer (GESClip * clip,
                        GESLayer * layer)

Moves a clip to a new layer. If the clip already exists in a layer, it is first removed from its current layer before being added to the new layer.

Parameters:

clip

A GESClip

layer

The new layer

Returns

TRUE if clip was successfully moved to layer.


GES.Clip.prototype.move_to_layer

function GES.Clip.prototype.move_to_layer(layer: GES.Layer): {
    // javascript wrapper for 'ges_clip_move_to_layer'
}

Moves a clip to a new layer. If the clip already exists in a layer, it is first removed from its current layer before being added to the new layer.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

layer ( GES.Layer ) –

The new layer

Returns ( gboolean ) –

TRUE (not introspectable) if clip was successfully moved to layer.


GES.Clip.move_to_layer

def GES.Clip.move_to_layer (self, layer):
    #python wrapper for 'ges_clip_move_to_layer'

Moves a clip to a new layer. If the clip already exists in a layer, it is first removed from its current layer before being added to the new layer.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

layer ( GES.Layer ) –

The new layer

Returns ( gboolean ) –

TRUE (not introspectable) if clip was successfully moved to layer.


ges_clip_set_supported_formats

ges_clip_set_supported_formats (GESClip * clip,
                                GESTrackType supportedformats)

Sets the supported-formats of the clip. This should normally only be called by subclasses, which should be responsible for updating its value, rather than the user.

Parameters:

clip

A GESClip

supportedformats

The GESTrackType-s supported by clip


GES.Clip.prototype.set_supported_formats

function GES.Clip.prototype.set_supported_formats(supportedformats: GES.TrackType): {
    // javascript wrapper for 'ges_clip_set_supported_formats'
}

Sets the supported-formats of the clip. This should normally only be called by subclasses, which should be responsible for updating its value, rather than the user.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

supportedformats ( GES.TrackType ) –

The GES.TrackType-s supported by clip


GES.Clip.set_supported_formats

def GES.Clip.set_supported_formats (self, supportedformats):
    #python wrapper for 'ges_clip_set_supported_formats'

Sets the supported_formats of the clip. This should normally only be called by subclasses, which should be responsible for updating its value, rather than the user.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

supportedformats ( GES.TrackType ) –

The GES.TrackType-s supported by clip


ges_clip_set_top_effect_index

gboolean
ges_clip_set_top_effect_index (GESClip * clip,
                               GESBaseEffect * effect,
                               guint newindex)

Set the index of an effect within the clip. See ges_clip_get_top_effect_index. The new index must be an existing index of the clip. The effect is moved to the new index, and the other effects may be shifted in index accordingly to otherwise maintain the ordering.

Parameters:

clip

A GESClip

effect

An effect within clip to move

newindex

The index for effect in clip

Returns

TRUE if effect was successfully moved to newindex.


GES.Clip.prototype.set_top_effect_index

function GES.Clip.prototype.set_top_effect_index(effect: GES.BaseEffect, newindex: guint): {
    // javascript wrapper for 'ges_clip_set_top_effect_index'
}

Set the index of an effect within the clip. See GES.Clip.prototype.get_top_effect_index. The new index must be an existing index of the clip. The effect is moved to the new index, and the other effects may be shifted in index accordingly to otherwise maintain the ordering.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

effect ( GES.BaseEffect ) –

An effect within clip to move

newindex ( guint ) –

The index for effect in clip

Returns ( gboolean ) –

TRUE (not introspectable) if effect was successfully moved to newindex.


GES.Clip.set_top_effect_index

def GES.Clip.set_top_effect_index (self, effect, newindex):
    #python wrapper for 'ges_clip_set_top_effect_index'

Set the index of an effect within the clip. See GES.Clip.get_top_effect_index. The new index must be an existing index of the clip. The effect is moved to the new index, and the other effects may be shifted in index accordingly to otherwise maintain the ordering.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

effect ( GES.BaseEffect ) –

An effect within clip to move

newindex ( guint ) –

The index for effect in clip

Returns ( gboolean ) –

TRUE (not introspectable) if effect was successfully moved to newindex.


ges_clip_set_top_effect_priority

gboolean
ges_clip_set_top_effect_priority (GESClip * clip,
                                  GESBaseEffect * effect,
                                  guint newpriority)

Parameters:

clip
No description available
effect
No description available
newpriority
No description available
Returns
No description available

GES.Clip.prototype.set_top_effect_priority

function GES.Clip.prototype.set_top_effect_priority(effect: GES.BaseEffect, newpriority: guint): {
    // javascript wrapper for 'ges_clip_set_top_effect_priority'
}

Parameters:

clip ( GES.Clip ) –
No description available
effect ( GES.BaseEffect ) –
No description available
newpriority ( guint ) –
No description available
Returns ( gboolean ) –
No description available

GES.Clip.set_top_effect_priority

def GES.Clip.set_top_effect_priority (self, effect, newpriority):
    #python wrapper for 'ges_clip_set_top_effect_priority'

Parameters:

clip ( GES.Clip ) –
No description available
effect ( GES.BaseEffect ) –
No description available
newpriority ( guint ) –
No description available
Returns ( gboolean ) –
No description available

ges_clip_split

GESClip *
ges_clip_split (GESClip * clip,
                guint64 position)

Splits a clip at the given timeline position into two clips. The clip must already have a layer.

The original clip's duration is reduced such that its end point matches the split position. Then a new clip is created in the same layer, whose start matches the split position and duration will be set such that its end point matches the old end point of the original clip. Thus, the two clips together will occupy the same positions in the timeline as the original clip did.

The children of the new clip will be new copies of the original clip's children, so it will share the same sources and use the same operations.

The new clip will also have its in-point set so that any internal data will appear in the timeline at the same time. Thus, when the timeline is played, the playback of data should appear the same. This may be complicated by any additional GESEffect-s that have been placed on the original clip that depend on the playback time or change the data consumption rate of sources. This method will attempt to translate these effects such that the playback appears the same. In such complex situations, you may get a better result if you place the clip in a separate sub GESProject, which only contains this clip (and its effects), and in the original layer create two neighbouring GESUriClip-s that reference this sub-project, but at a different in-point.

Parameters:

clip

The GESClip to split

position

The timeline position at which to perform the split

Returns ( [transfer: none] [nullable] ) –

The newly created clip resulting from the splitting clip, or NULL if clip can't be split.


GES.Clip.prototype.split

function GES.Clip.prototype.split(position: guint64): {
    // javascript wrapper for 'ges_clip_split'
}

Splits a clip at the given timeline position into two clips. The clip must already have a layer.

The original clip's duration is reduced such that its end point matches the split position. Then a new clip is created in the same layer, whose start matches the split position and duration will be set such that its end point matches the old end point of the original clip. Thus, the two clips together will occupy the same positions in the timeline as the original clip did.

The children of the new clip will be new copies of the original clip's children, so it will share the same sources and use the same operations.

The new clip will also have its in-point set so that any internal data will appear in the timeline at the same time. Thus, when the timeline is played, the playback of data should appear the same. This may be complicated by any additional GES.Effect-s that have been placed on the original clip that depend on the playback time or change the data consumption rate of sources. This method will attempt to translate these effects such that the playback appears the same. In such complex situations, you may get a better result if you place the clip in a separate sub GES.Project, which only contains this clip (and its effects), and in the original layer create two neighbouring GES.UriClip-s that reference this sub-project, but at a different in-point.

Parameters:

clip ( GES.Clip ) –

The GES.Clip to split

position ( guint64 ) –

The timeline position at which to perform the split

Returns ( GES.Clip ) –

The newly created clip resulting from the splitting clip, or NULL (not introspectable) if clip can't be split.


GES.Clip.split

def GES.Clip.split (self, position):
    #python wrapper for 'ges_clip_split'

Splits a clip at the given timeline position into two clips. The clip must already have a layer.

The original clip's duration is reduced such that its end point matches the split position. Then a new clip is created in the same layer, whose start matches the split position and duration will be set such that its end point matches the old end point of the original clip. Thus, the two clips together will occupy the same positions in the timeline as the original clip did.

The children of the new clip will be new copies of the original clip's children, so it will share the same sources and use the same operations.

The new clip will also have its in_point set so that any internal data will appear in the timeline at the same time. Thus, when the timeline is played, the playback of data should appear the same. This may be complicated by any additional GES.Effect-s that have been placed on the original clip that depend on the playback time or change the data consumption rate of sources. This method will attempt to translate these effects such that the playback appears the same. In such complex situations, you may get a better result if you place the clip in a separate sub GES.Project, which only contains this clip (and its effects), and in the original layer create two neighbouring GES.UriClip-s that reference this sub-project, but at a different in_point.

Parameters:

clip ( GES.Clip ) –

The GES.Clip to split

position ( guint64 ) –

The timeline position at which to perform the split

Returns ( GES.Clip ) –

The newly created clip resulting from the splitting clip, or NULL (not introspectable) if clip can't be split.


Properties

duration-limit

“duration-limit” guint64

The maximum duration that can be currently set for the clip, taking into account the in-point, max-duration, GESTrackElement:active, and track properties of its children. 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.

Flags : Read


duration-limit

“duration-limit” guint64

The maximum duration that can be currently set for the clip, taking into account the in-point, max-duration, GESTrackElement:active, and track properties of its children. 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.

Flags : Read


duration_limit

“self.props.duration_limit” guint64

The maximum duration that can be currently set for the clip, taking into account the in_point, max_duration, GESTrackElement:active, and track properties of its children. 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.

Flags : Read


layer

“layer” GESLayer *

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.

Flags : Read


layer

“layer” GES.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 (not introspectable) since the signal emission may be stopped internally.

Flags : Read


layer

“self.props.layer” GES.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 (not introspectable) since the signal emission may be stopped internally.

Flags : Read


supported-formats

“supported-formats” GESTrackType *

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

Flags : Read / Write / Construct


supported-formats

“supported-formats” GES.TrackType

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

Flags : Read / Write / Construct


supported_formats

“self.props.supported_formats” GES.TrackType

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

Flags : Read / Write / Construct


Virtual Methods

create_track_element

GESTrackElement *
create_track_element (GESClip * clip,
                      GESTrackType type)

Method to create the core GESTrackElement of a clip of this class. If a clip of this class may create several track elements per track type, this should be left as NULL, and create_track_elements should be used instead. Otherwise, you should implement this class method and leave create_track_elements as the default implementation

Parameters:

clip
No description available
type
No description available
Returns
No description available

vfunc_create_track_element

function vfunc_create_track_element(clip: GES.Clip, type: GES.TrackType): {
    // javascript implementation of the 'create_track_element' virtual method
}

Method to create the core GES.TrackElement of a clip of this class. If a clip of this class may create several track elements per track type, this should be left as NULL (not introspectable), and create_track_elements should be used instead. Otherwise, you should implement this class method and leave create_track_elements as the default implementation

Parameters:

clip ( GES.Clip ) –
No description available
type ( GES.TrackType ) –
No description available
Returns ( GES.TrackElement ) –
No description available

do_create_track_element

def do_create_track_element (clip, type):
    #python implementation of the 'create_track_element' virtual method

Method to create the core GES.TrackElement of a clip of this class. If a clip of this class may create several track elements per track type, this should be left as NULL (not introspectable), and create_track_elements should be used instead. Otherwise, you should implement this class method and leave create_track_elements as the default implementation

Parameters:

clip ( GES.Clip ) –
No description available
type ( GES.TrackType ) –
No description available
Returns ( GES.TrackElement ) –
No description available

create_track_elements

GList *
create_track_elements (GESClip * clip,
                       GESTrackType type)

Method to create the (multiple) core GESTrackElement-s of a clip of this class. If create_track_element is implemented, this should be kept as the default implementation

Parameters:

clip
No description available
type
No description available
Returns
No description available

vfunc_create_track_elements

function vfunc_create_track_elements(clip: GES.Clip, type: GES.TrackType): {
    // javascript implementation of the 'create_track_elements' virtual method
}

Method to create the (multiple) core GES.TrackElement-s of a clip of this class. If create_track_element is implemented, this should be kept as the default implementation

Parameters:

clip ( GES.Clip ) –
No description available
type ( GES.TrackType ) –
No description available
Returns ( [ GES.TrackElement ] ) –
No description available

do_create_track_elements

def do_create_track_elements (clip, type):
    #python implementation of the 'create_track_elements' virtual method

Method to create the (multiple) core GES.TrackElement-s of a clip of this class. If create_track_element is implemented, this should be kept as the default implementation

Parameters:

clip ( GES.Clip ) –
No description available
type ( GES.TrackType ) –
No description available
Returns ( [ GES.TrackElement ] ) –
No description available

Function Macros

GES_CLIP_CLASS_CAN_ADD_EFFECTS

#define GES_CLIP_CLASS_CAN_ADD_EFFECTS(klass) ((GES_CLIP_CLASS (klass))->ABI.abi.can_add_effects)

Whether the class allows for the user to add additional non-core GESBaseEffect-s to clips from this class.

Parameters:

klass

A GESClipClass


Constants

GES_TYPE_CLIP

#define GES_TYPE_CLIP             ges_clip_get_type()

Callbacks

GESCreateTrackElementFunc

GESTrackElement *
(*GESCreateTrackElementFunc) (GESClip * clip,
                              GESTrackType type)

A method for creating the core GESTrackElement of a clip, to be added to a GESTrack of the given track type.

If a clip may produce several track elements per track type, GESCreateTrackElementsFunc is more appropriate.

Parameters:

clip

A GESClip

type

A GESTrackType to create a GESTrackElement for

Returns ( [transfer: floating] [nullable] ) –

The GESTrackElement created by clip, or NULL if clip can not provide a track element for the given type or an error occurred.


GES.CreateTrackElementFunc

function GES.CreateTrackElementFunc(clip: GES.Clip, type: GES.TrackType): {
    // javascript wrapper for 'GESCreateTrackElementFunc'
}

A method for creating the core GES.TrackElement of a clip, to be added to a GES.Track of the given track type.

If a clip may produce several track elements per track type, GES.CreateTrackElementsFunc is more appropriate.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

type ( GES.TrackType ) –

A GES.TrackType to create a GES.TrackElement for

Returns ( GES.TrackElement ) –

The GES.TrackElement created by clip, or NULL (not introspectable) if clip can not provide a track element for the given type or an error occurred.


GES.CreateTrackElementFunc

def GES.CreateTrackElementFunc (clip, type):
    #python wrapper for 'GESCreateTrackElementFunc'

A method for creating the core GES.TrackElement of a clip, to be added to a GES.Track of the given track type.

If a clip may produce several track elements per track type, GES.CreateTrackElementsFunc is more appropriate.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

type ( GES.TrackType ) –

A GES.TrackType to create a GES.TrackElement for

Returns ( GES.TrackElement ) –

The GES.TrackElement created by clip, or NULL (not introspectable) if clip can not provide a track element for the given type or an error occurred.


GESCreateTrackElementsFunc

GList *
(*GESCreateTrackElementsFunc) (GESClip * clip,
                               GESTrackType type)

A method for creating the core GESTrackElement-s of a clip, to be added to GESTrack-s of the given track type.

Parameters:

clip

A GESClip

type

A GESTrackType to create GESTrackElement-s for

Returns ( [transfer: container] [element-type GESTrackElement] ) –

A list of the GESTrackElement-s created by clip for the given type, or NULL if no track elements are created or an error occurred.


GES.CreateTrackElementsFunc

function GES.CreateTrackElementsFunc(clip: GES.Clip, type: GES.TrackType): {
    // javascript wrapper for 'GESCreateTrackElementsFunc'
}

A method for creating the core GES.TrackElement-s of a clip, to be added to GES.Track-s of the given track type.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

type ( GES.TrackType ) –

A GES.TrackType to create GES.TrackElement-s for

Returns ( [ GES.TrackElement ] ) –

A list of the GES.TrackElement-s created by clip for the given type, or NULL (not introspectable) if no track elements are created or an error occurred.


GES.CreateTrackElementsFunc

def GES.CreateTrackElementsFunc (clip, type):
    #python wrapper for 'GESCreateTrackElementsFunc'

A method for creating the core GES.TrackElement-s of a clip, to be added to GES.Track-s of the given track type.

Parameters:

clip ( GES.Clip ) –

A GES.Clip

type ( GES.TrackType ) –

A GES.TrackType to create GES.TrackElement-s for

Returns ( [ GES.TrackElement ] ) –

A list of the GES.TrackElement-s created by clip for the given type, or NULL (not introspectable) if no track elements are created or an error occurred.


GESFillTrackElementFunc

gboolean
(*GESFillTrackElementFunc) (GESClip * clip,
                            GESTrackElement * track_element,
                            GstElement * nleobj)

A function that will be called when the nleobject of a corresponding track element needs to be filled.

The implementer of this function shall add the proper GstElement to nleobj using gst_bin_add.

Parameters:

clip

The GESClip controlling the track elements

track_element

The GESTrackElement

nleobj

The nleobject that needs to be filled

Returns

TRUE if the implementer successfully filled the nleobj.

deprecated : 1.18: This method type is no longer used.


GES.FillTrackElementFunc

function GES.FillTrackElementFunc(clip: GES.Clip, track_element: GES.TrackElement, nleobj: Gst.Element): {
    // javascript wrapper for 'GESFillTrackElementFunc'
}

A function that will be called when the nleobject of a corresponding track element needs to be filled.

The implementer of this function shall add the proper Gst.Element to nleobj using Gst.Bin.prototype.add.

Parameters:

clip ( GES.Clip ) –

The GES.Clip controlling the track elements

track_element ( GES.TrackElement ) –

The GES.TrackElement

nleobj ( Gst.Element ) –

The nleobject that needs to be filled

Returns ( gboolean ) –

TRUE (not introspectable) if the implementer successfully filled the nleobj.

deprecated : 1.18: This method type is no longer used.


GES.FillTrackElementFunc

def GES.FillTrackElementFunc (clip, track_element, nleobj):
    #python wrapper for 'GESFillTrackElementFunc'

A function that will be called when the nleobject of a corresponding track element needs to be filled.

The implementer of this function shall add the proper Gst.Element to nleobj using Gst.Bin.add.

Parameters:

clip ( GES.Clip ) –

The GES.Clip controlling the track elements

track_element ( GES.TrackElement ) –

The GES.TrackElement

nleobj ( Gst.Element ) –

The nleobject that needs to be filled

Returns ( gboolean ) –

TRUE (not introspectable) if the implementer successfully filled the nleobj.

deprecated : 1.18: This method type is no longer used.


Subpages:

GESUriClip – An object for manipulating media files in a GESTimeline

GESTitleClip – Render stand-alone titles in GESLayer.

GESTestClip – Render video and audio test patterns in a GESLayer

GESTimeOverlayClip – Source with a time overlay on top

GESEffectClip – An effect created by parse-launch style bin descriptions in a GESLayer

GESTransitionClip – Transition from one clip to another in a GESLayer

The results of the search are