ges/ges-track.c

   1 /* GStreamer Editing Services
   2  * Copyright (C) 2009 Edward Hervey <edward.hervey@collabora.co.uk>
   3  *               2009 Nokia Corporation
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * SECTION:ges-track
  23  * @short_description: Composition of objects
  24  *
  25  * Corresponds to one output format (i.e. audio OR video).
  26  *
  27  * Contains the compatible TrackObject(s).
  28  *
  29  * Wraps GNonLin's 'gnlcomposition' element.
  30  */
  31
  32 #include "ges-internal.h"
  33 #include "ges-track.h"
  34 #include "ges-track-object.h"
  35 #include "gesmarshal.h"
  36
  37 G_DEFINE_TYPE (GESTrack, ges_track, GST_TYPE_BIN);
  38
  39 struct _GESTrackPrivate
  40 {
  41   /*< private > */
  42   GESTimeline *timeline;
  43   GList *trackobjects;
  44   guint64 duration;
  45
  46   GstCaps *caps;
  47
  48   GstElement *composition;      /* The composition associated with this track */
  49   GstElement *background;       /* The backgrond, handle the gaps in the track */
  50   GstPad *srcpad;               /* The source GhostPad */
  51 };
  52
  53 enum
  54 {
  55   ARG_0,
  56   ARG_CAPS,
  57   ARG_TYPE,
  58   ARG_DURATION,
  59   ARG_LAST,
  60   TRACK_OBJECT_ADDED,
  61   TRACK_OBJECT_REMOVED,
  62   LAST_SIGNAL
  63 };
  64
  65 static guint ges_track_signals[LAST_SIGNAL] = { 0 };
  66
  67 static GParamSpec *properties[ARG_LAST];
  68
  69 static void pad_added_cb (GstElement * element, GstPad * pad, GESTrack * track);
  70 static void
  71 pad_removed_cb (GstElement * element, GstPad * pad, GESTrack * track);
  72 static void composition_duration_cb (GstElement * composition, GParamSpec * arg
  73     G_GNUC_UNUSED, GESTrack * obj);
  74 static void
  75 sort_track_objects_cb (GESTrackObject * child,
  76     GParamSpec * arg G_GNUC_UNUSED, GESTrack * track);
  77
  78 static void timeline_duration_cb (GESTimeline * timeline,
  79     GParamSpec * arg G_GNUC_UNUSED, GESTrack * track);
  80
  81 static void
  82 ges_track_get_property (GObject * object, guint property_id,
  83     GValue * value, GParamSpec * pspec)
  84 {
  85   GESTrack *track = GES_TRACK (object);
  86
  87   switch (property_id) {
  88     case ARG_CAPS:
  89       gst_value_set_caps (value, track->priv->caps);
  90       break;
  91     case ARG_TYPE:
  92       g_value_set_flags (value, track->type);
  93       break;
  94     case ARG_DURATION:
  95       g_value_set_uint64 (value, track->priv->duration);
  96       break;
  97     default:
  98       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
  99   }
 100 }
 101
 102 static void
 103 ges_track_set_property (GObject * object, guint property_id,
 104     const GValue * value, GParamSpec * pspec)
 105 {
 106   GESTrack *track = GES_TRACK (object);
 107
 108   switch (property_id) {
 109     case ARG_CAPS:
 110       ges_track_set_caps (track, gst_value_get_caps (value));
 111       break;
 112     case ARG_TYPE:
 113       track->type = g_value_get_flags (value);
 114       break;
 115     default:
 116       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 117   }
 118 }
 119
 120 static void
 121 ges_track_dispose (GObject * object)
 122 {
 123   GESTrack *track = (GESTrack *) object;
 124   GESTrackPrivate *priv = track->priv;
 125
 126   while (priv->trackobjects) {
 127     GESTrackObject *trobj = GES_TRACK_OBJECT (priv->trackobjects->data);
 128     ges_track_remove_object (track, trobj);
 129     ges_timeline_object_release_track_object ((GESTimelineObject *)
 130         ges_track_object_get_timeline_object (trobj), trobj);
 131   }
 132
 133   if (priv->composition) {
 134     gst_bin_remove (GST_BIN (object), priv->composition);
 135     priv->composition = NULL;
 136   }
 137
 138   if (priv->caps) {
 139     gst_caps_unref (priv->caps);
 140     priv->caps = NULL;
 141   }
 142
 143   G_OBJECT_CLASS (ges_track_parent_class)->dispose (object);
 144 }
 145
 146 static void
 147 ges_track_constructed (GObject * object)
 148 {
 149   GObjectClass *parent_class;
 150   GstElement *background = NULL;
 151   GESTrack *self = GES_TRACK (object);
 152   GESTrackPrivate *priv = self->priv;
 153
 154   if ((priv->background = gst_element_factory_make ("gnlsource", "background"))) {
 155     g_object_set (priv->background, "priority", G_MAXUINT, NULL);
 156
 157     switch (self->type) {
 158       case GES_TRACK_TYPE_VIDEO:
 159         background = gst_element_factory_make ("videotestsrc", "background");
 160         g_object_set (background, "pattern", 2, NULL);
 161         break;
 162       case GES_TRACK_TYPE_AUDIO:
 163         background = gst_element_factory_make ("audiotestsrc", "background");
 164         g_object_set (background, "wave", 4, NULL);
 165         break;
 166       default:
 167         break;
 168     }
 169
 170     if (background) {
 171       if (!gst_bin_add (GST_BIN (priv->background), background))
 172         GST_ERROR ("Couldn't add background");
 173       else {
 174         if (!gst_bin_add (GST_BIN (priv->composition), priv->background))
 175           GST_ERROR ("Couldn't add background");
 176       }
 177
 178     }
 179   }
 180
 181   parent_class = ges_track_parent_class;
 182   if (parent_class->constructed)
 183     parent_class->constructed (object);
 184
 185   G_OBJECT_CLASS (parent_class)->constructed (object);
 186 }
 187
 188 static void
 189 ges_track_finalize (GObject * object)
 190 {
 191   G_OBJECT_CLASS (ges_track_parent_class)->finalize (object);
 192 }
 193
 194 static void
 195 ges_track_class_init (GESTrackClass * klass)
 196 {
 197   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 198
 199   g_type_class_add_private (klass, sizeof (GESTrackPrivate));
 200
 201   object_class->get_property = ges_track_get_property;
 202   object_class->set_property = ges_track_set_property;
 203   object_class->dispose = ges_track_dispose;
 204   object_class->finalize = ges_track_finalize;
 205   object_class->constructed = ges_track_constructed;
 206
 207   /**
 208    * GESTrack:caps
 209    *
 210    * Caps used to filter/choose the output stream. This is generally set to
 211    * a generic set of caps like 'video/x-raw' for raw video.
 212    *
 213    * Default value: #GST_CAPS_ANY.
 214    */
 215   properties[ARG_CAPS] = g_param_spec_boxed ("caps", "Caps",
 216       "Caps used to filter/choose the output stream",
 217       GST_TYPE_CAPS, G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
 218   g_object_class_install_property (object_class, ARG_CAPS,
 219       properties[ARG_CAPS]);
 220
 221   /**
 222    * GESTrack:duration
 223    *
 224    * Current duration of the track
 225    *
 226    * Default value: O
 227    */
 228   properties[ARG_DURATION] = g_param_spec_uint64 ("duration", "Duration",
 229       "The current duration of the track", 0, G_MAXUINT64, GST_SECOND,
 230       G_PARAM_READABLE);
 231   g_object_class_install_property (object_class, ARG_DURATION,
 232       properties[ARG_DURATION]);
 233
 234   /**
 235    * GESTrack:track-type
 236    *
 237    * Type of stream the track outputs. This is used when creating the #GESTrack
 238    * to specify in generic terms what type of content will be outputted.
 239    *
 240    * It also serves as a 'fast' way to check what type of data will be outputted
 241    * from the #GESTrack without having to actually check the #GESTrack's caps
 242    * property.
 243    */
 244   properties[ARG_TYPE] = g_param_spec_flags ("track-type", "TrackType",
 245       "Type of stream the track outputs",
 246       GES_TYPE_TRACK_TYPE, GES_TRACK_TYPE_CUSTOM,
 247       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
 248   g_object_class_install_property (object_class, ARG_TYPE,
 249       properties[ARG_TYPE]);
 250
 251   /**
 252    * GESTrack::track-object-added
 253    * @object: the #GESTrack
 254    * @effect: the #GESTrackObject that was added.
 255    *
 256    * Will be emitted after a track object was added to the track.
 257    *
 258    * Since: 0.10.2
 259    */
 260   ges_track_signals[TRACK_OBJECT_ADDED] =
 261       g_signal_new ("track-object-added", G_TYPE_FROM_CLASS (klass),
 262       G_SIGNAL_RUN_FIRST, 0, NULL, NULL, ges_marshal_VOID__OBJECT,
 263       G_TYPE_NONE, 1, GES_TYPE_TRACK_OBJECT);
 264
 265   /**
 266    * GESTrack::track-object-removed
 267    * @object: the #GESTrack
 268    * @effect: the #GESTrackObject that was removed.
 269    *
 270    * Will be emitted after a track object was removed from the track.
 271    *
 272    * Since: 0.10.2
 273    */
 274   ges_track_signals[TRACK_OBJECT_REMOVED] =
 275       g_signal_new ("track-object-removed", G_TYPE_FROM_CLASS (klass),
 276       G_SIGNAL_RUN_FIRST, 0, NULL, NULL, ges_marshal_VOID__OBJECT,
 277       G_TYPE_NONE, 1, GES_TYPE_TRACK_OBJECT);
 278 }
 279
 280 static void
 281 ges_track_init (GESTrack * self)
 282 {
 283   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 284       GES_TYPE_TRACK, GESTrackPrivate);
 285
 286   self->priv->composition = gst_element_factory_make ("gnlcomposition", NULL);
 287
 288   g_signal_connect (G_OBJECT (self->priv->composition), "notify::duration",
 289       G_CALLBACK (composition_duration_cb), self);
 290   g_signal_connect (self->priv->composition, "pad-added",
 291       (GCallback) pad_added_cb, self);
 292   g_signal_connect (self->priv->composition, "pad-removed",
 293       (GCallback) pad_removed_cb, self);
 294
 295   if (!gst_bin_add (GST_BIN (self), self->priv->composition))
 296     GST_ERROR ("Couldn't add composition to bin !");
 297 }
 298
 299 /**
 300  * ges_track_new:
 301  * @type: The type of track
 302  * @caps: (transfer full): The caps to restrict the output of the track to.
 303  *
 304  * Creates a new #GESTrack with the given @type and @caps.
 305  *
 306  * The newly created track will steal a reference to the caps. If you wish to
 307  * use those caps elsewhere, you will have to take an extra reference.
 308  *
 309  * Returns: A new #GESTrack.
 310  */
 311 GESTrack *
 312 ges_track_new (GESTrackType type, GstCaps * caps)
 313 {
 314   GESTrack *track;
 315
 316   track = g_object_new (GES_TYPE_TRACK, "caps", caps, "track-type", type, NULL);
 317   gst_caps_unref (caps);
 318
 319   return track;
 320 }
 321
 322 /**
 323  * ges_track_video_raw_new:
 324  *
 325  * Creates a new #GESTrack of type #GES_TRACK_TYPE_VIDEO and with generic
 326  * raw video caps ("video/x-raw");
 327  *
 328  * Returns: A new #GESTrack.
 329  */
 330 GESTrack *
 331 ges_track_video_raw_new (void)
 332 {
 333   GESTrack *track;
 334   GstCaps *caps = gst_caps_new_empty_simple ("video/x-raw");
 335
 336   track = ges_track_new (GES_TRACK_TYPE_VIDEO, caps);
 337
 338   return track;
 339 }
 340
 341 /**
 342  * ges_track_audio_raw_new:
 343  *
 344  * Creates a new #GESTrack of type #GES_TRACK_TYPE_AUDIO and with generic
 345  * raw audio caps ("audio/x-raw");
 346  *
 347  * Returns: A new #GESTrack.
 348  */
 349 GESTrack *
 350 ges_track_audio_raw_new (void)
 351 {
 352   GESTrack *track;
 353   GstCaps *caps = gst_caps_new_empty_simple ("audio/x-raw");
 354
 355   track = ges_track_new (GES_TRACK_TYPE_AUDIO, caps);
 356
 357   return track;
 358 }
 359
 360 /**
 361  * ges_track_set_timeline:
 362  * @track: a #GESTrack
 363  * @timeline: a #GESTimeline
 364  *
 365  * Sets @timeline as the timeline controlling @track.
 366  */
 367 void
 368 ges_track_set_timeline (GESTrack * track, GESTimeline * timeline)
 369 {
 370   GST_DEBUG ("track:%p, timeline:%p", track, timeline);
 371
 372   if (track->priv->timeline)
 373     g_signal_handlers_disconnect_by_func (track,
 374         timeline_duration_cb, track->priv->timeline);
 375
 376   if (timeline)
 377     g_signal_connect (G_OBJECT (timeline), "notify::duration",
 378         G_CALLBACK (timeline_duration_cb), track);
 379
 380   track->priv->timeline = timeline;
 381 }
 382
 383 /**
 384  * ges_track_set_caps:
 385  * @track: a #GESTrack
 386  * @caps: the #GstCaps to set
 387  *
 388  * Sets the given @caps on the track.
 389  */
 390 void
 391 ges_track_set_caps (GESTrack * track, const GstCaps * caps)
 392 {
 393   GESTrackPrivate *priv;
 394
 395   g_return_if_fail (GES_IS_TRACK (track));
 396   g_return_if_fail (GST_IS_CAPS (caps));
 397
 398   GST_DEBUG ("track:%p, caps:%" GST_PTR_FORMAT, track, caps);
 399
 400   priv = track->priv;
 401
 402   if (priv->caps)
 403     gst_caps_unref (priv->caps);
 404   priv->caps = gst_caps_copy (caps);
 405
 406   g_object_set (priv->composition, "caps", caps, NULL);
 407   /* FIXME : update all trackobjects ? */
 408 }
 409
 410
 411 /* FIXME : put the compare function in the utils */
 412
 413 static gint
 414 objects_start_compare (GESTrackObject * a, GESTrackObject * b)
 415 {
 416   if (a->start == b->start) {
 417     if (a->priority < b->priority)
 418       return -1;
 419     if (a->priority > b->priority)
 420       return 1;
 421     return 0;
 422   }
 423   if (a->start < b->start)
 424     return -1;
 425   if (a->start > b->start)
 426     return 1;
 427   return 0;
 428 }
 429
 430 /**
 431  * ges_track_add_object:
 432  * @track: a #GESTrack
 433  * @object: (transfer full): the #GESTrackObject to add
 434  *
 435  * Adds the given object to the track. Sets the object's controlling track,
 436  * and thus takes ownership of the @object.
 437  *
 438  * An object can only be added to one track.
 439  *
 440  * Returns: #TRUE if the object was properly added. #FALSE if the track does not
 441  * want to accept the object.
 442  */
 443 gboolean
 444 ges_track_add_object (GESTrack * track, GESTrackObject * object)
 445 {
 446   g_return_val_if_fail (GES_IS_TRACK (track), FALSE);
 447   g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
 448
 449   GST_DEBUG ("track:%p, object:%p", track, object);
 450
 451   if (G_UNLIKELY (ges_track_object_get_track (object) != NULL)) {
 452     GST_WARNING ("Object already belongs to another track");
 453     return FALSE;
 454   }
 455
 456   /* At this point, the track object shouldn't have any gnlobject since
 457    * it hasn't been added to a track yet.
 458    * FIXME : This check seems a bit obsolete */
 459   if (G_UNLIKELY (ges_track_object_get_gnlobject (object) != NULL)) {
 460     GST_ERROR ("TrackObject already controls a gnlobject !");
 461     return FALSE;
 462   }
 463
 464   if (G_UNLIKELY (!ges_track_object_set_track (object, track))) {
 465     GST_ERROR ("Couldn't properly add the object to the Track");
 466     return FALSE;
 467   }
 468
 469   GST_DEBUG ("Adding object %s to ourself %s",
 470       GST_OBJECT_NAME (ges_track_object_get_gnlobject (object)),
 471       GST_OBJECT_NAME (track->priv->composition));
 472
 473   if (G_UNLIKELY (!gst_bin_add (GST_BIN (track->priv->composition),
 474               ges_track_object_get_gnlobject (object)))) {
 475     GST_WARNING ("Couldn't add object to the GnlComposition");
 476     return FALSE;
 477   }
 478
 479   g_object_ref_sink (object);
 480   track->priv->trackobjects =
 481       g_list_insert_sorted (track->priv->trackobjects, object,
 482       (GCompareFunc) objects_start_compare);
 483
 484   g_signal_emit (track, ges_track_signals[TRACK_OBJECT_ADDED], 0,
 485       GES_TRACK_OBJECT (object));
 486
 487   g_signal_connect (GES_TRACK_OBJECT (object), "notify::start",
 488       G_CALLBACK (sort_track_objects_cb), track);
 489
 490   g_signal_connect (GES_TRACK_OBJECT (object), "notify::priority",
 491       G_CALLBACK (sort_track_objects_cb), track);
 492
 493   return TRUE;
 494 }
 495
 496 /**
 497  * ges_track_get_objects:
 498  * @track: a #GESTrack
 499  *
 500  * Gets the #GESTrackObject contained in @track
 501  *
 502  * Returns: (transfer full) (element-type GESTrackObject): the list of
 503  * #GESTrackObject present in the Track sorted by priority and start.
 504  */
 505 GList *
 506 ges_track_get_objects (GESTrack * track)
 507 {
 508   GList *ret = NULL;
 509   GList *tmp;
 510
 511   g_return_val_if_fail (GES_IS_TRACK (track), NULL);
 512
 513   for (tmp = track->priv->trackobjects; tmp; tmp = tmp->next) {
 514     ret = g_list_prepend (ret, tmp->data);
 515     g_object_ref (tmp->data);
 516   }
 517
 518   ret = g_list_reverse (ret);
 519   return ret;
 520 }
 521
 522 /**
 523  * ges_track_remove_object:
 524  * @track: a #GESTrack
 525  * @object: the #GESTrackObject to remove
 526  *
 527  * Removes the object from the track and unparents it.
 528  * Unparenting it means the reference owned by @track on the @object will be
 529  * removed. If you wish to use the @object after this function, make sure you
 530  * call g_object_ref() before removing it from the @track.
 531  *
 532  * Returns: #TRUE if the object was removed, else #FALSE if the track
 533  * could not remove the object (like if it didn't belong to the track).
 534  */
 535 gboolean
 536 ges_track_remove_object (GESTrack * track, GESTrackObject * object)
 537 {
 538   GESTrackPrivate *priv;
 539   GstElement *gnlobject;
 540
 541   g_return_val_if_fail (GES_IS_TRACK (track), FALSE);
 542   g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
 543
 544   GST_DEBUG ("track:%p, object:%p", track, object);
 545
 546   priv = track->priv;
 547
 548   if (G_UNLIKELY (ges_track_object_get_track (object) != track)) {
 549     GST_WARNING ("Object belongs to another track");
 550     return FALSE;
 551   }
 552
 553   if ((gnlobject = ges_track_object_get_gnlobject (object))) {
 554     GST_DEBUG ("Removing GnlObject '%s' from composition '%s'",
 555         GST_ELEMENT_NAME (gnlobject), GST_ELEMENT_NAME (priv->composition));
 556     if (!gst_bin_remove (GST_BIN (priv->composition), gnlobject)) {
 557       GST_WARNING ("Failed to remove gnlobject from composition");
 558       return FALSE;
 559     }
 560   }
 561
 562   g_signal_handlers_disconnect_by_func (object, sort_track_objects_cb, NULL);
 563
 564   ges_track_object_set_track (object, NULL);
 565
 566   g_signal_emit (track, ges_track_signals[TRACK_OBJECT_REMOVED], 0,
 567       GES_TRACK_OBJECT (object));
 568
 569   priv->trackobjects = g_list_remove (priv->trackobjects, object);
 570
 571   g_object_unref (object);
 572
 573   return TRUE;
 574 }
 575
 576 static void
 577 pad_added_cb (GstElement * element, GstPad * pad, GESTrack * track)
 578 {
 579   GESTrackPrivate *priv = track->priv;
 580
 581   GST_DEBUG ("track:%p, pad %s:%s", track, GST_DEBUG_PAD_NAME (pad));
 582
 583   /* ghost the pad */
 584   priv->srcpad = gst_ghost_pad_new ("src", pad);
 585
 586   gst_pad_set_active (priv->srcpad, TRUE);
 587
 588   gst_element_add_pad (GST_ELEMENT (track), priv->srcpad);
 589
 590   GST_DEBUG ("done");
 591 }
 592
 593 static void
 594 pad_removed_cb (GstElement * element, GstPad * pad, GESTrack * track)
 595 {
 596   GESTrackPrivate *priv = track->priv;
 597
 598   GST_DEBUG ("track:%p, pad %s:%s", track, GST_DEBUG_PAD_NAME (pad));
 599
 600   if (G_LIKELY (priv->srcpad)) {
 601     gst_pad_set_active (priv->srcpad, FALSE);
 602     gst_element_remove_pad (GST_ELEMENT (track), priv->srcpad);
 603     priv->srcpad = NULL;
 604   }
 605
 606   GST_DEBUG ("done");
 607 }
 608
 609 static void
 610 composition_duration_cb (GstElement * composition,
 611     GParamSpec * arg G_GNUC_UNUSED, GESTrack * obj)
 612 {
 613   guint64 duration;
 614
 615   g_object_get (composition, "duration", &duration, NULL);
 616
 617
 618   if (obj->priv->duration != duration) {
 619     GST_DEBUG ("composition duration : %" GST_TIME_FORMAT " current : %"
 620         GST_TIME_FORMAT, GST_TIME_ARGS (duration),
 621         GST_TIME_ARGS (obj->priv->duration));
 622
 623     obj->priv->duration = duration;
 624
 625 #if GLIB_CHECK_VERSION(2,26,0)
 626     g_object_notify_by_pspec (G_OBJECT (obj), properties[ARG_DURATION]);
 627 #else
 628     g_object_notify (G_OBJECT (obj), "duration");
 629 #endif
 630   }
 631 }
 632
 633 static void
 634 sort_track_objects_cb (GESTrackObject * child,
 635     GParamSpec * arg G_GNUC_UNUSED, GESTrack * track)
 636 {
 637   track->priv->trackobjects =
 638       g_list_sort (track->priv->trackobjects,
 639       (GCompareFunc) objects_start_compare);
 640 }
 641
 642 static void
 643 timeline_duration_cb (GESTimeline * timeline,
 644     GParamSpec * arg G_GNUC_UNUSED, GESTrack * track)
 645 {
 646   guint64 duration;
 647
 648   g_object_get (timeline, "duration", &duration, NULL);
 649   g_object_set (GES_TRACK (track)->priv->background, "duration", duration,
 650       NULL);
 651
 652   GST_DEBUG_OBJECT (track, "Updating background duration to %" GST_TIME_FORMAT,
 653       GST_TIME_ARGS (duration));
 654 }
 655
 656 /**
 657  * ges_track_get_caps:
 658  * @track: a #GESTrack
 659  *
 660  * Get the #GstCaps this track is configured to output.
 661  *
 662  * Returns: The #GstCaps this track is configured to output.
 663  */
 664 const GstCaps *
 665 ges_track_get_caps (GESTrack * track)
 666 {
 667   g_return_val_if_fail (GES_IS_TRACK (track), NULL);
 668
 669   return track->priv->caps;
 670 }
 671
 672 /**
 673  * ges_track_get_timeline:
 674  * @track: a #GESTrack
 675  *
 676  * Get the #GESTimeline this track belongs to. Can be %NULL.
 677  *
 678  * Returns: The #GESTimeline this track belongs to. Can be %NULL.
 679  */
 680 const GESTimeline *
 681 ges_track_get_timeline (GESTrack * track)
 682 {
 683   g_return_val_if_fail (GES_IS_TRACK (track), NULL);
 684
 685   return track->priv->timeline;
 686 }
 687
 688 /**
 689  * ges_track_enable_update:
 690  * @track: a #GESTrack
 691  * @enabled: Whether the track should update on every change or not.
 692  *
 693  * Control whether the track is updated for every change happening within.
 694  *
 695  * Users will want to use this method with %FALSE before doing lots of changes,
 696  * and then call again with %TRUE for the changes to take effect in one go.
 697  *
 698  * Returns: %TRUE if the update status could be changed, else %FALSE.
 699  */
 700 gboolean
 701 ges_track_enable_update (GESTrack * track, gboolean enabled)
 702 {
 703   gboolean update;
 704
 705   g_object_set (track->priv->composition, "update", enabled, NULL);
 706
 707   g_object_get (track->priv->composition, "update", &update, NULL);
 708
 709   if (update == enabled) {
 710     return TRUE;
 711   } else {
 712     return FALSE;
 713   }
 714 }