/* GStreamer Editing Services * Copyright (C) 2009 Edward Hervey <edward.hervey@collabora.co.uk> * 2009 Nokia Corporation * 2011 Mathieu Duponchelle <mathieu.duponchelle@epitech.eu> * 2013 Thibault Saunier <thibault.saunier@collabora.com> * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ /** * SECTION:geslayer * @title: GESLayer * @short_description: Non-overlapping sequence of #GESClip * * #GESLayer-s are responsible for collecting and ordering #GESClip-s. * * A layer within a timeline will have an associated priority, * corresponding to their index within the timeline. A layer with the * index/priority 0 will have the highest priority and the layer with the * largest index will have the lowest priority (the order of priorities, * in this sense, is the _reverse_ of the numerical ordering of the * indices). ges_timeline_move_layer() should be used if you wish to * change how layers are prioritised in a timeline. * * Layers with higher priorities will have their content priorities * over content from lower priority layers, similar to how layers are * used in image editing. For example, if two separate layers both * display video content, then the layer with the higher priority will * have its images shown first. The other layer will only have its image * shown if the higher priority layer has no content at the given * playtime, or is transparent in some way. Audio content in separate * layers will simply play in addition. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "ges-internal.h" #include "ges-layer.h" #include "ges.h" #include "ges-source-clip.h" static void ges_meta_container_interface_init (GESMetaContainerInterface * iface); struct _GESLayerPrivate { /*< private > */ GList *clips_start; /* The Clips sorted by start and * priority */ guint32 priority; /* The priority of the layer within the * containing timeline */ gboolean auto_transition; GHashTable *tracks_activness; }; typedef struct { GESClip *clip; GESLayer *layer; } NewAssetUData; typedef struct { GESTrack *track; GESLayer *layer; gboolean active; gboolean track_disposed; } LayerActivnessData; static void _track_disposed_cb (LayerActivnessData * data, GObject * disposed_track) { data->track_disposed = TRUE; g_hash_table_remove (data->layer->priv->tracks_activness, data->track); } static void layer_activness_data_free (LayerActivnessData * data) { if (!data->track_disposed) g_object_weak_unref ((GObject *) data->track, (GWeakNotify) _track_disposed_cb, data); g_free (data); } static LayerActivnessData * layer_activness_data_new (GESTrack * track, GESLayer * layer, gboolean active) { LayerActivnessData *data = g_new0 (LayerActivnessData, 1); data->layer = layer; data->track = track; data->active = active; g_object_weak_ref (G_OBJECT (track), (GWeakNotify) _track_disposed_cb, data); return data; } enum { PROP_0, PROP_PRIORITY, PROP_AUTO_TRANSITION, PROP_LAST }; enum { OBJECT_ADDED, OBJECT_REMOVED, ACTIVE_CHANGED, LAST_SIGNAL }; static guint ges_layer_signals[LAST_SIGNAL] = { 0 }; G_DEFINE_TYPE_WITH_CODE (GESLayer, ges_layer, G_TYPE_INITIALLY_UNOWNED, G_ADD_PRIVATE (GESLayer) G_IMPLEMENT_INTERFACE (GES_TYPE_EXTRACTABLE, NULL) G_IMPLEMENT_INTERFACE (GES_TYPE_META_CONTAINER, ges_meta_container_interface_init)); /* GObject standard vmethods */ static void ges_layer_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { GESLayer *layer = GES_LAYER (object); switch (property_id) { case PROP_PRIORITY: g_value_set_uint (value, layer->priv->priority); break; case PROP_AUTO_TRANSITION: g_value_set_boolean (value, layer->priv->auto_transition); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } } static void ges_layer_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { GESLayer *layer = GES_LAYER (object); switch (property_id) { case PROP_PRIORITY: GST_FIXME ("Deprecated, use ges_timeline_move_layer instead"); layer_set_priority (layer, g_value_get_uint (value), FALSE); break; case PROP_AUTO_TRANSITION: ges_layer_set_auto_transition (layer, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } } static void ges_layer_dispose (GObject * object) { GESLayer *layer = GES_LAYER (object); GESLayerPrivate *priv = layer->priv; GST_DEBUG ("Disposing layer"); while (priv->clips_start) ges_layer_remove_clip (layer, (GESClip *) priv->clips_start->data); g_clear_pointer (&layer->priv->tracks_activness, g_hash_table_unref); G_OBJECT_CLASS (ges_layer_parent_class)->dispose (object); } static gboolean _register_metas (GESLayer * layer) { ges_meta_container_register_meta_float (GES_META_CONTAINER (layer), GES_META_READ_WRITE, GES_META_VOLUME, 1.0); return TRUE; } static void ges_meta_container_interface_init (GESMetaContainerInterface * iface) { } static void ges_layer_class_init (GESLayerClass * klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->get_property = ges_layer_get_property; object_class->set_property = ges_layer_set_property; object_class->dispose = ges_layer_dispose; /** * GESLayer:priority: * * The priority of the layer in the #GESTimeline. 0 is the highest * priority. Conceptually, a timeline is a stack of layers, * and the priority of the layer represents its position in the stack. Two * layers should not have the same priority within a given GESTimeline. * * Note that the timeline needs to be committed (with #ges_timeline_commit) * for the change to be taken into account. * * Deprecated:1.16.0: use #ges_timeline_move_layer instead. This deprecation means * that you will not need to handle layer priorities at all yourself, GES * will make sure there is never 'gaps' between layer priorities. */ g_object_class_install_property (object_class, PROP_PRIORITY, g_param_spec_uint ("priority", "Priority", "The priority of the layer", 0, G_MAXUINT, 0, G_PARAM_READWRITE)); /** * GESLayer:auto-transition: * * Whether to automatically create a #GESTransitionClip whenever two * #GESSource-s that both belong to a #GESClip in the layer overlap. * See #GESTimeline for what counts as an overlap. * * When a layer is added to a #GESTimeline, if this property is left as * %FALSE, but the timeline's #GESTimeline:auto-transition is %TRUE, it * will be set to %TRUE as well. */ g_object_class_install_property (object_class, PROP_AUTO_TRANSITION, g_param_spec_boolean ("auto-transition", "Auto-Transition", "whether the transitions are added", FALSE, G_PARAM_READWRITE)); /** * GESLayer::clip-added: * @layer: The #GESLayer * @clip: The clip that was added * * Will be emitted after the clip is added to the layer. */ ges_layer_signals[OBJECT_ADDED] = g_signal_new ("clip-added", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GESLayerClass, object_added), NULL, NULL, NULL, G_TYPE_NONE, 1, GES_TYPE_CLIP); /** * GESLayer::clip-removed: * @layer: The #GESLayer * @clip: The clip that was removed * * Will be emitted after the clip is removed from the layer. */ ges_layer_signals[OBJECT_REMOVED] = g_signal_new ("clip-removed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GESLayerClass, object_removed), NULL, NULL, NULL, G_TYPE_NONE, 1, GES_TYPE_CLIP); /** * GESLayer::active-changed: * @layer: The #GESLayer * @active: Whether @layer has been made active or de-active in the @tracks * @tracks: (element-type GESTrack) (transfer none): A list of #GESTrack * which have been activated or deactivated * * Will be emitted whenever the layer is activated or deactivated * for some #GESTrack. See ges_layer_set_active_for_tracks(). * * Since: 1.18 */ ges_layer_signals[ACTIVE_CHANGED] = g_signal_new ("active-changed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL, G_TYPE_NONE, 2, G_TYPE_BOOLEAN, G_TYPE_PTR_ARRAY); } static void ges_layer_init (GESLayer * self) { self->priv = ges_layer_get_instance_private (self); self->priv->priority = 0; self->priv->auto_transition = FALSE; self->min_nle_priority = MIN_NLE_PRIO; self->max_nle_priority = LAYER_HEIGHT + MIN_NLE_PRIO; self->priv->tracks_activness = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) layer_activness_data_free); _register_metas (self); } static gint ges_layer_resync_priorities_by_type (GESLayer * layer, gint starting_priority, GType type) { GstClockTime next_reset = 0; gint priority = starting_priority, max_priority = priority; GList *tmp; GESTimelineElement *element; layer->priv->clips_start = g_list_sort (layer->priv->clips_start, (GCompareFunc) element_start_compare); for (tmp = layer->priv->clips_start; tmp; tmp = tmp->next) { element = GES_TIMELINE_ELEMENT (tmp->data); if (GES_IS_TRANSITION_CLIP (element)) { /* Blindly set transitions priorities to 0 */ _set_priority0 (element, 0); continue; } else if (!g_type_is_a (G_OBJECT_TYPE (element), type)) continue; if (element->start > next_reset) { priority = starting_priority; next_reset = 0; } if (element->start + element->duration > next_reset) next_reset = element->start + element->duration; _set_priority0 (element, priority); priority = priority + GES_CONTAINER_HEIGHT (element); if (priority > max_priority) max_priority = priority; } return max_priority; } /** * ges_layer_resync_priorities: * @layer: The #GESLayer * * Resyncs the priorities of the clips controlled by @layer. */ gboolean ges_layer_resync_priorities (GESLayer * layer) { gint min_source_prios; g_return_val_if_fail (GES_IS_LAYER (layer), FALSE); GST_INFO_OBJECT (layer, "Resync priorities (prio: %d)", layer->priv->priority); min_source_prios = ges_layer_resync_priorities_by_type (layer, 1, GES_TYPE_OPERATION_CLIP); ges_layer_resync_priorities_by_type (layer, min_source_prios, GES_TYPE_SOURCE_CLIP); return TRUE; } void layer_set_priority (GESLayer * layer, guint priority, gboolean emit) { GST_DEBUG ("layer:%p, priority:%d", layer, priority); if (priority != layer->priv->priority) { layer->priv->priority = priority; layer->min_nle_priority = (priority * LAYER_HEIGHT) + MIN_NLE_PRIO; layer->max_nle_priority = ((priority + 1) * LAYER_HEIGHT) + MIN_NLE_PRIO; ges_layer_resync_priorities (layer); } if (emit) g_object_notify (G_OBJECT (layer), "priority"); } static void new_asset_cb (GESAsset * source, GAsyncResult * res, NewAssetUData * udata) { GError *error = NULL; GESAsset *asset = ges_asset_request_finish (res, &error); GST_DEBUG_OBJECT (udata->layer, "%" GST_PTR_FORMAT " Asset loaded, " "setting its asset", udata->clip); if (error) { GESProject *project = udata->layer->timeline ? GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE (udata->layer->timeline))) : NULL; if (project) { gchar *possible_id; possible_id = ges_project_try_updating_id (project, source, error); if (possible_id) { ges_asset_request_async (ges_asset_get_extractable_type (source), possible_id, NULL, (GAsyncReadyCallback) new_asset_cb, udata); g_free (possible_id); return; } } GST_ERROR ("Asset could not be created for uri %s, error: %s", ges_asset_get_id (asset), error->message); } else { GESProject *project = udata->layer->timeline ? GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE (udata->layer->timeline))) : NULL; ges_extractable_set_asset (GES_EXTRACTABLE (udata->clip), asset); ges_project_add_asset (project, asset); /* clip was already ref-sinked when creating udata, * gst_layer_add_clip() creates a new ref as such and * below we unref the ref from udata */ ges_layer_add_clip (udata->layer, udata->clip); } gst_object_unref (asset); gst_object_unref (udata->clip); g_free (udata); } /** * ges_layer_get_duration: * @layer: The layer to get the duration from * * Retrieves the duration of the layer, which is the difference * between the start of the layer (always time 0) and the end (which will * be the end time of the final clip). * * Returns: The duration of @layer. */ GstClockTime ges_layer_get_duration (GESLayer * layer) { GList *tmp; GstClockTime duration = 0; g_return_val_if_fail (GES_IS_LAYER (layer), 0); for (tmp = layer->priv->clips_start; tmp; tmp = tmp->next) { duration = MAX (duration, _END (tmp->data)); } return duration; } static gboolean ges_layer_remove_clip_internal (GESLayer * layer, GESClip * clip, gboolean emit_removed) { GESLayer *current_layer; GList *tmp; GESTimeline *timeline = layer->timeline; GST_DEBUG ("layer:%p, clip:%p", layer, clip); current_layer = ges_clip_get_layer (clip); if (G_UNLIKELY (current_layer != layer)) { GST_WARNING ("Clip doesn't belong to this layer"); if (current_layer != NULL) gst_object_unref (current_layer); return FALSE; } gst_object_unref (current_layer); /* Remove it from our list of controlled objects */ layer->priv->clips_start = g_list_remove (layer->priv->clips_start, clip); if (emit_removed) { /* emit 'clip-removed' */ g_signal_emit (layer, ges_layer_signals[OBJECT_REMOVED], 0, clip); } /* inform the clip it's no longer in a layer */ ges_clip_set_layer (clip, NULL); /* so neither in a timeline */ if (timeline) ges_timeline_remove_clip (timeline, clip); for (tmp = GES_CONTAINER_CHILDREN (clip); tmp; tmp = tmp->next) ges_track_element_set_layer_active (tmp->data, TRUE); /* Remove our reference to the clip */ gst_object_unref (clip); return TRUE; } /* Public methods */ /** * ges_layer_remove_clip: * @layer: The #GESLayer * @clip: The clip to remove * * Removes the given clip from the layer. * * Returns: %TRUE if @clip was removed from @layer, or %FALSE if the * operation failed. */ gboolean ges_layer_remove_clip (GESLayer * layer, GESClip * clip) { g_return_val_if_fail (GES_IS_LAYER (layer), FALSE); g_return_val_if_fail (GES_IS_CLIP (clip), FALSE); return ges_layer_remove_clip_internal (layer, clip, TRUE); } /** * ges_layer_set_priority: * @layer: The #GESLayer * @priority: The priority to set * * Sets the layer to the given priority. See #GESLayer:priority. * * Deprecated:1.16.0: use #ges_timeline_move_layer instead. This deprecation means * that you will not need to handle layer priorities at all yourself, GES * will make sure there is never 'gaps' between layer priorities. */ void ges_layer_set_priority (GESLayer * layer, guint priority) { g_return_if_fail (GES_IS_LAYER (layer)); GST_FIXME ("Deprecated, use ges_timeline_move_layer instead"); layer_set_priority (layer, priority, TRUE); } /** * ges_layer_get_auto_transition: * @layer: The #GESLayer * * Gets the #GESLayer:auto-transition of the layer. * * Returns: %TRUE if transitions are automatically added to @layer. */ gboolean ges_layer_get_auto_transition (GESLayer * layer) { g_return_val_if_fail (GES_IS_LAYER (layer), 0); return layer->priv->auto_transition; } /** * ges_layer_set_auto_transition: * @layer: The #GESLayer * @auto_transition: Whether transitions should be automatically added to * the layer * * Sets #GESLayer:auto-transition for the layer. Use * ges_timeline_set_auto_transition() if you want all layers within a * #GESTimeline to have #GESLayer:auto-transition set to %TRUE. Use this * method if you want different values for different layers (and make sure * to keep #GESTimeline:auto-transition as %FALSE for the corresponding * timeline). */ void ges_layer_set_auto_transition (GESLayer * layer, gboolean auto_transition) { g_return_if_fail (GES_IS_LAYER (layer)); if (layer->priv->auto_transition == auto_transition) return; layer->priv->auto_transition = auto_transition; g_object_notify (G_OBJECT (layer), "auto-transition"); } /** * ges_layer_get_priority: * @layer: The #GESLayer * * Get the priority of the layer. When inside a timeline, this is its * index in the timeline. See ges_timeline_move_layer(). * * Returns: The priority of @layer within its timeline. */ guint ges_layer_get_priority (GESLayer * layer) { g_return_val_if_fail (GES_IS_LAYER (layer), 0); return layer->priv->priority; } /** * ges_layer_get_clips: * @layer: The #GESLayer * * Get the #GESClip-s contained in this layer. * * Returns: (transfer full) (element-type GESClip): A list of clips in * @layer. */ GList * ges_layer_get_clips (GESLayer * layer) { GESLayerClass *klass; g_return_val_if_fail (GES_IS_LAYER (layer), NULL); klass = GES_LAYER_GET_CLASS (layer); if (klass->get_objects) { return klass->get_objects (layer); } return g_list_sort (g_list_copy_deep (layer->priv->clips_start, (GCopyFunc) gst_object_ref, NULL), (GCompareFunc) element_start_compare); } /** * ges_layer_is_empty: * @layer: The #GESLayer to check * * Convenience method to check if the layer is empty (doesn't contain * any #GESClip), or not. * * Returns: %TRUE if @layer is empty, %FALSE if it contains at least * one clip. */ gboolean ges_layer_is_empty (GESLayer * layer) { g_return_val_if_fail (GES_IS_LAYER (layer), FALSE); return (layer->priv->clips_start == NULL); } /** * ges_layer_add_clip_full: * @layer: The #GESLayer * @clip: (transfer floating): The clip to add * @error: (nullable): Return location for an error * * Adds the given clip to the layer. If the method succeeds, the layer * will take ownership of the clip. * * This method will fail and return %FALSE if @clip already resides in * some layer. It can also fail if the additional clip breaks some * compositional rules (see #GESTimelineElement). * * Returns: %TRUE if @clip was properly added to @layer, or %FALSE * if @layer refused to add @clip. * Since: 1.18 */ gboolean ges_layer_add_clip_full (GESLayer * layer, GESClip * clip, GError ** error) { GList *tmp, *prev_children, *new_children; GESAsset *asset; GESLayerPrivate *priv; GESLayer *current_layer; GESTimeline *timeline; GESContainer *container; GError *timeline_error = NULL; g_return_val_if_fail (GES_IS_LAYER (layer), FALSE); g_return_val_if_fail (GES_IS_CLIP (clip), FALSE); g_return_val_if_fail (!error || !*error, FALSE); timeline = GES_TIMELINE_ELEMENT_TIMELINE (clip); container = GES_CONTAINER (clip); GST_DEBUG_OBJECT (layer, "adding clip:%p", clip); gst_object_ref_sink (clip); priv = layer->priv; current_layer = ges_clip_get_layer (clip); if (G_UNLIKELY (current_layer)) { GST_WARNING_OBJECT (layer, "Clip %" GES_FORMAT " already belongs to " "another layer", GES_ARGS (clip)); gst_object_unref (clip); gst_object_unref (current_layer); return FALSE; } if (timeline && timeline != layer->timeline) { /* if a clip is not in any layer, its timeline should not be set */ GST_ERROR_OBJECT (layer, "Clip %" GES_FORMAT " timeline %" GST_PTR_FORMAT " does not match that of the layer %" GST_PTR_FORMAT, GES_ARGS (clip), timeline, layer->timeline); gst_object_unref (clip); return FALSE; } timeline = layer->timeline; asset = ges_extractable_get_asset (GES_EXTRACTABLE (clip)); if (asset == NULL) { gchar *id; NewAssetUData *mudata = g_new (NewAssetUData, 1); mudata->clip = clip; mudata->layer = layer; GST_DEBUG_OBJECT (layer, "%" GST_PTR_FORMAT " as no reference to any " "assets creating a asset... trying sync", clip); id = ges_extractable_get_id (GES_EXTRACTABLE (clip)); asset = ges_asset_request (G_OBJECT_TYPE (clip), id, NULL); if (asset == NULL) { GESProject *project = layer->timeline ? GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE (layer->timeline))) : NULL; ges_asset_request_async (G_OBJECT_TYPE (clip), id, NULL, (GAsyncReadyCallback) new_asset_cb, mudata); if (project) ges_project_add_loading_asset (project, G_OBJECT_TYPE (clip), id); g_free (id); GST_LOG_OBJECT (layer, "Object added async"); return TRUE; } g_free (id); ges_extractable_set_asset (GES_EXTRACTABLE (clip), asset); g_free (mudata); gst_clear_object (&asset); } /* Take a reference to the clip and store it stored by start/priority */ priv->clips_start = g_list_insert_sorted (priv->clips_start, clip, (GCompareFunc) element_start_compare); /* Inform the clip it's now in this layer */ ges_clip_set_layer (clip, layer); GST_DEBUG ("current clip priority : %d, Height: %d", _PRIORITY (clip), LAYER_HEIGHT); /* Set the priority. */ if (_PRIORITY (clip) > LAYER_HEIGHT) { GST_WARNING_OBJECT (layer, "%p is out of the layer space, setting its priority to " "%d, setting it to the maximum priority of the layer: %d", clip, _PRIORITY (clip), LAYER_HEIGHT - 1); _set_priority0 (GES_TIMELINE_ELEMENT (clip), LAYER_HEIGHT - 1); } ges_layer_resync_priorities (layer); /* FIXME: ideally we would only emit if we are going to return TRUE. * However, for backward-compatibility, we ensure the "clip-added" * signal is released before the clip's "child-added" signal, which is * invoked by ges_timeline_add_clip */ g_signal_emit (layer, ges_layer_signals[OBJECT_ADDED], 0, clip); prev_children = ges_container_get_children (container, FALSE); if (timeline && !ges_timeline_add_clip (timeline, clip, &timeline_error)) { GST_INFO_OBJECT (layer, "Could not add the clip %" GES_FORMAT " to the timeline %" GST_PTR_FORMAT, GES_ARGS (clip), timeline); if (timeline_error) { if (error) { *error = timeline_error; } else { GST_WARNING_OBJECT (timeline, "Adding the clip %" GES_FORMAT " to the timeline failed: %s", GES_ARGS (clip), timeline_error->message); g_error_free (timeline_error); } } /* remove any track elements that were newly created */ new_children = ges_container_get_children (container, FALSE); for (tmp = new_children; tmp; tmp = tmp->next) { if (!g_list_find (prev_children, tmp->data)) ges_container_remove (container, tmp->data); } g_list_free_full (prev_children, gst_object_unref); g_list_free_full (new_children, gst_object_unref); /* FIXME: change emit signal to FALSE once we are able to delay the * "clip-added" signal until after ges_timeline_add_clip */ ges_layer_remove_clip_internal (layer, clip, TRUE); return FALSE; } g_list_free_full (prev_children, gst_object_unref); for (tmp = container->children; tmp; tmp = tmp->next) { GESTrack *track = ges_track_element_get_track (tmp->data); if (track) ges_track_element_set_layer_active (tmp->data, ges_layer_get_active_for_track (layer, track)); } return TRUE; } /** * ges_layer_add_clip: * @layer: The #GESLayer * @clip: (transfer floating): The clip to add * * See ges_layer_add_clip_full(), which also gives an error. * * Returns: %TRUE if @clip was properly added to @layer, or %FALSE * if @layer refused to add @clip. */ gboolean ges_layer_add_clip (GESLayer * layer, GESClip * clip) { return ges_layer_add_clip_full (layer, clip, NULL); } /** * ges_layer_add_asset_full: * @layer: The #GESLayer * @asset: The asset to extract the new clip from * @start: The #GESTimelineElement:start value to set on the new clip * If `start == #GST_CLOCK_TIME_NONE`, it will be added to the end * of @layer, i.e. it will be set to @layer's duration * @inpoint: The #GESTimelineElement:in-point value to set on the new * clip * @duration: The #GESTimelineElement:duration value to set on the new * clip * @track_types: The #GESClip:supported-formats to set on the the new * clip, or #GES_TRACK_TYPE_UNKNOWN to use the default * @error: (nullable): Return location for an error * * Extracts a new clip from an asset and adds it to the layer with * the given properties. * * Returns: (transfer none): The newly created clip. * Since: 1.18 */ GESClip * ges_layer_add_asset_full (GESLayer * layer, GESAsset * asset, GstClockTime start, GstClockTime inpoint, GstClockTime duration, GESTrackType track_types, GError ** error) { GESClip *clip; g_return_val_if_fail (GES_IS_LAYER (layer), NULL); g_return_val_if_fail (GES_IS_ASSET (asset), NULL); g_return_val_if_fail (!error || !*error, NULL); g_return_val_if_fail (g_type_is_a (ges_asset_get_extractable_type (asset), GES_TYPE_CLIP), NULL); GST_DEBUG_OBJECT (layer, "Adding asset %s with: start: %" GST_TIME_FORMAT " inpoint: %" GST_TIME_FORMAT " duration: %" GST_TIME_FORMAT " track types: %d (%s)", ges_asset_get_id (asset), GST_TIME_ARGS (start), GST_TIME_ARGS (inpoint), GST_TIME_ARGS (duration), track_types, ges_track_type_name (track_types)); clip = GES_CLIP (ges_asset_extract (asset, NULL)); if (!GST_CLOCK_TIME_IS_VALID (start)) { start = ges_layer_get_duration (layer); GST_DEBUG_OBJECT (layer, "No start specified, setting it to %" GST_TIME_FORMAT, GST_TIME_ARGS (start)); } _set_start0 (GES_TIMELINE_ELEMENT (clip), start); _set_inpoint0 (GES_TIMELINE_ELEMENT (clip), inpoint); if (track_types != GES_TRACK_TYPE_UNKNOWN) ges_clip_set_supported_formats (clip, track_types); if (GST_CLOCK_TIME_IS_VALID (duration)) { _set_duration0 (GES_TIMELINE_ELEMENT (clip), duration); } if (!ges_layer_add_clip_full (layer, clip, error)) { return NULL; } return clip; } /** * ges_layer_add_asset: * @layer: The #GESLayer * @asset: The asset to extract the new clip from * @start: The #GESTimelineElement:start value to set on the new clip * If `start == #GST_CLOCK_TIME_NONE`, it will be added to the end * of @layer, i.e. it will be set to @layer's duration * @inpoint: The #GESTimelineElement:in-point value to set on the new * clip * @duration: The #GESTimelineElement:duration value to set on the new * clip * @track_types: The #GESClip:supported-formats to set on the the new * clip, or #GES_TRACK_TYPE_UNKNOWN to use the default * * See ges_layer_add_asset_full(), which also gives an error. * * Returns: (transfer none) (nullable): The newly created clip. */ GESClip * ges_layer_add_asset (GESLayer * layer, GESAsset * asset, GstClockTime start, GstClockTime inpoint, GstClockTime duration, GESTrackType track_types) { return ges_layer_add_asset_full (layer, asset, start, inpoint, duration, track_types, NULL); } /** * ges_layer_new: * * Creates a new layer. * * Returns: (transfer floating): A new layer. */ GESLayer * ges_layer_new (void) { return g_object_new (GES_TYPE_LAYER, NULL); } /** * ges_layer_get_timeline: * @layer: The #GESLayer * * Gets the timeline that the layer is a part of. * * Returns: (transfer none) (nullable): The timeline that @layer * is currently part of, or %NULL if it is not associated with any * timeline. */ GESTimeline * ges_layer_get_timeline (GESLayer * layer) { g_return_val_if_fail (GES_IS_LAYER (layer), NULL); return layer->timeline; } void ges_layer_set_timeline (GESLayer * layer, GESTimeline * timeline) { GList *tmp; g_return_if_fail (GES_IS_LAYER (layer)); GST_DEBUG ("layer:%p, timeline:%p", layer, timeline); for (tmp = layer->priv->clips_start; tmp; tmp = tmp->next) { ges_timeline_element_set_timeline (tmp->data, timeline); } layer->timeline = timeline; } /** * ges_layer_get_clips_in_interval: * @layer: The #GESLayer * @start: Start of the interval * @end: End of the interval * * Gets the clips within the layer that appear between @start and @end. * * Returns: (transfer full) (element-type GESClip): A list of #GESClip-s * that intersect the interval `[start, end)` in @layer. */ GList * ges_layer_get_clips_in_interval (GESLayer * layer, GstClockTime start, GstClockTime end) { GList *tmp; GList *intersecting_clips = NULL; GstClockTime clip_start, clip_end; gboolean clip_intersects; g_return_val_if_fail (GES_IS_LAYER (layer), NULL); layer->priv->clips_start = g_list_sort (layer->priv->clips_start, (GCompareFunc) element_start_compare); for (tmp = layer->priv->clips_start; tmp; tmp = tmp->next) { clip_intersects = FALSE; clip_start = ges_timeline_element_get_start (tmp->data); clip_end = clip_start + ges_timeline_element_get_duration (tmp->data); if (start <= clip_start && clip_start < end) clip_intersects = TRUE; else if (start < clip_end && clip_end <= end) clip_intersects = TRUE; else if (clip_start < start && clip_end > end) clip_intersects = TRUE; if (clip_intersects) intersecting_clips = g_list_insert_sorted (intersecting_clips, gst_object_ref (tmp->data), (GCompareFunc) element_start_compare); } return intersecting_clips; } /** * ges_layer_get_active_for_track: * @layer: The #GESLayer * @track: The #GESTrack to check if @layer is currently active for * * Gets whether the layer is active for the given track. See * ges_layer_set_active_for_tracks(). * * Returns: %TRUE if @layer is active for @track, or %FALSE otherwise. * * Since: 1.18 */ gboolean ges_layer_get_active_for_track (GESLayer * layer, GESTrack * track) { LayerActivnessData *d; g_return_val_if_fail (GES_IS_LAYER (layer), FALSE); g_return_val_if_fail (GES_IS_TRACK (track), FALSE); g_return_val_if_fail (layer->timeline == ges_track_get_timeline (track), FALSE); d = g_hash_table_lookup (layer->priv->tracks_activness, track); return d ? d->active : TRUE; } /** * ges_layer_set_active_for_tracks: * @layer: The #GESLayer * @active: Whether elements in @tracks should be active or not * @tracks: (transfer none) (element-type GESTrack) (allow-none): The list of * tracks @layer should be (de-)active in, or %NULL to include all the tracks * in the @layer's timeline * * Activate or deactivate track elements in @tracks (or in all tracks if @tracks * is %NULL). * * When a layer is deactivated for a track, all the #GESTrackElement-s in * the track that belong to a #GESClip in the layer will no longer be * active in the track, regardless of their individual * #GESTrackElement:active value. * * Note that by default a layer will be active for all of its * timeline's tracks. * * Returns: %TRUE if the operation worked %FALSE otherwise. * * Since: 1.18 */ gboolean ges_layer_set_active_for_tracks (GESLayer * layer, gboolean active, GList * tracks) { GList *tmp, *owned_tracks = NULL; GPtrArray *changed_tracks = NULL; g_return_val_if_fail (GES_IS_LAYER (layer), FALSE); if (!tracks && layer->timeline) owned_tracks = tracks = ges_timeline_get_tracks (layer->timeline); for (tmp = tracks; tmp; tmp = tmp->next) { GESTrack *track = tmp->data; /* Handle setting timeline later */ g_return_val_if_fail (layer->timeline == ges_track_get_timeline (track), FALSE); if (ges_layer_get_active_for_track (layer, track) != active) { if (changed_tracks == NULL) changed_tracks = g_ptr_array_new (); g_ptr_array_add (changed_tracks, track); } g_hash_table_insert (layer->priv->tracks_activness, track, layer_activness_data_new (track, layer, active)); } if (changed_tracks) { g_signal_emit (layer, ges_layer_signals[ACTIVE_CHANGED], 0, active, changed_tracks); g_ptr_array_unref (changed_tracks); } g_list_free_full (owned_tracks, gst_object_unref); return TRUE; }