GESClip

GES.Clip

GObject.Object
    ╰──GObject.InitiallyUnowned
        ╰──GES.TimelineElement
            ╰──GES.Container
                ╰──GES.Clip
                    ╰──GES.OperationClip
                    ╰──GES.SourceClip

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.

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.

Since : 1.18

GES.Clip.prototype.add_top_effect

function GES.Clip.prototype.add_top_effect(effect: GES.BaseEffect, index: Number): {
    // javascript wrapper for 'ges_clip_add_top_effect'
}

Add a top effect to a clip at the given index.

Unlike using GES.Container.prototype.add, this allows you to set the index in advance. It will also check that no error occurred during the track selection for the effect.

Note, only subclasses of GES.ClipClass that have GES_CLIP_CLASS_CAN_ADD_EFFECTS (not introspectable) set to true (such as GES.SourceClip and GES.BaseEffectClip) can have additional top effects added.

Note, if the effect is a time effect, this may be refused if the clip would not be able to adapt itself once the effect is added.

Since : 1.18

GES.Clip.prototype.find_track_element

function GES.Clip.prototype.find_track_element(track: GES.Track, type: GObject.Type): {
    // 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.

GES.Clip.prototype.find_track_elements

function GES.Clip.prototype.find_track_elements(track: GES.Track, track_type: GES.TrackType, type: GObject.Type): {
    // 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 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, 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, 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.

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.

Since : 1.18

GES.Clip.prototype.get_internal_time_from_timeline_time

function GES.Clip.prototype.get_internal_time_from_timeline_time(child: GES.TrackElement, timeline_time: Number): {
    // javascript wrapper for 'ges_clip_get_internal_time_from_timeline_time'
}

Convert the timeline time to an internal source time of the child. This will take any time effects placed on the clip into account (see GES.BaseEffect for what time effects are supported, and how to declare them in GES).

When timeline_time is above the start of clip, this will return the internal time at which the content that appears at timeline_time in the output of the timeline is created in child. For example, if timeline_time corresponds to the current seek position, this would let you know which part of a media file is being read.

This will be done assuming the clip has an indefinite end, so the internal time may be beyond the current out-point of the child, or even its max-duration.

If, instead, timeline_time is below the current start of clip, this will return what you would need to set the in-point of child to if you set the start of clip to timeline_time and wanted to keep the content of child currently found at the current start of clip at the same timeline position. If this would be negative, the conversion fails. This is useful for determining what in-point would result from a GES.EditMode.EDIT_TRIM to timeline_time.

Note that whilst a clip has no time effects, this second return is equivalent to finding the internal time at which the content that appears at timeline_time in the timeline can be found in child if it had indefinite extent in both directions. However, with non-linear time effects this second return will be more distinct.

In either case, the returned time would be appropriate to use for the in-point or max-duration of the child.

See GES.Clip.prototype.get_timeline_time_from_internal_time, which performs the reverse.

Since : 1.18

GES.Clip.prototype.get_layer

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

Gets the layer of the 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.

GES.Clip.prototype.get_timeline_time_from_internal_time

function GES.Clip.prototype.get_timeline_time_from_internal_time(child: GES.TrackElement, internal_time: Number): {
    // javascript wrapper for 'ges_clip_get_timeline_time_from_internal_time'
}

Convert the internal source time from the child to a timeline time. This will take any time effects placed on the clip into account (see GES.BaseEffect for what time effects are supported, and how to declare them in GES).

When internal_time is above the in-point of child, this will return the timeline time at which the internal content found at internal_time appears in the output of the timeline's track. For example, this would let you know where in the timeline a particular scene in a media file would appear.

This will be done assuming the clip has an indefinite end, so the timeline time may be beyond the end of the clip, or even breaking its duration-limit.

If, instead, internal_time is below the current in-point of child, this will return what you would need to set the start of clip to if you set the in-point of child to internal_time and wanted to keep the content of child currently found at the current start of clip at the same timeline position. If this would be negative, the conversion fails. This is useful for determining what position to use in a GES.EditMode.EDIT_TRIM if you wish to trim to a specific point in the internal content, such as a particular scene in a media file.

Note that whilst a clip has no time effects, this second return is equivalent to finding the timeline time at which the content of child at internal_time would be found in the timeline if it had indefinite extent in both directions. However, with non-linear time effects this second return will be more distinct.

In either case, the returned time would be appropriate to use in GES.TimelineElement.prototype.edit for GES.EditMode.EDIT_TRIM, and similar, if you wish to use a particular internal point as a reference. For example, you could choose to end a clip at a certain internal 'out-point', similar to the in-point, by translating the desired end time into the timeline coordinates, and using this position to trim the end of a clip.

See GES.Clip.prototype.get_internal_time_from_timeline_time, which performs the reverse, or GES.Clip.prototype.get_timeline_time_from_source_frame which does the same conversion, but using frame numbers.

Since : 1.18

GES.Clip.prototype.get_timeline_time_from_source_frame

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

Convert the source frame number to a timeline time. This acts the same as GES.Clip.prototype.get_timeline_time_from_internal_time using the core children of the clip and using the frame number to specify the internal position, rather than a timestamp.

The returned timeline time can be used to seek or edit to a specific frame.

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

Since : 1.18

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.

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'
}

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.

GES.Clip.prototype.move_to_layer

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

See GES.Clip.prototype.move_to_layer_full, which also gives an error.

GES.Clip.prototype.move_to_layer_full

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

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.

Since : 1.18

GES.Clip.prototype.remove_top_effect

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

Remove a top effect from the clip.

Note, if the effect is a time effect, this may be refused if the clip would not be able to adapt itself once the effect is removed.

Since : 1.18

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.

GES.Clip.prototype.set_top_effect_index

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

See GES.Clip.prototype.set_top_effect_index_full, which also gives an error.

GES.Clip.prototype.set_top_effect_index_full

function GES.Clip.prototype.set_top_effect_index_full(effect: GES.BaseEffect, newindex: Number): {
    // javascript wrapper for 'ges_clip_set_top_effect_index_full'
}

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.

Since : 1.18

GES.Clip.prototype.set_top_effect_priority

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

GES.Clip.prototype.split

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

See GES.Clip.prototype.split_full, which also gives an error.

GES.Clip.prototype.split_full

function GES.Clip.prototype.split_full(position: Number): {
    // javascript wrapper for 'ges_clip_split_full'
}

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.

Since : 1.18

duration-limit

“duration-limit” Number

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.

Flags : Read

Since : 1.18

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

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

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, and GESClipClass::create_track_elements should be used instead. Otherwise, you should implement this class method and leave GESClipClass::create_track_elements as the default implementation

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 GESClipClass::create_track_element is implemented, this should be kept as the default implementation

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.

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.

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.

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