ges/ges-timeline-layer.c

   1 /* GStreamer Editing Services
   2  * Copyright (C) 2009 Edward Hervey <edward.hervey@collabora.co.uk>
   3  *               2009 Nokia Corporation
   4  *               2011 Mathieu Duponchelle <mathieu.duponchelle@epitech.eu>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 /**
  23  * SECTION:ges-timeline-layer
  24  * @short_description: Non-overlapping sequence of #GESTimelineObject
  25  *
  26  * Responsible for the ordering of the various contained TimelineObject(s). A
  27  * timeline layer has a "priority" property, which is used to manage the
  28  * priorities of individual TimelineObjects. Two layers should not have the
  29  * same priority within a given timeline.
  30  */
  31
  32 #include "ges-internal.h"
  33 #include "gesmarshal.h"
  34 #include "ges-timeline-layer.h"
  35 #include "ges.h"
  36 #include "ges-timeline-source.h"
  37
  38 #define LAYER_HEIGHT 1000
  39
  40 static void
  41 track_object_removed_cb (GESTimelineObject * object,
  42     GESTrackObject * track_object);
  43 static void track_object_added_cb (GESTimelineObject * object,
  44     GESTrackObject * track_object, GHashTable * signal_table);
  45 static void track_object_changed_cb (GESTrackObject * track_object,
  46     GParamSpec * arg G_GNUC_UNUSED);
  47 static void calculate_transitions (GESTrackObject * track_object);
  48 static void calculate_next_transition (GESTrackObject * track_object,
  49     GESTimelineLayer * layer);
  50
  51 static void
  52 timeline_object_height_changed_cb (GESTimelineObject * obj,
  53     GESTrackEffect * tr_eff, GESTimelineObject * second_obj);
  54
  55 G_DEFINE_TYPE (GESTimelineLayer, ges_timeline_layer, G_TYPE_INITIALLY_UNOWNED);
  56
  57 struct _GESTimelineLayerPrivate
  58 {
  59   /*< private > */
  60   GList *objects_start;         /* The TimelineObjects sorted by start and
  61                                  * priority */
  62
  63   guint32 priority;             /* The priority of the layer within the
  64                                  * containing timeline */
  65
  66   gboolean auto_transition;
  67
  68
  69   GHashTable *signal_table;
  70 };
  71
  72 enum
  73 {
  74   PROP_0,
  75   PROP_PRIORITY,
  76   PROP_AUTO_TRANSITION,
  77   PROP_LAST
  78 };
  79
  80 enum
  81 {
  82   OBJECT_ADDED,
  83   OBJECT_REMOVED,
  84   LAST_SIGNAL
  85 };
  86
  87 static guint ges_timeline_layer_signals[LAST_SIGNAL] = { 0 };
  88
  89 static gboolean ges_timeline_layer_resync_priorities (GESTimelineLayer * layer);
  90
  91 static GList *track_get_by_layer (GESTimelineLayer * layer, GESTrack * track);
  92
  93 static void compare (GList * compared, GESTrackObject * track_object,
  94     gboolean ahead);
  95
  96 static void
  97 ges_timeline_layer_get_property (GObject * object, guint property_id,
  98     GValue * value, GParamSpec * pspec)
  99 {
 100   GESTimelineLayer *layer = GES_TIMELINE_LAYER (object);
 101
 102   switch (property_id) {
 103     case PROP_PRIORITY:
 104       g_value_set_uint (value, layer->priv->priority);
 105       break;
 106     case PROP_AUTO_TRANSITION:
 107       g_value_set_boolean (value, layer->priv->auto_transition);
 108       break;
 109     default:
 110       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 111   }
 112 }
 113
 114 static void
 115 ges_timeline_layer_set_property (GObject * object, guint property_id,
 116     const GValue * value, GParamSpec * pspec)
 117 {
 118   GESTimelineLayer *layer = GES_TIMELINE_LAYER (object);
 119
 120   switch (property_id) {
 121     case PROP_PRIORITY:
 122       ges_timeline_layer_set_priority (layer, g_value_get_uint (value));
 123       break;
 124     case PROP_AUTO_TRANSITION:
 125       ges_timeline_layer_set_auto_transition (layer,
 126           g_value_get_boolean (value));
 127       break;
 128     default:
 129       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 130   }
 131 }
 132
 133 static void
 134 ges_timeline_layer_dispose (GObject * object)
 135 {
 136   GESTimelineLayer *layer = GES_TIMELINE_LAYER (object);
 137   GESTimelineLayerPrivate *priv = layer->priv;
 138
 139   GST_DEBUG ("Disposing layer");
 140
 141   while (priv->objects_start)
 142     ges_timeline_layer_remove_object (layer,
 143         (GESTimelineObject *) priv->objects_start->data);
 144
 145   G_OBJECT_CLASS (ges_timeline_layer_parent_class)->dispose (object);
 146 }
 147
 148 static void
 149 ges_timeline_layer_class_init (GESTimelineLayerClass * klass)
 150 {
 151   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 152
 153   g_type_class_add_private (klass, sizeof (GESTimelineLayerPrivate));
 154
 155   object_class->get_property = ges_timeline_layer_get_property;
 156   object_class->set_property = ges_timeline_layer_set_property;
 157   object_class->dispose = ges_timeline_layer_dispose;
 158
 159   /**
 160    * GESTimelineLayer:priority
 161    *
 162    * The priority of the layer in the #GESTimeline. 0 is the highest
 163    * priority. Conceptually, a #GESTimeline is a stack of GESTimelineLayers,
 164    * and the priority of the layer represents its position in the stack. Two
 165    * layers should not have the same priority within a given GESTimeline.
 166    */
 167   g_object_class_install_property (object_class, PROP_PRIORITY,
 168       g_param_spec_uint ("priority", "Priority",
 169           "The priority of the layer", 0, G_MAXUINT, 0, G_PARAM_READWRITE));
 170
 171   /**
 172    * GESTimelineLayer:auto-transition
 173    *
 174    * Sets whether transitions are added automagically when timeline objects overlap.
 175    */
 176   g_object_class_install_property (object_class, PROP_AUTO_TRANSITION,
 177       g_param_spec_boolean ("auto-transition", "Auto-Transition",
 178           "whether the transitions are added", FALSE, G_PARAM_READWRITE));
 179
 180   /**
 181    * GESTimelineLayer::object-added
 182    * @layer: the #GESTimelineLayer
 183    * @object: the #GESTimelineObject that was added.
 184    *
 185    * Will be emitted after the object was added to the layer.
 186    */
 187   ges_timeline_layer_signals[OBJECT_ADDED] =
 188       g_signal_new ("object-added", G_TYPE_FROM_CLASS (klass),
 189       G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GESTimelineLayerClass, object_added),
 190       NULL, NULL, ges_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
 191       GES_TYPE_TIMELINE_OBJECT);
 192
 193   /**
 194    * GESTimelineLayer::object-removed
 195    * @layer: the #GESTimelineLayer
 196    * @object: the #GESTimelineObject that was removed
 197    *
 198    * Will be emitted after the object was removed from the layer.
 199    */
 200   ges_timeline_layer_signals[OBJECT_REMOVED] =
 201       g_signal_new ("object-removed", G_TYPE_FROM_CLASS (klass),
 202       G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GESTimelineLayerClass,
 203           object_removed), NULL, NULL, ges_marshal_VOID__OBJECT, G_TYPE_NONE, 1,
 204       GES_TYPE_TIMELINE_OBJECT);
 205 }
 206
 207 static void
 208 ges_timeline_layer_init (GESTimelineLayer * self)
 209 {
 210   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 211       GES_TYPE_TIMELINE_LAYER, GESTimelineLayerPrivate);
 212
 213   self->priv->priority = 0;
 214   self->priv->auto_transition = FALSE;
 215   self->min_gnl_priority = 0;
 216   self->max_gnl_priority = LAYER_HEIGHT;
 217   self->priv->signal_table =
 218       g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref,
 219       NULL);
 220 }
 221
 222 /**
 223  * ges_timeline_layer_new:
 224  *
 225  * Creates a new #GESTimelineLayer.
 226  *
 227  * Returns: A new #GESTimelineLayer
 228  */
 229 GESTimelineLayer *
 230 ges_timeline_layer_new (void)
 231 {
 232   return g_object_new (GES_TYPE_TIMELINE_LAYER, NULL);
 233 }
 234
 235 /**
 236  * ges_timeline_layer_get_timeline:
 237  * @layer: The #GESTimelineLayer to get the parent #GESTimeline from
 238  *
 239  * Get the #GESTimeline in which #GESTimelineLayer currently is.
 240  *
 241  * Returns: (transfer none):  the #GESTimeline in which #GESTimelineLayer
 242  * currently is or %NULL if not in any timeline yet.
 243  */
 244 GESTimeline *
 245 ges_timeline_layer_get_timeline (GESTimelineLayer * layer)
 246 {
 247   g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), NULL);
 248
 249   return layer->timeline;
 250 }
 251
 252 void
 253 ges_timeline_layer_set_timeline (GESTimelineLayer * layer,
 254     GESTimeline * timeline)
 255 {
 256   GST_DEBUG ("layer:%p, timeline:%p", layer, timeline);
 257
 258   layer->timeline = timeline;
 259 }
 260
 261 static gint
 262 objects_start_compare (GESTimelineObject * a, GESTimelineObject * b)
 263 {
 264   if (a->start == b->start) {
 265     if (a->priority < b->priority)
 266       return -1;
 267     if (a->priority > b->priority)
 268       return 1;
 269     return 0;
 270   }
 271   if (a->start < b->start)
 272     return -1;
 273   if (a->start > b->start)
 274     return 1;
 275   return 0;
 276 }
 277
 278 static GList *
 279 track_get_by_layer (GESTimelineLayer * layer, GESTrack * track)
 280 {
 281   GList *tck_objects_list = NULL, *tmp = NULL, *return_list = NULL;
 282   GESTimelineObject *tl_obj;
 283
 284   tck_objects_list = ges_track_get_objects (track);
 285   for (tmp = tck_objects_list; tmp; tmp = tmp->next) {
 286     tl_obj = ges_track_object_get_timeline_object (tmp->data);
 287
 288     if (ges_timeline_object_get_layer (tl_obj) == layer) {
 289       /*  We steal the reference from tck_objects_list */
 290       return_list = g_list_append (return_list, tmp->data);
 291
 292     } else
 293       g_object_unref (tmp->data);
 294   }
 295
 296   return return_list;
 297 }
 298
 299 /**
 300  * ges_timeline_layer_add_object:
 301  * @layer: a #GESTimelineLayer
 302  * @object: (transfer full): the #GESTimelineObject to add.
 303  *
 304  * Adds the given object to the layer. Sets the object's parent, and thus
 305  * takes ownership of the object.
 306  *
 307  * An object can only be added to one layer.
 308  *
 309  * Calling this method will construct and properly set all the media related
 310  * elements on @object. If you need to know when those objects (actually #GESTrackObject)
 311  * are constructed, you should connect to the object::track-object-added signal which
 312  * is emited right after those elements are ready to be used.
 313  *
 314  * Returns: TRUE if the object was properly added to the layer, or FALSE
 315  * if the @layer refuses to add the object.
 316  */
 317 gboolean
 318 ges_timeline_layer_add_object (GESTimelineLayer * layer,
 319     GESTimelineObject * object)
 320 {
 321   GESTimelineLayer *tl_obj_layer;
 322   guint32 maxprio, minprio, prio;
 323
 324   GST_DEBUG ("layer:%p, object:%p", layer, object);
 325
 326   tl_obj_layer = ges_timeline_object_get_layer (object);
 327
 328   if (G_UNLIKELY (tl_obj_layer)) {
 329     GST_WARNING ("TimelineObject %p already belongs to another layer", object);
 330     g_object_unref (tl_obj_layer);
 331     return FALSE;
 332   }
 333
 334   g_object_ref_sink (object);
 335
 336   /* Take a reference to the object and store it stored by start/priority */
 337   layer->priv->objects_start =
 338       g_list_insert_sorted (layer->priv->objects_start, object,
 339       (GCompareFunc) objects_start_compare);
 340
 341   /* We have to wait for the track objects to be created to calculate transitions */
 342   if (layer->priv->auto_transition) {
 343     if (GES_IS_TIMELINE_SOURCE (object)) {
 344       g_signal_connect (G_OBJECT (object), "track-object-added",
 345           G_CALLBACK (track_object_added_cb), layer->priv->signal_table);
 346       g_signal_connect (G_OBJECT (object), "track-object-removed",
 347           G_CALLBACK (track_object_removed_cb), NULL);
 348     }
 349   }
 350
 351   /* Inform the object it's now in this layer */
 352   ges_timeline_object_set_layer (object, layer);
 353
 354   GST_DEBUG ("current object priority : %d, layer min/max : %d/%d",
 355       GES_TIMELINE_OBJECT_PRIORITY (object),
 356       layer->min_gnl_priority, layer->max_gnl_priority);
 357
 358   /* Set the priority. */
 359   maxprio = layer->max_gnl_priority;
 360   minprio = layer->min_gnl_priority;
 361   prio = GES_TIMELINE_OBJECT_PRIORITY (object);
 362   if (minprio + prio > (maxprio)) {
 363     GST_WARNING ("%p is out of the layer %p space, setting its priority to "
 364         "setting its priority %d to failthe maximum priority of the layer %d",
 365         object, layer, prio, maxprio - minprio);
 366     ges_timeline_object_set_priority (object, LAYER_HEIGHT - 1);
 367   }
 368   /* If the object has an acceptable priority, we just let it with its current
 369    * priority */
 370
 371   ges_timeline_layer_resync_priorities (layer);
 372
 373   /* emit 'object-added' */
 374   g_signal_emit (layer, ges_timeline_layer_signals[OBJECT_ADDED], 0, object);
 375
 376   return TRUE;
 377 }
 378
 379 static void
 380 track_object_duration_cb (GESTrackObject * track_object,
 381     GParamSpec * arg G_GNUC_UNUSED)
 382 {
 383   GESTimelineLayer *layer;
 384   GESTimelineObject *tlobj;
 385
 386   tlobj = ges_track_object_get_timeline_object (track_object);
 387   layer = ges_timeline_object_get_layer (tlobj);
 388   if (G_LIKELY (GES_IS_TRACK_SOURCE (track_object)))
 389     calculate_next_transition (track_object, layer);
 390 }
 391
 392 static void
 393 track_object_deleted_cb (GESTrack * track, GESTrackObject * track_object)
 394 {
 395   GList *track_objects, *tmp, *cur;
 396   GESTimelineLayer *layer;
 397
 398   track_objects = ges_track_get_objects (track);
 399   cur = g_list_find (track_objects, track_object);
 400   for (tmp = cur->next; tmp; tmp = tmp->next) {
 401     if (GES_IS_TRACK_SOURCE (tmp->data)) {
 402       break;
 403     }
 404     if (GES_IS_TRACK_AUDIO_TRANSITION (tmp->data)
 405         || GES_IS_TRACK_VIDEO_TRANSITION (tmp->data)) {
 406       layer =
 407           ges_timeline_object_get_layer (ges_track_object_get_timeline_object
 408           (tmp->data));
 409       if (ges_timeline_layer_get_auto_transition (layer)) {
 410         ges_track_enable_update (track, FALSE);
 411         ges_timeline_layer_remove_object (layer,
 412             ges_track_object_get_timeline_object (tmp->data));
 413         ges_track_enable_update (track, TRUE);
 414       }
 415       g_object_unref (layer);
 416     }
 417   }
 418
 419   for (tmp = cur->prev; tmp; tmp = tmp->prev) {
 420     if (GES_IS_TRACK_SOURCE (tmp->data)) {
 421       break;
 422     }
 423     if (GES_IS_TRACK_AUDIO_TRANSITION (tmp->data)
 424         || GES_IS_TRACK_VIDEO_TRANSITION (tmp->data)) {
 425       layer =
 426           ges_timeline_object_get_layer (ges_track_object_get_timeline_object
 427           (tmp->data));
 428       if (ges_timeline_layer_get_auto_transition (layer)) {
 429         ges_track_enable_update (track, FALSE);
 430         ges_timeline_layer_remove_object (layer,
 431             ges_track_object_get_timeline_object (tmp->data));
 432         ges_track_enable_update (track, TRUE);
 433       }
 434       g_object_unref (layer);
 435     }
 436   }
 437   g_object_unref (track_object);
 438 }
 439
 440 static void
 441 track_object_added_cb (GESTimelineObject * object,
 442     GESTrackObject * track_object, GHashTable * signal_table)
 443 {
 444   GESTrack *track;
 445   gint ptr;
 446
 447   if (GES_IS_TRACK_SOURCE (track_object)) {
 448     g_signal_connect (G_OBJECT (track_object), "notify::start",
 449         G_CALLBACK (track_object_changed_cb), NULL);
 450     g_signal_connect (G_OBJECT (track_object), "notify::duration",
 451         G_CALLBACK (track_object_duration_cb), NULL);
 452     calculate_transitions (track_object);
 453   }
 454   track = ges_track_object_get_track (track_object);
 455   if (!g_hash_table_lookup (signal_table, track)) {
 456     ptr = g_signal_connect (track, "track-object-removed",
 457         (GCallback) track_object_deleted_cb, NULL);
 458     g_hash_table_insert (signal_table, track, GINT_TO_POINTER (ptr));
 459   }
 460   return;
 461 }
 462
 463 static void
 464 track_object_removed_cb (GESTimelineObject * object,
 465     GESTrackObject * track_object)
 466 {
 467   return;
 468   if (GES_IS_TRACK_SOURCE (track_object)) {
 469     g_signal_handlers_disconnect_by_func (track_object, track_object_changed_cb,
 470         object);
 471   }
 472   return;
 473 }
 474
 475 static void
 476 timeline_object_height_changed_cb (GESTimelineObject * obj,
 477     GESTrackEffect * tr_eff, GESTimelineObject * second_obj)
 478 {
 479   gint priority, height;
 480   g_object_get (obj, "height", &height, "priority", &priority, NULL);
 481   g_object_set (second_obj, "priority", priority + height, NULL);
 482 }
 483
 484 static void
 485 track_object_changed_cb (GESTrackObject * track_object,
 486     GParamSpec * arg G_GNUC_UNUSED)
 487 {
 488   if (G_LIKELY (GES_IS_TRACK_SOURCE (track_object)))
 489     calculate_transitions (track_object);
 490 }
 491
 492 static void
 493 calculate_next_transition_with_list (GESTrackObject * track_object,
 494     GList * tckobjs_in_layer, GESTimelineLayer * layer)
 495 {
 496   GList *compared;
 497
 498   if (!(compared = g_list_find (tckobjs_in_layer, track_object)))
 499     return;
 500
 501   if (compared == NULL)
 502     /* This is the last TrackObject of the Track */
 503     return;
 504
 505   do {
 506     compared = compared->next;
 507     if (compared == NULL)
 508       return;
 509   } while (!GES_IS_TRACK_SOURCE (compared->data));
 510
 511   compare (compared, track_object, FALSE);
 512 }
 513
 514
 515 static void
 516 calculate_next_transition (GESTrackObject * track_object,
 517     GESTimelineLayer * layer)
 518 {
 519   GESTrack *track;
 520   GList *tckobjs_in_layer;
 521
 522   if ((track = ges_track_object_get_track (track_object))) {
 523     tckobjs_in_layer = track_get_by_layer (layer, track);
 524     calculate_next_transition_with_list (track_object, tckobjs_in_layer, layer);
 525
 526     g_list_foreach (tckobjs_in_layer, (GFunc) g_object_unref, NULL);
 527     g_list_free (tckobjs_in_layer);
 528   }
 529 }
 530
 531 static void
 532 calculate_transitions (GESTrackObject * track_object)
 533 {
 534   GList *tckobjs_in_layer, *compared;
 535   GESTimelineLayer *layer;
 536   GESTimelineObject *tlobj;
 537
 538   GESTrack *track = ges_track_object_get_track (track_object);
 539
 540   if (track == NULL)
 541     return;
 542
 543   tlobj = ges_track_object_get_timeline_object (track_object);
 544   layer = ges_timeline_object_get_layer (tlobj);
 545   tckobjs_in_layer = track_get_by_layer (layer, track);
 546   if (!(compared = g_list_find (tckobjs_in_layer, track_object)))
 547     return;
 548   do {
 549     compared = compared->prev;
 550
 551     if (compared == NULL) {
 552       /* Nothing before, let's check after */
 553       calculate_next_transition_with_list (track_object, tckobjs_in_layer,
 554           layer);
 555       goto done;
 556
 557     }
 558   } while (!GES_IS_TRACK_SOURCE (compared->data));
 559
 560   compare (compared, track_object, TRUE);
 561
 562   calculate_next_transition_with_list (track_object, tckobjs_in_layer, layer);
 563
 564 done:
 565   g_list_foreach (tckobjs_in_layer, (GFunc) g_object_unref, NULL);
 566   g_list_free (tckobjs_in_layer);
 567 }
 568
 569
 570 /* Compare:
 571  * @compared: The #GList of #GESTrackObjects that we compare with @track_object
 572  * @track_object: The #GESTrackObject that serves as a reference
 573  * @ahead: %TRUE if we are comparing frontward %FALSE if we are comparing
 574  * backward*/
 575 static void
 576 compare (GList * compared, GESTrackObject * track_object, gboolean ahead)
 577 {
 578   GList *tmp;
 579   gint64 start, duration, compared_start, compared_duration, end, compared_end,
 580       tr_start, tr_duration;
 581   GESTimelineStandardTransition *trans = NULL;
 582   GESTrack *track;
 583   GESTimelineLayer *layer;
 584   GESTimelineObject *object, *compared_object, *first_object, *second_object;
 585   gint priority;
 586
 587   g_return_if_fail (compared);
 588
 589   GST_DEBUG ("Recalculating transitions");
 590
 591   object = ges_track_object_get_timeline_object (track_object);
 592
 593   if (!object) {
 594     GST_WARNING ("Trackobject not in a timeline object: "
 595         "Can not calulate transitions");
 596
 597     return;
 598   }
 599
 600   compared_object = ges_track_object_get_timeline_object (compared->data);
 601   layer = ges_timeline_object_get_layer (object);
 602
 603   start = ges_track_object_get_start (track_object);
 604   duration = ges_track_object_get_duration (track_object);
 605   compared_start = ges_track_object_get_start (compared->data);
 606   compared_duration = ges_track_object_get_duration (compared->data);
 607   end = start + duration;
 608   compared_end = compared_start + compared_duration;
 609
 610   if (ahead) {
 611     /* Make sure we remove the last transition we created it is not needed
 612      * FIXME make it a smarter way */
 613     if (compared->prev && GES_IS_TRACK_TRANSITION (compared->prev->data)) {
 614       trans = GES_TIMELINE_STANDARD_TRANSITION
 615           (ges_track_object_get_timeline_object (compared->prev->data));
 616       g_object_get (compared->prev->data, "start", &tr_start, "duration",
 617           &tr_duration, NULL);
 618       if (tr_start >= compared_start && tr_start + tr_duration <= compared_end)
 619         ges_timeline_layer_remove_object (layer, GES_TIMELINE_OBJECT (trans));
 620       trans = NULL;
 621     }
 622
 623     for (tmp = compared->next; tmp; tmp = tmp->next) {
 624       /* If we have a transitionmnmnm we recaluculuculate its values */
 625       if (GES_IS_TRACK_TRANSITION (tmp->data)) {
 626         g_object_get (tmp->data, "start", &tr_start, "duration", &tr_duration,
 627             NULL);
 628
 629         if (tr_start + tr_duration == compared_start + compared_duration) {
 630           GESTimelineObject *tlobj;
 631           tlobj = ges_track_object_get_timeline_object (tmp->data);
 632
 633           trans = GES_TIMELINE_STANDARD_TRANSITION (tlobj);
 634           break;
 635         }
 636       }
 637     }
 638
 639     if (compared_end <= start) {
 640       if (trans) {
 641         ges_timeline_layer_remove_object (layer, GES_TIMELINE_OBJECT (trans));
 642         g_object_get (compared_object, "priority", &priority, NULL);
 643         g_object_set (object, "priority", priority, NULL);
 644       }
 645
 646       goto clean;
 647     } else if (start > compared_start && end < compared_end) {
 648       if (trans) {
 649         /* Transition not needed anymore */
 650         ges_timeline_layer_remove_object (layer, GES_TIMELINE_OBJECT (trans));
 651       }
 652       goto clean;
 653     } else if (start <= compared_start) {
 654       if (trans) {
 655         ges_timeline_layer_remove_object (layer, GES_TIMELINE_OBJECT (trans));
 656       }
 657
 658       goto clean;
 659     }
 660
 661   } else {
 662     if (compared->next && GES_IS_TRACK_TRANSITION (compared->next->data)) {
 663       trans = GES_TIMELINE_STANDARD_TRANSITION
 664           (ges_track_object_get_timeline_object (compared->next->data));
 665       g_object_get (compared->prev->data, "start", &tr_start, "duration",
 666           &tr_duration, NULL);
 667       if (tr_start >= compared_start && tr_start + tr_duration <= compared_end)
 668         ges_timeline_layer_remove_object (layer, GES_TIMELINE_OBJECT (trans));
 669       trans = NULL;
 670     }
 671     for (tmp = compared->prev; tmp; tmp = tmp->prev) {
 672       if GES_IS_TRACK_TRANSITION
 673         (tmp->data) {
 674         g_object_get (tmp->data, "start", &tr_start, "duration", &tr_duration,
 675             NULL);
 676         if (tr_start == compared_start) {
 677           trans = GES_TIMELINE_STANDARD_TRANSITION
 678               (ges_track_object_get_timeline_object (tmp->data));
 679           break;
 680         }
 681         }
 682     }
 683
 684     if (start + duration <= compared_start) {
 685       if (trans) {
 686         ges_timeline_layer_remove_object (layer, GES_TIMELINE_OBJECT (trans));
 687         g_object_get (object, "priority", &priority, NULL);
 688         g_object_set (compared_object, "priority", priority, NULL);
 689       }
 690       goto clean;
 691
 692     } else if (start > compared_start) {
 693       if (trans)
 694         ges_timeline_layer_remove_object (layer, GES_TIMELINE_OBJECT (trans));
 695
 696       goto clean;
 697     } else if (start < compared_start && end > compared_end) {
 698       if (trans) {
 699         ges_timeline_layer_remove_object (layer, GES_TIMELINE_OBJECT (trans));
 700       }
 701
 702       goto clean;
 703     }
 704   }
 705
 706   if (!trans) {
 707     gint height;
 708
 709     trans =
 710         ges_timeline_standard_transition_new_for_nick ((gchar *) "crossfade");
 711     track = ges_track_object_get_track (track_object);
 712
 713     ges_timeline_object_set_supported_formats (GES_TIMELINE_OBJECT (trans),
 714         track->type);
 715
 716     ges_timeline_layer_add_object (layer, GES_TIMELINE_OBJECT (trans));
 717
 718     if (ahead) {
 719       first_object = ges_track_object_get_timeline_object (compared->data);
 720       second_object = object;
 721     } else {
 722       second_object = ges_track_object_get_timeline_object (compared->data);
 723       first_object = object;
 724     }
 725
 726     g_object_get (first_object, "priority", &priority, "height", &height, NULL);
 727     g_object_set (second_object, "priority", priority + height, NULL);
 728     g_signal_connect (first_object, "notify::height",
 729         (GCallback) timeline_object_height_changed_cb, second_object);
 730   }
 731
 732   if (ahead) {
 733     g_object_set (trans, "start", start, "duration",
 734         compared_duration + compared_start - start, NULL);
 735   } else {
 736     g_object_set (trans, "start", compared_start, "duration",
 737         start + duration - compared_start, NULL);
 738   }
 739
 740 clean:
 741   g_object_unref (layer);
 742 }
 743
 744 static void
 745 look_for_transition (GESTrackObject * track_object, GESTimelineLayer * layer)
 746 {
 747   GESTrack *track;
 748   GList *track_objects, *tmp, *cur;
 749
 750   track = ges_track_object_get_track (track_object);
 751
 752   track_objects = ges_track_get_objects (track);
 753
 754   cur = g_list_find (track_objects, track_object);
 755
 756   for (tmp = cur->next; tmp; tmp = tmp->next) {
 757     if (GES_IS_TRACK_SOURCE (tmp->data)) {
 758       break;
 759     }
 760     if (GES_IS_TRACK_AUDIO_TRANSITION (tmp->data)
 761         || GES_IS_TRACK_VIDEO_TRANSITION (tmp->data)) {
 762       ges_timeline_layer_remove_object (layer,
 763           ges_track_object_get_timeline_object (tmp->data));
 764     }
 765   }
 766
 767   for (tmp = cur->prev; tmp; tmp = tmp->prev) {
 768     if (GES_IS_TRACK_SOURCE (tmp->data)) {
 769       break;
 770     }
 771     if (GES_IS_TRACK_AUDIO_TRANSITION (tmp->data)
 772         || GES_IS_TRACK_VIDEO_TRANSITION (tmp->data)) {
 773       ges_timeline_layer_remove_object (layer,
 774           ges_track_object_get_timeline_object (tmp->data));
 775     }
 776   }
 777   g_list_foreach (track_objects, (GFunc) g_object_unref, NULL);
 778   g_list_free (track_objects);
 779 }
 780
 781 static gboolean
 782 disconnect_handlers (GESTrack * track, gpointer * ptr)
 783 {
 784   g_signal_handler_disconnect (track, GPOINTER_TO_INT (ptr));
 785
 786   return TRUE;
 787 }
 788
 789 /**
 790  * ges_timeline_layer_remove_object:
 791  * @layer: a #GESTimelineLayer
 792  * @object: the #GESTimelineObject to remove
 793  *
 794  * Removes the given @object from the @layer and unparents it.
 795  * Unparenting it means the reference owned by @layer on the @object will be
 796  * removed. If you wish to use the @object after this function, make sure you
 797  * call g_object_ref() before removing it from the @layer.
 798  *
 799  * Returns: TRUE if the object could be removed, FALSE if the layer does
 800  * not want to remove the object.
 801  */
 802 gboolean
 803 ges_timeline_layer_remove_object (GESTimelineLayer * layer,
 804     GESTimelineObject * object)
 805 {
 806   GESTimelineLayer *tl_obj_layer;
 807   GList *trackobjects, *tmp;
 808
 809   g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), FALSE);
 810   g_return_val_if_fail (GES_IS_TIMELINE_OBJECT (object), FALSE);
 811
 812   GST_DEBUG ("layer:%p, object:%p", layer, object);
 813
 814   tl_obj_layer = ges_timeline_object_get_layer (object);
 815   if (G_UNLIKELY (tl_obj_layer != layer)) {
 816     GST_WARNING ("TimelineObject doesn't belong to this layer");
 817     if (tl_obj_layer != NULL)
 818       g_object_unref (tl_obj_layer);
 819     return FALSE;
 820   }
 821   g_object_unref (tl_obj_layer);
 822
 823   if (layer->priv->auto_transition) {
 824     trackobjects = ges_timeline_object_get_track_objects (object);
 825
 826     for (tmp = trackobjects; tmp; tmp = tmp->next) {
 827       look_for_transition (tmp->data, layer);
 828     }
 829
 830     g_list_foreach (trackobjects, (GFunc) g_object_unref, NULL);
 831     g_list_free (trackobjects);
 832   }
 833
 834   g_hash_table_foreach_remove (layer->priv->signal_table,
 835       (GHRFunc) disconnect_handlers, NULL);
 836
 837   /* emit 'object-removed' */
 838   g_signal_emit (layer, ges_timeline_layer_signals[OBJECT_REMOVED], 0, object);
 839
 840   /* inform the object it's no longer in a layer */
 841   ges_timeline_object_set_layer (object, NULL);
 842
 843   /* Remove it from our list of controlled objects */
 844   layer->priv->objects_start =
 845       g_list_remove (layer->priv->objects_start, object);
 846
 847   /* Remove our reference to the object */
 848   g_object_unref (object);
 849
 850   return TRUE;
 851 }
 852
 853 /**
 854  * ges_timeline_layer_resync_priorities:
 855  * @layer: a #GESTimelineLayer
 856  *
 857  * Resyncs the priorities of the objects controlled by @layer.
 858  * This method
 859  */
 860 gboolean
 861 ges_timeline_layer_resync_priorities (GESTimelineLayer * layer)
 862 {
 863   GList *tmp;
 864   GESTimelineObject *obj;
 865
 866   GST_DEBUG ("Resync priorities of %p", layer);
 867
 868   /* TODO : Inhibit composition updates while doing this.
 869    * Ideally we want to do it from an even higher level, but here will
 870    * do in the meantime. */
 871
 872   for (tmp = layer->priv->objects_start; tmp; tmp = tmp->next) {
 873     obj = GES_TIMELINE_OBJECT (tmp->data);
 874     ges_timeline_object_set_priority (obj, GES_TIMELINE_OBJECT_PRIORITY (obj));
 875   }
 876
 877   return TRUE;
 878 }
 879
 880 /**
 881  * ges_timeline_layer_set_priority:
 882  * @layer: a #GESTimelineLayer
 883  * @priority: the priority to set
 884  *
 885  * Sets the layer to the given @priority. See the documentation of the
 886  * priority property for more information.
 887  */
 888 void
 889 ges_timeline_layer_set_priority (GESTimelineLayer * layer, guint priority)
 890 {
 891   g_return_if_fail (GES_IS_TIMELINE_LAYER (layer));
 892
 893   GST_DEBUG ("layer:%p, priority:%d", layer, priority);
 894
 895   if (priority != layer->priv->priority) {
 896     layer->priv->priority = priority;
 897     layer->min_gnl_priority = (priority * LAYER_HEIGHT);
 898     layer->max_gnl_priority = ((priority + 1) * LAYER_HEIGHT) - 1;
 899
 900     ges_timeline_layer_resync_priorities (layer);
 901   }
 902 }
 903
 904 /**
 905  * ges_timeline_layer_get_auto_transition:
 906  * @layer: a #GESTimelineLayer
 907  *
 908  * Gets whether transitions are automatically added when objects
 909  * overlap or not.
 910  *
 911  * Returns: %TRUE if transitions are automatically added, else %FALSE.
 912  */
 913 gboolean
 914 ges_timeline_layer_get_auto_transition (GESTimelineLayer * layer)
 915 {
 916   g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), 0);
 917
 918   return layer->priv->auto_transition;
 919 }
 920
 921 /**
 922  * ges_timeline_layer_set_auto_transition:
 923  * @layer: a #GESTimelineLayer
 924  * @auto_transition: whether the auto_transition is active
 925  *
 926  * Sets the layer to the given @auto_transition. See the documentation of the
 927  * property auto_transition for more information.
 928  */
 929 void
 930 ges_timeline_layer_set_auto_transition (GESTimelineLayer * layer,
 931     gboolean auto_transition)
 932 {
 933
 934   GList *tmp;
 935   g_return_if_fail (GES_IS_TIMELINE_LAYER (layer));
 936
 937   if (auto_transition) {
 938     for (tmp = layer->priv->objects_start; tmp; tmp = tmp->next) {
 939       if (GES_IS_TIMELINE_SOURCE (tmp->data)) {
 940         g_signal_connect (G_OBJECT (tmp->data), "track-object-added",
 941             G_CALLBACK (track_object_added_cb), layer);
 942         g_signal_connect (G_OBJECT (tmp->data), "track-object-removed",
 943             G_CALLBACK (track_object_removed_cb), layer);
 944       }
 945     }
 946     /* FIXME calculate all the transitions at that time */
 947   }
 948   layer->priv->auto_transition = auto_transition;
 949 }
 950
 951 /**
 952  * ges_timeline_layer_get_priority:
 953  * @layer: a #GESTimelineLayer
 954  *
 955  * Get the priority of @layer within the timeline.
 956  *
 957  * Returns: The priority of the @layer within the timeline.
 958  */
 959 guint
 960 ges_timeline_layer_get_priority (GESTimelineLayer * layer)
 961 {
 962   g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), 0);
 963
 964   return layer->priv->priority;
 965 }
 966
 967 /**
 968  * ges_timeline_layer_get_objects:
 969  * @layer: a #GESTimelineLayer
 970  *
 971  * Get the timeline objects this layer contains.
 972  *
 973  * Returns: (transfer full) (element-type GESTimelineObject): a #GList of
 974  * timeline objects. The user is responsible for
 975  * unreffing the contained objects and freeing the list.
 976  */
 977
 978 GList *
 979 ges_timeline_layer_get_objects (GESTimelineLayer * layer)
 980 {
 981   GList *ret = NULL;
 982   GList *tmp;
 983   GESTimelineLayerClass *klass;
 984
 985   g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), NULL);
 986
 987   klass = GES_TIMELINE_LAYER_GET_CLASS (layer);
 988
 989   if (klass->get_objects) {
 990     return klass->get_objects (layer);
 991   }
 992
 993   for (tmp = layer->priv->objects_start; tmp; tmp = tmp->next) {
 994     ret = g_list_prepend (ret, tmp->data);
 995     g_object_ref (tmp->data);
 996   }
 997
 998   ret = g_list_reverse (ret);
 999   return ret;
1000 }
1001
1002 /**
1003  * ges_timeline_layer_is_empty:
1004  * @layer: The #GESTimelineLayer to check
1005  *
1006  * Convenience method to check if @layer is empty (doesn't contain any object),
1007  * or not.
1008  *
1009  * Returns: %TRUE if @layer is empty, %FALSE if it already contains at least
1010  * one #GESTimelineObject
1011  */
1012 gboolean
1013 ges_timeline_layer_is_empty (GESTimelineLayer * layer)
1014 {
1015   g_return_val_if_fail (GES_IS_TIMELINE_LAYER (layer), FALSE);
1016
1017   return (layer->priv->objects_start == NULL);
1018 }