gstreamer/subprojects/gst-editing-services/ges/ges-layer.c

/* 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_slice_free (NewAssetUData, 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_slice_new (NewAssetUData);

    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_slice_free (NewAssetUData, 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): 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;
}