gstreamer/ges/ges-timeline-tree.c

/* GStreamer Editing Services
 * Copyright (C) 2019 Igalia S.L
 *     Author: 2019 Thibault Saunier <tsaunier@igalia.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.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "ges-timeline-tree.h"
#include "ges-internal.h"

GST_DEBUG_CATEGORY_STATIC (tree_debug);
#undef GST_CAT_DEFAULT
#define GST_CAT_DEFAULT tree_debug

#define ELEMENT_EDGE_VALUE(e, edge) ((edge == GES_EDGE_END) ? ((GstClockTimeDiff) _END (e)) : ((GstClockTimeDiff) _START (e)))
typedef struct
{
  GstClockTime distance;
  gboolean on_end_only;
  gboolean on_start_only;

  GESEdge edge;
  GESTimelineElement *element;

  GESTimelineElement *moving_element;
  GESEdge moving_edge;
  GstClockTimeDiff diff;
} SnappingData;

/*  *INDENT-OFF* */
struct _TreeIterationData
{
  GNode *root;
  gboolean res;

  GstClockTimeDiff start_diff;
  GstClockTimeDiff inpoint_diff;
  GstClockTimeDiff duration_diff;
  gint64 priority_diff;

  /* The element we are visiting */
  GESTimelineElement *element;

  /* All the TrackElement currently moving */
  GList *movings;

  /* Elements overlaping on the start/end of @element */
  GESTimelineElement *overlaping_on_start;
  GESTimelineElement *overlaping_on_end;

  /* Timestamp after which elements will be rippled */
  GstClockTime ripple_time;

  SnappingData *snapping;

  /* The edge being trimmed or rippled */
  GESEdge edge;
  GHashTable *moved_clips;

  GList *neighbours;

  /* Data related to trimming groups */
  GstClockTime trim_group_start;
  GstClockTime trim_group_end;
} tree_iteration_data_init = {
   .root = NULL,
   .res = TRUE,
   .start_diff = 0,
   .inpoint_diff = 0,
   .duration_diff = 0,
   .priority_diff = 0,
   .element = NULL,
   .movings = NULL,
   .overlaping_on_start = NULL,
   .overlaping_on_end = NULL,
   .ripple_time = GST_CLOCK_TIME_NONE,
   .snapping = NULL,
   .edge = GES_EDGE_NONE,
   .moved_clips = NULL,
   .neighbours = NULL,
   .trim_group_start = GST_CLOCK_TIME_NONE,
   .trim_group_end = GST_CLOCK_TIME_NONE,
};
/*  *INDENT-ON* */

typedef struct _TreeIterationData TreeIterationData;

static void
clean_iteration_data (TreeIterationData * data)
{
  g_list_free (data->neighbours);
  g_list_free (data->movings);
  if (data->moved_clips)
    g_hash_table_unref (data->moved_clips);
}

void
timeline_tree_init_debug (void)
{
  GST_DEBUG_CATEGORY_INIT (tree_debug, "gestree",
      GST_DEBUG_FG_YELLOW, "timeline tree");
}


static gboolean
print_node (GNode * node, gpointer unused_data)
{
  if (G_NODE_IS_ROOT (node)) {
    g_print ("Timeline: %p\n", node->data);
    return FALSE;
  }

  g_print ("%*c- %" GES_FORMAT " - layer %" G_GINT32_FORMAT "\n",
      2 * g_node_depth (node), ' ', GES_ARGS (node->data),
      ges_timeline_element_get_layer_priority (node->data));

  return FALSE;
}

void
timeline_tree_debug (GNode * root)
{
  g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
      (GNodeTraverseFunc) print_node, NULL);
}

static inline GESTimelineElement *
get_toplevel_container (gpointer element)
{
  GESTimelineElement *ret =
      ges_timeline_element_get_toplevel_parent ((GESTimelineElement
          *) (element));

  /*  We own a ref to the elements ourself */
  gst_object_unref (ret);
  return ret;
}

static gboolean
timeline_tree_can_move_element_internal (GNode * root,
    GESTimelineElement * element,
    gint64 priority,
    GstClockTimeDiff start,
    GstClockTimeDiff inpoint,
    GstClockTimeDiff duration,
    GList * moving_track_elements,
    GstClockTime ripple_time, SnappingData * snapping, GESEdge edge);

static GNode *
find_node (GNode * root, gpointer element)
{
  return g_node_find (root, G_IN_ORDER, G_TRAVERSE_ALL, element);
}

static void
timeline_element_parent_cb (GESTimelineElement * child, GParamSpec * arg
    G_GNUC_UNUSED, GNode * root)
{
  GNode *new_parent_node = NULL, *node = find_node (root, child);

  if (child->parent)
    new_parent_node = find_node (root, child->parent);

  if (!new_parent_node)
    new_parent_node = root;

  g_node_unlink (node);
  g_node_prepend (new_parent_node, node);
}

void
timeline_tree_track_element (GNode * root, GESTimelineElement * element)
{
  GNode *node;
  GNode *parent;
  GESTimelineElement *toplevel;

  if (find_node (root, element)) {
    return;
  }

  g_signal_connect (element, "notify::parent",
      G_CALLBACK (timeline_element_parent_cb), root);

  toplevel = get_toplevel_container (element);
  if (toplevel == element) {
    GST_DEBUG ("Tracking toplevel element %" GES_FORMAT, GES_ARGS (element));

    node = g_node_prepend_data (root, element);
  } else {
    parent = find_node (root, element->parent);
    GST_LOG ("%" GES_FORMAT "parent is %" GES_FORMAT, GES_ARGS (element),
        GES_ARGS (element->parent));
    g_assert (parent);
    node = g_node_prepend_data (parent, element);
  }

  if (GES_IS_CONTAINER (element)) {
    GList *tmp;

    for (tmp = GES_CONTAINER_CHILDREN (element); tmp; tmp = tmp->next) {
      GNode *child_node = find_node (root, tmp->data);

      if (child_node) {
        g_node_unlink (child_node);
        g_node_prepend (node, child_node);
      } else {
        timeline_tree_track_element (root, tmp->data);
      }
    }
  }

  timeline_update_duration (root->data);
}

void
timeline_tree_stop_tracking_element (GNode * root, GESTimelineElement * element)
{
  GNode *node = find_node (root, element);

  node = find_node (root, element);

  /* Move children to the parent */
  while (node->children) {
    GNode *tmp = node->children;
    g_node_unlink (tmp);
    g_node_prepend (node->parent, tmp);
  }

  g_assert (node);
  GST_DEBUG ("Stop tracking %" GES_FORMAT, GES_ARGS (element));
  g_signal_handlers_disconnect_by_func (element, timeline_element_parent_cb,
      root);

  g_node_destroy (node);
  timeline_update_duration (root->data);
}

static inline gboolean
check_can_move_to_layer (GESTimelineElement * element,
    gint layer_priority_offset)
{
  return (((gint64) GES_TIMELINE_ELEMENT_LAYER_PRIORITY (element) -
          layer_priority_offset) >= 0);
}

/*  *INDENT-OFF* */
#define CHECK_AND_SNAP(diff_val,moving_edge_,edge_) \
if (snapping->distance >= ABS(diff_val) && ABS(diff_val) <= ABS(snapping->diff)) { \
  snapping->element = element; \
  snapping->edge = edge_; \
  snapping->moving_element = moving_elem; \
  snapping->moving_edge = moving_edge_; \
  snapping->diff = (diff_val); \
  GST_LOG("Snapping %" GES_FORMAT "with %" GES_FORMAT " - diff: %" G_GINT64_FORMAT "", GES_ARGS (moving_elem), GES_ARGS(element), (diff_val)); \
}

static void
check_snapping (GESTimelineElement * element, GESTimelineElement * moving_elem,
    SnappingData * snapping, GstClockTime start, GstClockTime end,
    GstClockTime moving_start, GstClockTime moving_end)
{
  GstClockTimeDiff snap_end_end_diff;
  GstClockTimeDiff snap_end_start_diff;

  if (element == moving_elem)
    return;

  if (!snapping || (
      GES_IS_CLIP (element->parent) && element->parent == moving_elem->parent))
    return;

  snap_end_end_diff = (GstClockTimeDiff) moving_end - (GstClockTimeDiff) end;
  snap_end_start_diff = (GstClockTimeDiff) moving_end - (GstClockTimeDiff) start;

  GST_DEBUG("Moving [%" G_GINT64_FORMAT "-%" G_GINT64_FORMAT "] element [%" G_GINT64_FORMAT "-%" G_GINT64_FORMAT "]", moving_start, moving_end, start, end);
  /* Prefer snapping end */
  if (!snapping->on_start_only) {
    CHECK_AND_SNAP(snap_end_end_diff, GES_EDGE_END, GES_EDGE_END)
    else CHECK_AND_SNAP(snap_end_start_diff, GES_EDGE_END, GES_EDGE_START)
  }

  if (!snapping->on_end_only) {
    GstClockTimeDiff snap_start_end_diff = GST_CLOCK_DIFF(end, moving_start);
    GstClockTimeDiff snap_start_start_diff = GST_CLOCK_DIFF(start, moving_start);

    CHECK_AND_SNAP(snap_start_end_diff, GES_EDGE_START, GES_EDGE_END)
    else CHECK_AND_SNAP(snap_start_start_diff, GES_EDGE_START, GES_EDGE_START)
  }
}
#undef CHECK_AND_SNAP
/*  *INDENT-ON* */

static gboolean
check_track_elements_overlaps_and_values (GNode * node,
    TreeIterationData * data)
{
  GESTimelineElement *e = (GESTimelineElement *) node->data;
  GstClockTimeDiff moving_start, moving_end, start, inpoint, end, duration;
  gint64 priority = ((gint64) GES_TIMELINE_ELEMENT_LAYER_PRIORITY (e));
  gint64 moving_priority =
      (gint64) GES_TIMELINE_ELEMENT_LAYER_PRIORITY (data->element) -
      data->priority_diff;

  gboolean can_overlap = e != data->element, in_movings, rippling, moving;

  if (!GES_IS_SOURCE (e))
    return FALSE;

  in_movings = ! !g_list_find (data->movings, e);
  rippling = e != data->element && !in_movings
      && (GST_CLOCK_TIME_IS_VALID (data->ripple_time)
      && e->start >= data->ripple_time);
  moving = in_movings || rippling || e == data->element;

  start = (GstClockTimeDiff) e->start;
  inpoint = (GstClockTimeDiff) e->inpoint;
  end = (GstClockTimeDiff) e->start + e->duration;
  duration = e->duration;
  moving_start = GST_CLOCK_DIFF (data->start_diff, data->element->start);
  moving_end =
      GST_CLOCK_DIFF (data->duration_diff,
      moving_start + data->element->duration);

  if (moving) {
    if (rippling) {
      if (data->edge == GES_EDGE_END) {
        /* Moving as rippled from the end of a previous element */
        start -= data->duration_diff;
      } else
        start -= data->start_diff;
    } else {
      start -= data->start_diff;
      if (GES_TIMELINE_ELEMENT_GET_CLASS (e)->set_inpoint)
        inpoint -= data->inpoint_diff;
      duration -= data->duration_diff;
    }
    end = start + duration;
    priority -= data->priority_diff;

    GST_DEBUG ("%s %" GES_FORMAT "to [%" G_GINT64_FORMAT "(%"
        G_GINT64_FORMAT ") - %" G_GINT64_FORMAT "] - layer: %" G_GINT64_FORMAT,
        rippling ? "Rippling" : "Moving", GES_ARGS (e), start, inpoint,
        duration, priority);
  }

  /* Not in the same track */
  if (ges_track_element_get_track ((GESTrackElement *) node->data) !=
      ges_track_element_get_track ((GESTrackElement *) data->element)) {
    GST_LOG ("%" GES_FORMAT " and %" GES_FORMAT
        " are not in the same track", GES_ARGS (node->data),
        GES_ARGS (data->element));
    can_overlap = FALSE;
  }

  /* Not in the same layer */
  if (priority != moving_priority) {
    GST_LOG ("%" GST_PTR_FORMAT " and %" GST_PTR_FORMAT
        " are not on the same layer (%d != %" G_GINT64_FORMAT ")", node->data,
        data->element, GES_TIMELINE_ELEMENT_LAYER_PRIORITY (e),
        moving_priority);
    can_overlap = FALSE;
  }

  if (start < 0) {
    GST_INFO ("%" GES_FORMAT "start would be %" G_GINT64_FORMAT " < 0",
        GES_ARGS (e), start);
    goto error;
  }

  if (duration < 0) {
    GST_INFO ("%" GES_FORMAT "duration would be %" G_GINT64_FORMAT " < 0",
        GES_ARGS (e), duration);
    goto error;
  }

  if (priority < 0) {
    GST_INFO ("%" GES_FORMAT "priority would be %" G_GINT64_FORMAT " < 0",
        GES_ARGS (e), priority);
    goto error;
  }

  if (inpoint < 0) {
    GST_INFO ("%" GES_FORMAT " can't set inpoint %" G_GINT64_FORMAT,
        GES_ARGS (e), inpoint);
    goto error;
  }

  if (inpoint + duration > e->maxduration) {
    GST_INFO ("%" GES_FORMAT " inpoint + duration %" G_GINT64_FORMAT
        " > max_duration %" G_GINT64_FORMAT,
        GES_ARGS (e), inpoint + duration, e->maxduration);
    goto error;
  }

  if (!moving)
    check_snapping (e, data->element, data->snapping, start, end, moving_start,
        moving_end);

  if (!can_overlap)
    return FALSE;

  if (start > moving_end || moving_start > end) {
    /* They do not overlap at all */
    GST_LOG ("%" GES_FORMAT " and %" GES_FORMAT
        " do not overlap at all.",
        GES_ARGS (node->data), GES_ARGS (data->element));
    return FALSE;
  }

  if ((moving_start <= start && moving_end >= end) ||
      (moving_start >= start && moving_end <= end)) {
    GST_INFO ("Fully overlaped: %s<%p> [%" G_GINT64_FORMAT " - %"
        G_GINT64_FORMAT "] and %s<%p> [%" G_GINT64_FORMAT " - %" G_GINT64_FORMAT
        " (%" G_GINT64_FORMAT ")]", e->name, e, start, end, data->element->name,
        data->element, moving_start, moving_end, data->duration_diff);

    goto error;
  }

  if (moving_start < end && moving_start > start) {
    GST_LOG ("Overlap start: %s<%p> [%" G_GINT64_FORMAT "-%" G_GINT64_FORMAT
        "] and %s<%p> [%" G_GINT64_FORMAT "-%" G_GINT64_FORMAT " (%"
        G_GINT64_FORMAT ")]", e->name, e, start, end, data->element->name,
        data->element, moving_start, moving_end, data->duration_diff);
    if (data->overlaping_on_start) {
      GST_INFO ("Clip is overlapped by %s and %s at its start",
          data->overlaping_on_start->name, e->name);
      goto error;
    }

    data->overlaping_on_start = node->data;
  } else if (moving_end > end && end > moving_start) {
    GST_LOG ("Overlap end: %s<%p> [%" G_GINT64_FORMAT "-%" G_GINT64_FORMAT
        "] and %s<%p> [%" G_GINT64_FORMAT "-%" G_GINT64_FORMAT " (%"
        G_GINT64_FORMAT ")]", e->name, e, start, end, data->element->name,
        data->element, moving_start, moving_end, data->duration_diff);

    if (data->overlaping_on_end) {
      GST_INFO ("Clip is overlapped by %s and %s at its end",
          data->overlaping_on_end->name, e->name);
      goto error;
    }
    data->overlaping_on_end = node->data;
  }

  return FALSE;

error:
  data->res = FALSE;
  return TRUE;
}

static gboolean
check_can_move_children (GNode * node, TreeIterationData * data)
{
  GESTimelineElement *element = node->data;
  GstClockTimeDiff start = GST_CLOCK_DIFF (data->start_diff, element->start);
  GstClockTime inpoint = GST_CLOCK_DIFF (data->inpoint_diff, element->inpoint);
  GstClockTime duration =
      GST_CLOCK_DIFF (data->duration_diff, element->duration);
  gint64 priority =
      (gint64) GES_TIMELINE_ELEMENT_LAYER_PRIORITY (element) -
      data->priority_diff;
  if (element == data->element)
    return FALSE;

  data->res =
      timeline_tree_can_move_element_internal (data->root, node->data, priority,
      start, inpoint, duration, data->movings, data->ripple_time,
      data->snapping, data->edge);

  return !data->res;
}

static gboolean
timeline_tree_can_move_element_from_data (GNode * root,
    TreeIterationData * data)
{
  GNode *node = find_node (root, data->element);

  g_assert (node);
  if (G_NODE_IS_LEAF (node)) {
    if (GES_IS_SOURCE (node->data)) {
      g_node_traverse (root, G_IN_ORDER, G_TRAVERSE_LEAVES, -1,
          (GNodeTraverseFunc) check_track_elements_overlaps_and_values, data);

      return data->res;
    }

    return TRUE;
  }

  g_node_traverse (node, G_IN_ORDER, G_TRAVERSE_LEAFS, -1,
      (GNodeTraverseFunc) check_can_move_children, data);

  return data->res;
}

static gboolean
add_element_to_list (GNode * node, GList ** elements)
{
  *elements = g_list_prepend (*elements, node->data);

  return FALSE;
}

static gboolean
timeline_tree_can_move_element_internal (GNode * root,
    GESTimelineElement * element, gint64 priority, GstClockTimeDiff start,
    GstClockTimeDiff inpoint, GstClockTimeDiff duration,
    GList * moving_track_elements, GstClockTime ripple_time,
    SnappingData * snapping, GESEdge edge)
{
  gboolean res;
  TreeIterationData data = tree_iteration_data_init;

  data.root = root;
  data.start_diff = GST_CLOCK_DIFF (start, element->start);
  data.inpoint_diff = GST_CLOCK_DIFF (inpoint, element->inpoint);
  data.duration_diff = GST_CLOCK_DIFF (duration, element->duration);
  data.priority_diff =
      (gint64) GES_TIMELINE_ELEMENT_LAYER_PRIORITY (element) - priority;
  data.element = element;
  data.movings = g_list_copy (moving_track_elements);
  data.ripple_time = ripple_time;
  data.snapping = snapping;
  data.edge = edge;

  if (GES_IS_SOURCE (element))
    data.priority_diff =
        GES_TIMELINE_ELEMENT_LAYER_PRIORITY (element) - priority;

  res = timeline_tree_can_move_element_from_data (root, &data);
  clean_iteration_data (&data);

  return res;
}

gboolean
timeline_tree_can_move_element (GNode * root,
    GESTimelineElement * element, guint32 priority, GstClockTime start,
    GstClockTime duration, GList * moving_track_elements)
{
  GESTimelineElement *toplevel;
  GstClockTimeDiff start_offset, duration_offset;
  gint64 priority_diff;
  gboolean res;
  GList *local_moving_track_elements = g_list_copy (moving_track_elements);

  toplevel = get_toplevel_container (element);
  if (ELEMENT_FLAG_IS_SET (element, GES_TIMELINE_ELEMENT_SET_SIMPLE) ||
      ELEMENT_FLAG_IS_SET (toplevel, GES_TIMELINE_ELEMENT_SET_SIMPLE))
    return TRUE;

  start_offset = GST_CLOCK_DIFF (start, element->start);
  duration_offset = GST_CLOCK_DIFF (duration, element->duration);
  priority_diff =
      (gint64) GES_TIMELINE_ELEMENT_LAYER_PRIORITY (toplevel) -
      (gint64) priority;

  g_node_traverse (find_node (root, toplevel), G_IN_ORDER,
      G_TRAVERSE_LEAVES, -1, (GNodeTraverseFunc) add_element_to_list,
      &local_moving_track_elements);

  res = timeline_tree_can_move_element_internal (root, toplevel,
      GES_TIMELINE_ELEMENT_LAYER_PRIORITY (toplevel) - priority_diff,
      GST_CLOCK_DIFF (start_offset, toplevel->start),
      toplevel->inpoint,
      GST_CLOCK_DIFF (duration_offset, toplevel->duration),
      local_moving_track_elements, GST_CLOCK_TIME_NONE, NULL, GES_EDGE_NONE);

  g_list_free (local_moving_track_elements);
  return res;
}

static void
move_to_new_layer (GESTimelineElement * elem, gint layer_priority_offset)
{
  guint32 nprio =
      GES_TIMELINE_ELEMENT_LAYER_PRIORITY (elem) - layer_priority_offset;
  GESTimeline *timeline = GES_TIMELINE_ELEMENT_TIMELINE (elem);

  if (!layer_priority_offset)
    return;

  GST_DEBUG ("%s moving from %" G_GUINT32_FORMAT " to %" G_GUINT32_FORMAT " (%"
      G_GUINT32_FORMAT ")", elem->name, elem->priority, nprio,
      layer_priority_offset);
  if (GES_IS_CLIP (elem)) {
    GESLayer *layer = ges_timeline_get_layer (timeline, nprio);

    if (layer == NULL) {
      do {
        layer = ges_timeline_append_layer (timeline);
      } while (ges_layer_get_priority (layer) < nprio);
    } else {
      gst_object_unref (layer);
    }

    ges_clip_move_to_layer (GES_CLIP (elem), layer);
  } else if (GES_IS_GROUP (elem)) {
    ges_timeline_element_set_priority (elem, nprio);
  } else {
    g_assert_not_reached ();
  }
}

gboolean
timeline_tree_ripple (GNode * root, gint64 layer_priority_offset,
    GstClockTimeDiff offset, GESTimelineElement * rippled_element,
    GESEdge edge, GstClockTime snapping_distance)
{
  GNode *node;
  GHashTableIter iter;
  GESTimelineElement *elem;
  GstClockTimeDiff start, duration;
  gboolean res = TRUE;
  GHashTable *to_move = g_hash_table_new (g_direct_hash, g_direct_equal);
  GList *moving_track_elements = NULL;
  SnappingData snapping = {
    .distance = snapping_distance,
    .on_end_only = edge == GES_EDGE_END,
    .on_start_only = FALSE,
    .element = NULL,
    .edge = GES_EDGE_NONE,
    .diff = (GstClockTimeDiff) snapping_distance,
  };
  gint64 new_layer_priority =
      ((gint64) GES_TIMELINE_ELEMENT_LAYER_PRIORITY (rippled_element)) -
      layer_priority_offset;
  GESTimelineElement *ripple_toplevel =
      get_toplevel_container (rippled_element);
  GstClockTimeDiff ripple_time = ELEMENT_EDGE_VALUE (rippled_element, edge);

  if (edge == GES_EDGE_END) {
    if (ripple_toplevel != rippled_element) {
      GST_FIXME ("Trying to ripple end %" GES_FORMAT " but in %" GES_FORMAT
          " we do not know how to do that yet!",
          GES_ARGS (rippled_element), GES_ARGS (ripple_toplevel));
      goto error;
    }
  } else {
    g_node_traverse (find_node (root, ripple_toplevel), G_IN_ORDER,
        G_TRAVERSE_LEAVES, -1, (GNodeTraverseFunc) add_element_to_list,
        &moving_track_elements);
  }

  GST_INFO ("Moving %" GES_FORMAT " with offset %" G_GINT64_FORMAT "",
      GES_ARGS (ripple_toplevel), offset);

  if (edge == GES_EDGE_END) {
    start = _START (rippled_element);
    duration = GST_CLOCK_DIFF (offset, _DURATION (rippled_element));
  } else {
    start = GST_CLOCK_DIFF (offset, _START (rippled_element));
    duration = _DURATION (rippled_element);
  }

  if (!timeline_tree_can_move_element_internal (root, rippled_element,
          new_layer_priority, start, rippled_element->inpoint, duration, NULL,
          ripple_time, snapping_distance ? &snapping : NULL, edge)) {
    goto error;
  }

  if (snapping_distance) {
    if (snapping.element) {
      offset =
          GST_CLOCK_DIFF (ELEMENT_EDGE_VALUE (snapping.element, snapping.edge),
          ELEMENT_EDGE_VALUE (snapping.moving_element, snapping.moving_edge));

      if (edge == GES_EDGE_END) {
        start = _START (rippled_element);
        duration = GST_CLOCK_DIFF (offset, _DURATION (rippled_element));
      } else {
        start = GST_CLOCK_DIFF (offset, _START (rippled_element));
        duration = _DURATION (rippled_element);
      }

      GST_INFO ("Snapping on %" GES_FORMAT "%s %" G_GINT64_FORMAT "",
          GES_ARGS (snapping.element),
          snapping.edge == GES_EDGE_END ? "end" : "start",
          ELEMENT_EDGE_VALUE (snapping.element, snapping.edge));
      if (!timeline_tree_can_move_element_internal (root, rippled_element,
              new_layer_priority, start, rippled_element->inpoint, duration,
              NULL, ripple_time, NULL, edge)) {
        goto error;
      }
    }

    ges_timeline_emit_snapping (root->data, rippled_element, snapping.element,
        snapping.element ? ELEMENT_EDGE_VALUE (snapping.element,
            snapping.edge) : GST_CLOCK_TIME_NONE);
  }

  /* Make sure we can ripple all toplevels after the rippled element */
  for (node = root->children; node; node = node->next) {
    GESTimelineElement *toplevel = get_toplevel_container (node->data);

    if (GES_TIMELINE_ELEMENT_START (toplevel) < ripple_time
        && (edge == GES_EDGE_END || toplevel != ripple_toplevel))
      continue;

    if (!timeline_tree_can_move_element_internal (root, node->data,
            ((gint64) GES_TIMELINE_ELEMENT_LAYER_PRIORITY (node->data)) -
            layer_priority_offset,
            GST_CLOCK_DIFF (offset, _START (node->data)),
            _INPOINT (node->data),
            _DURATION (node->data), moving_track_elements, ripple_time, NULL,
            GES_EDGE_NONE)) {
      goto error;
    }

    if (!check_can_move_to_layer (toplevel, layer_priority_offset)) {
      GST_INFO ("%" GES_FORMAT " would land in a layer with negative priority",
          GES_ARGS (toplevel));
      goto error;
    }

    g_hash_table_add (to_move, toplevel);
  }

  if (edge == GES_EDGE_END) {
    if (!check_can_move_to_layer (rippled_element, layer_priority_offset)) {
      GST_INFO ("%" GES_FORMAT " would land in a layer with negative priority",
          GES_ARGS (rippled_element));

      goto error;
    }

    if (duration < 0) {
      GST_INFO ("Would set duration to  %" G_GINT64_FORMAT " <= 0", duration);
      goto error;
    }

    ELEMENT_SET_FLAG (rippled_element, GES_TIMELINE_ELEMENT_SET_SIMPLE);
    ges_timeline_element_set_duration (rippled_element, duration);
    ELEMENT_UNSET_FLAG (rippled_element, GES_TIMELINE_ELEMENT_SET_SIMPLE);
  }

  g_hash_table_iter_init (&iter, to_move);
  while (g_hash_table_iter_next (&iter, (gpointer *) & elem, NULL)) {
    GST_LOG ("Moving %" GES_FORMAT " to %" G_GINT64_FORMAT " - layer %"
        G_GINT64_FORMAT "", GES_ARGS (elem),
        GES_TIMELINE_ELEMENT_START (elem) - offset,
        (gint64) GES_TIMELINE_ELEMENT_LAYER_PRIORITY (elem) -
        layer_priority_offset);

    ELEMENT_SET_FLAG (elem, GES_TIMELINE_ELEMENT_SET_SIMPLE);
    ges_timeline_element_set_start (elem,
        GST_CLOCK_DIFF (offset, GES_TIMELINE_ELEMENT_START (elem)));
    move_to_new_layer (elem, layer_priority_offset);
    ELEMENT_UNSET_FLAG (elem, GES_TIMELINE_ELEMENT_SET_SIMPLE);
  }

  ELEMENT_SET_FLAG (rippled_element, GES_TIMELINE_ELEMENT_SET_SIMPLE);
  if (edge == GES_EDGE_END)
    move_to_new_layer (rippled_element, layer_priority_offset);
  ELEMENT_UNSET_FLAG (rippled_element, GES_TIMELINE_ELEMENT_SET_SIMPLE);

  timeline_tree_create_transitions (root, ges_timeline_find_auto_transition);
  timeline_update_transition (root->data);
  timeline_update_duration (root->data);

done:
  g_hash_table_unref (to_move);
  g_list_free (moving_track_elements);
  return res;

error:
  res = FALSE;
  goto done;
}

static gboolean
trim_group_get_vals (TreeIterationData * data, GESTimelineElement * e,
    GstClockTimeDiff * n_start, GstClockTimeDiff * n_inpoint,
    GstClockTimeDiff * n_duration)
{
  GstClockTimeDiff offset;
  GstClockTimeDiff group_nstart =
      GST_CLOCK_DIFF (data->start_diff, data->trim_group_start);
  GstClockTimeDiff group_nend =
      GST_CLOCK_DIFF (data->duration_diff, data->trim_group_end);

  if (data->edge == GES_EDGE_START &&
      ((group_nstart >= e->start) || (e->start == data->trim_group_start))) {

    offset = GST_CLOCK_DIFF (group_nstart, e->start);
    *n_start = group_nstart;
    *n_inpoint = GST_CLOCK_DIFF (offset, e->inpoint);
    *n_duration =
        GST_CLOCK_DIFF (*n_start, (GstClockTimeDiff) e->start + e->duration);

    GST_DEBUG_OBJECT (data->element, "Trimming %" GES_FORMAT " start",
        GES_ARGS (e));
    return TRUE;
  } else if (data->edge == GES_EDGE_END &&
      ((group_nend <= _END (e)) || (_END (e) == data->trim_group_end))) {

    offset = GST_CLOCK_DIFF (group_nend, _END (e));
    *n_start = e->start;
    *n_inpoint = e->inpoint;
    *n_duration = GST_CLOCK_DIFF (offset, e->duration);

    GST_DEBUG_OBJECT (data->element, "Trimming %" GES_FORMAT " end",
        GES_ARGS (e));

    return TRUE;
  }

  /* Ignoring child */
  return FALSE;
}

static gboolean
check_trim_child (GNode * node, TreeIterationData * data)
{
  GESTimelineElement *e = node->data;
  GstClockTimeDiff n_start = GST_CLOCK_DIFF (data->start_diff, e->start);
  GstClockTimeDiff n_inpoint = GST_CLOCK_DIFF (data->inpoint_diff, e->inpoint);
  GstClockTimeDiff n_duration = data->edge == GES_EDGE_END ?
      GST_CLOCK_DIFF (data->duration_diff, e->duration) :
      GST_CLOCK_DIFF (n_start, (GstClockTimeDiff) e->start + e->duration);

  if (GST_CLOCK_TIME_IS_VALID (data->trim_group_start)
      && !trim_group_get_vals (data, e, &n_start, &n_inpoint, &n_duration)) {
    GST_DEBUG_OBJECT (data->element, "Not trimming");
    return FALSE;
  }

  if (!timeline_tree_can_move_element_internal (data->root, e,
          (gint64) ges_timeline_element_get_layer_priority (e) -
          data->priority_diff, n_start, n_inpoint, n_duration, NULL,
          GST_CLOCK_TIME_NONE, data->snapping, GES_EDGE_NONE))
    goto error;

  if (GES_IS_CLIP (e->parent))
    g_hash_table_add (data->moved_clips, e->parent);
  else if (GES_IS_CLIP (e))
    g_hash_table_add (data->moved_clips, e);

  return FALSE;

error:
  data->res = FALSE;

  return TRUE;
}

static gboolean
timeline_tree_can_trim_element_internal (GNode * root, TreeIterationData * data)
{
  g_node_traverse (find_node (root, data->element), G_IN_ORDER,
      G_TRAVERSE_LEAVES, -1, (GNodeTraverseFunc) check_trim_child, data);

  return data->res;
}

static void
trim_simple (GESTimelineElement * element, GstClockTimeDiff offset,
    GESEdge edge, TreeIterationData * data)
{
  GESTimelineElement *toplevel =
      ges_timeline_element_get_toplevel_parent (element);

  GstClockTimeDiff n_start = GST_CLOCK_DIFF (offset, element->start);
  GstClockTimeDiff n_inpoint = GST_CLOCK_DIFF (offset, element->inpoint);
  GstClockTimeDiff n_duration = edge == GES_EDGE_END
      ? GST_CLOCK_DIFF (offset, element->duration)
      : element->duration + offset;

  if (data && GST_CLOCK_TIME_IS_VALID (data->trim_group_start))
    g_assert (trim_group_get_vals (data, element, &n_start, &n_inpoint,
            &n_duration));

  ELEMENT_SET_FLAG (element, GES_TIMELINE_ELEMENT_SET_SIMPLE);
  ELEMENT_SET_FLAG (toplevel, GES_TIMELINE_ELEMENT_SET_SIMPLE);
  if (edge != GES_EDGE_END) {
    ges_timeline_element_set_start (element, n_start);
    ges_timeline_element_set_inpoint (element, n_inpoint);
  }
  ges_timeline_element_set_duration (element, n_duration);

  GST_LOG ("Trimmed %" GES_FORMAT, GES_ARGS (element));
  ELEMENT_UNSET_FLAG (element, GES_TIMELINE_ELEMENT_SET_SIMPLE);
  ELEMENT_UNSET_FLAG (toplevel, GES_TIMELINE_ELEMENT_SET_SIMPLE);
  gst_object_unref (toplevel);
}

#define SET_TRIMMING_DATA(data, _edge, offset) G_STMT_START { \
  data.edge = (_edge);                                           \
  data.start_diff = (_edge) == GES_EDGE_END ? 0 : (offset); \
  data.inpoint_diff = (_edge) == GES_EDGE_END ? 0 : (offset); \
  data.duration_diff = (_edge) == GES_EDGE_END ? (offset) : -(offset); \
  if (GES_IS_GROUP (data.element)) {\
    data.trim_group_start = data.element->start;\
    data.trim_group_end = _END (data.element); \
  } \
} G_STMT_END


gboolean
timeline_tree_trim (GNode * root, GESTimelineElement * element,
    gint64 layer_priority_offset, GstClockTimeDiff offset, GESEdge edge,
    GstClockTime snapping_distance)
{
  GHashTableIter iter;
  gboolean res = TRUE;
  GESTimelineElement *elem;
  gint64 new_layer_priority =
      ((gint64) GES_TIMELINE_ELEMENT_LAYER_PRIORITY (element)) -
      layer_priority_offset;
  SnappingData snapping = {
    .distance = snapping_distance,
    .on_end_only = edge == GES_EDGE_END,
    .on_start_only = edge != GES_EDGE_END,
    .element = NULL,
    .edge = GES_EDGE_NONE,
    .diff = (GstClockTimeDiff) snapping_distance,
  };
  TreeIterationData data = tree_iteration_data_init;

  /* Make sure to check all children of clips */
  if (GES_IS_TRACK_ELEMENT (element) && element->parent)
    element = element->parent;

  data.root = root;
  data.element = element;
  data.priority_diff =
      (gint64) ges_timeline_element_get_layer_priority (element) -
      new_layer_priority;
  data.snapping = snapping_distance ? &snapping : NULL;
  data.moved_clips = g_hash_table_new (g_direct_hash, g_direct_equal);
  SET_TRIMMING_DATA (data, edge, offset);
  GST_INFO ("%" GES_FORMAT " trimming %s with offset %" G_GINT64_FORMAT "",
      GES_ARGS (element), edge == GES_EDGE_END ? "end" : "start", offset);
  g_node_traverse (find_node (root, get_toplevel_container (element)),
      G_IN_ORDER, G_TRAVERSE_LEAVES, -1,
      (GNodeTraverseFunc) add_element_to_list, &data.movings);

  if (!timeline_tree_can_trim_element_internal (root, &data)) {
    GST_INFO ("Can not trim object.");
    goto error;
  }

  if (snapping_distance) {
    if (snapping.element) {
      offset =
          GST_CLOCK_DIFF (ELEMENT_EDGE_VALUE (snapping.element, snapping.edge),
          ELEMENT_EDGE_VALUE (snapping.moving_element, snapping.moving_edge));

      GST_INFO ("Snapping on %" GES_FORMAT "%s %" G_GINT64_FORMAT
          " -- offset: %" G_GINT64_FORMAT "", GES_ARGS (snapping.element),
          snapping.edge == GES_EDGE_END ? "end" : "start",
          ELEMENT_EDGE_VALUE (snapping.element, snapping.edge), offset);
    }

    ges_timeline_emit_snapping (root->data, element,
        snapping.element,
        snapping.element ? ELEMENT_EDGE_VALUE (snapping.element,
            snapping.edge) : GST_CLOCK_TIME_NONE);
  }

  g_hash_table_iter_init (&iter, data.moved_clips);
  while (g_hash_table_iter_next (&iter, (gpointer *) & elem, NULL))
    trim_simple (elem, offset, edge, &data);

  timeline_tree_create_transitions (root, ges_timeline_find_auto_transition);
  timeline_update_transition (root->data);
  timeline_update_duration (root->data);

done:
  clean_iteration_data (&data);
  return res;

error:
  res = FALSE;
  goto done;
}

gboolean
timeline_tree_move (GNode * root, GESTimelineElement * element,
    gint64 layer_priority_offset, GstClockTimeDiff offset, GESEdge edge,
    GstClockTime snapping_distance)
{
  gboolean res = TRUE;
  GESTimelineElement *toplevel = get_toplevel_container (element);
  TreeIterationData data = tree_iteration_data_init;
  SnappingData snapping = {
    .distance = snapping_distance,
    .on_end_only = edge == GES_EDGE_END,
    .on_start_only = edge == GES_EDGE_END,
    .element = NULL,
    .edge = GES_EDGE_NONE,
    .diff = (GstClockTimeDiff) snapping_distance,
  };

  data.root = root;
  data.element = edge == GES_EDGE_END ? element : toplevel;
  data.edge = edge;
  data.priority_diff = layer_priority_offset;
  data.snapping = snapping_distance ? &snapping : NULL;
  data.start_diff = edge == GES_EDGE_END ? 0 : offset;
  data.duration_diff = edge == GES_EDGE_END ? offset : 0;

  GST_INFO ("%" GES_FORMAT
      " moving %s with offset %" G_GINT64_FORMAT ", (snaping distance: %"
      G_GINT64_FORMAT ")", GES_ARGS (element),
      edge == GES_EDGE_END ? "end" : "start", offset, snapping_distance);
  g_node_traverse (find_node (root, data.element), G_IN_ORDER,
      G_TRAVERSE_LEAVES, -1, (GNodeTraverseFunc) add_element_to_list,
      &data.movings);

  if (!timeline_tree_can_move_element_from_data (root, &data)) {
    GST_INFO ("Can not move object.");
    goto error;
  }

  if (snapping_distance) {
    if (snapping.element) {
      gint64 noffset =
          GST_CLOCK_DIFF (ELEMENT_EDGE_VALUE (snapping.element, snapping.edge),
          ELEMENT_EDGE_VALUE (snapping.moving_element, snapping.moving_edge));

      GST_INFO ("Snapping %" GES_FORMAT " (%s) with %" GES_FORMAT
          "%s %" G_GINT64_FORMAT " -- offset: %" G_GINT64_FORMAT
          " (previous offset: %" G_GINT64_FORMAT ")",
          GES_ARGS (snapping.moving_element),
          snapping.moving_edge == GES_EDGE_END ? "end" : "start",
          GES_ARGS (snapping.element),
          snapping.edge == GES_EDGE_END ? "end" : "start",
          ELEMENT_EDGE_VALUE (snapping.element, snapping.edge), noffset,
          offset);
      offset = noffset;
      data.start_diff = edge == GES_EDGE_END ? 0 : offset;
      data.duration_diff = edge == GES_EDGE_END ? offset : 0;
      data.snapping = NULL;
      if (!timeline_tree_can_move_element_from_data (root, &data)) {
        GST_INFO ("Can not move object.");
        goto error;
      }
    }

    ges_timeline_emit_snapping (root->data, element,
        snapping.element,
        snapping.element ? ELEMENT_EDGE_VALUE (snapping.element,
            snapping.edge) : GST_CLOCK_TIME_NONE);
  }

  if (!check_can_move_to_layer (toplevel, layer_priority_offset)) {
    GST_INFO ("%" GES_FORMAT " would land in a layer with negative priority",
        GES_ARGS (toplevel));
    goto error;
  }

  ELEMENT_SET_FLAG (toplevel, GES_TIMELINE_ELEMENT_SET_SIMPLE);
  if (edge == GES_EDGE_END)
    ges_timeline_element_set_duration (element, GST_CLOCK_DIFF (offset,
            element->duration));
  else
    ges_timeline_element_set_start (toplevel, GST_CLOCK_DIFF (offset,
            toplevel->start));
  move_to_new_layer (toplevel, layer_priority_offset);
  ELEMENT_UNSET_FLAG (toplevel, GES_TIMELINE_ELEMENT_SET_SIMPLE);

  timeline_tree_create_transitions (root, ges_timeline_find_auto_transition);
  timeline_update_transition (root->data);
  timeline_update_duration (root->data);

  GST_LOG ("Moved %" GES_FORMAT, GES_ARGS (element));

done:
  clean_iteration_data (&data);
  return res;

error:
  res = FALSE;
  goto done;
}

static gboolean
find_neighbour (GNode * node, TreeIterationData * data)
{
  gboolean in_same_track = FALSE;
  GList *tmp;

  if (!GES_IS_SOURCE (node->data)) {
    return FALSE;
  }


  for (tmp = GES_CONTAINER_CHILDREN (data->element); tmp; tmp = tmp->next) {
    if (tmp->data == node->data)
      return FALSE;

    if (ges_track_element_get_track (node->data) ==
        ges_track_element_get_track (tmp->data)) {
      in_same_track = TRUE;
    }
  }

  if (!in_same_track) {
    return FALSE;
  }

  if (ELEMENT_EDGE_VALUE (node->data,
          data->edge == GES_EDGE_START ? GES_EDGE_END : GES_EDGE_START) ==
      ELEMENT_EDGE_VALUE (data->element, data->edge)) {
    if (!g_list_find (data->neighbours,
            GES_TIMELINE_ELEMENT_PARENT (node->data)))
      data->neighbours =
          g_list_prepend (data->neighbours,
          GES_TIMELINE_ELEMENT_PARENT (node->data));
  }

  return FALSE;
}

gboolean
timeline_tree_roll (GNode * root, GESTimelineElement * element,
    GstClockTimeDiff offset, GESEdge edge, GstClockTime snapping_distance)
{
  gboolean res = TRUE;
  GList *tmp;
  GESEdge neighbour_edge;
  TreeIterationData data = tree_iteration_data_init;
  SnappingData snapping = {
    .distance = snapping_distance,
    .on_end_only = edge == GES_EDGE_END,
    .on_start_only = edge == GES_EDGE_END,
    .element = NULL,
    .edge = GES_EDGE_NONE,
    .moving_edge = GES_EDGE_NONE,
    .diff = (GstClockTimeDiff) snapping_distance,
  };

  data.root = root;
  data.element = element;
  data.edge = edge;
  data.snapping = snapping_distance ? &snapping : NULL;
  data.start_diff = edge == GES_EDGE_END ? 0 : offset;
  data.inpoint_diff = edge == GES_EDGE_END ? 0 : offset;
  data.duration_diff = edge == GES_EDGE_END ? offset : -offset;
  data.ripple_time = GST_CLOCK_TIME_NONE;
  neighbour_edge = data.edge == GES_EDGE_END ? GES_EDGE_START : GES_EDGE_END;

  SET_TRIMMING_DATA (data, edge, offset);
  g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_LEAFS, -1,
      (GNodeTraverseFunc) find_neighbour, &data);

  if (data.neighbours == NULL) {
    GST_INFO ("%s doesn't have any direct neighbour on edge %s",
        element->name, ges_edge_name (edge));

    return timeline_tree_trim (root, element, 0, offset, edge,
        snapping_distance);
  }

  GST_INFO ("Trimming %" GES_FORMAT " %s to %" G_GINT64_FORMAT "",
      GES_ARGS (data.element), ges_edge_name (edge), offset);

  if (!timeline_tree_can_move_element_from_data (root, &data))
    goto error;


  if (snapping_distance) {
    if (snapping.element) {
      gint64 noffset =
          GST_CLOCK_DIFF (ELEMENT_EDGE_VALUE (snapping.element, snapping.edge),
          ELEMENT_EDGE_VALUE (snapping.moving_element, snapping.moving_edge));

      GST_INFO ("Snapping %" GES_FORMAT " (%s) with %" GES_FORMAT
          "%s %" G_GINT64_FORMAT " -- offset: %" G_GINT64_FORMAT
          " (previous offset: %" G_GINT64_FORMAT ")",
          GES_ARGS (snapping.moving_element),
          snapping.moving_edge == GES_EDGE_END ? "end" : "start",
          GES_ARGS (snapping.element),
          snapping.edge == GES_EDGE_END ? "end" : "start",
          ELEMENT_EDGE_VALUE (snapping.element, snapping.edge), noffset,
          offset);
      offset = noffset;

      SET_TRIMMING_DATA (data, edge, offset);

      if (!timeline_tree_can_move_element_from_data (root, &data)) {
        GST_INFO ("Can not move object.");
        goto error;
      }
    }
  }

  if (snapping_distance && snapping.element) {
    ges_timeline_emit_snapping (root->data, element,
        snapping.element,
        snapping.element ? ELEMENT_EDGE_VALUE (snapping.element,
            snapping.edge) : GST_CLOCK_TIME_NONE);
  }

  data.snapping = NULL;
  SET_TRIMMING_DATA (data, neighbour_edge, offset);
  for (tmp = data.neighbours; tmp; tmp = tmp->next) {
    data.element = tmp->data;

    GST_INFO ("Trimming %" GES_FORMAT " %s to %" G_GINT64_FORMAT "",
        GES_ARGS (data.element), ges_edge_name (data.edge), offset);
    if (!timeline_tree_can_move_element_from_data (root, &data)) {
      GST_INFO ("Can not move object.");
      goto error;
    }
  }

  trim_simple (element, offset, edge, NULL);
  for (tmp = data.neighbours; tmp; tmp = tmp->next)
    trim_simple (tmp->data, offset, data.edge, NULL);

done:
  timeline_update_duration (root->data);
  g_list_free (data.neighbours);
  return res;

error:
  res = FALSE;
  goto done;
}

static void
create_transition_if_needed (GESTimeline * timeline, GESTrackElement * prev,
    GESTrackElement * next, GESTreeGetAutoTransitionFunc get_auto_transition)
{
  GstClockTime duration = _END (prev) - _START (next);
  GESAutoTransition *trans =
      get_auto_transition (timeline, prev, next, duration);

  if (!trans) {
    GESLayer *layer = ges_timeline_get_layer (timeline,
        GES_TIMELINE_ELEMENT_LAYER_PRIORITY (prev));
    gst_object_unref (layer);

    GST_INFO ("Creating transition [%" G_GINT64_FORMAT " - %" G_GINT64_FORMAT
        "]", _START (next), duration);
    ges_timeline_create_transition (timeline, prev, next, NULL, layer,
        _START (next), duration);
  }
}

static gboolean
create_transitions (GNode * node,
    GESTreeGetAutoTransitionFunc get_auto_transition)
{
  TreeIterationData data = tree_iteration_data_init;
  GESTimeline *timeline;
  GESLayer *layer;

  if (G_NODE_IS_ROOT (node))
    return FALSE;

  timeline = GES_TIMELINE_ELEMENT_TIMELINE (node->data);
  data.element = node->data;
  if (!GES_IS_SOURCE (node->data))
    return FALSE;

  if (!timeline) {
    GST_INFO ("%" GES_FORMAT " not in timeline yet", GES_ARGS (node->data));

    return FALSE;
  }

  layer =
      ges_timeline_get_layer (timeline,
      GES_TIMELINE_ELEMENT_LAYER_PRIORITY (node->data));
  gst_object_unref (layer);

  if (!ges_layer_get_auto_transition (layer))
    return FALSE;

  g_node_traverse (g_node_get_root (node), G_IN_ORDER, G_TRAVERSE_LEAVES, -1,
      (GNodeTraverseFunc) check_track_elements_overlaps_and_values, &data);

  if (data.overlaping_on_start)
    create_transition_if_needed (timeline,
        GES_TRACK_ELEMENT (data.overlaping_on_start), node->data,
        get_auto_transition);

  if (data.overlaping_on_end)
    create_transition_if_needed (timeline, node->data,
        GES_TRACK_ELEMENT (data.overlaping_on_end), get_auto_transition);

  return FALSE;
}

void
timeline_tree_create_transitions (GNode * root,
    GESTreeGetAutoTransitionFunc get_auto_transition)
{
  g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_LEAFS, -1,
      (GNodeTraverseFunc) create_transitions, get_auto_transition);
}

static gboolean
compute_duration (GNode * node, GstClockTime * duration)
{
  *duration = MAX (_END (node->data), *duration);

  return FALSE;
}

GstClockTime
timeline_tree_get_duration (GNode * root)
{
  GstClockTime duration = 0;

  if (root->children)
    g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_LEAFS, -1,
        (GNodeTraverseFunc) compute_duration, &duration);

  return duration;
}

static gboolean
reset_layer_activness (GNode * node, GESLayer * layer)
{
  GESTrack *track;


  if (!GES_IS_TRACK_ELEMENT (node->data))
    return FALSE;

  track = ges_track_element_get_track (node->data);
  if (!track || (ges_timeline_element_get_layer_priority (node->data) !=
          ges_layer_get_priority (layer)))
    return FALSE;

  ges_track_element_set_layer_active (node->data,
      ges_layer_get_active_for_track (layer, track));

  return FALSE;
}

void
timeline_tree_reset_layer_active (GNode * root, GESLayer * layer)
{
  g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_LEAFS, -1,
      (GNodeTraverseFunc) reset_layer_activness, layer);
}