ges/ges-project.c

   1 /* GStreamer Editing Services
   2  *
   3  * Copyright (C) <2012> Thibault Saunier <thibault.saunier@collabora.com>
   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  * SECTION: gesproject
  22  * @short_description: A GESAsset that is used to manage projects
  23  *
  24  * The #GESProject is used to control a set of #GESAsset and is a
  25  * #GESAsset with #GES_TYPE_TIMELINE as @extractable_type itself. That
  26  * means that you can extract #GESTimeline from a project as followed:
  27  *
  28  * |[
  29  *  GESProject *project;
  30  *  GESTimeline *timeline;
  31  *
  32  *  project = ges_project_new ("file:///path/to/a/valid/project/uri");
  33  *
  34  *  // Here you can connect to the various signal to get more infos about
  35  *  // what is happening and recover from errors if possible
  36  *  ...
  37  *
  38  *  timeline = ges_asset_extract (GES_ASSET (project));
  39  * ]|
  40  *
  41  * The #GESProject class offers a higher level API to handle #GESAsset-s.
  42  * It lets you request new asset, and it informs you about new assets through
  43  * a set of signals. Also it handles problem such as missing files/missing
  44  * #GstElement and lets you try to recover from those.
  45  */
  46 #include "ges.h"
  47 #include "ges-internal.h"
  48
  49 static GPtrArray *new_paths = NULL;
  50 static GHashTable *tried_uris = NULL;
  51
  52 /* TODO We should rely on both extractable_type and @id to identify
  53  * a Asset, not only @id
  54  */
  55 G_DEFINE_TYPE (GESProject, ges_project, GES_TYPE_ASSET);
  56
  57 struct _GESProjectPrivate
  58 {
  59   GHashTable *assets;
  60   /* Set of asset ID being loaded */
  61   GHashTable *loading_assets;
  62   GHashTable *loaded_with_error;
  63   GESAsset *formatter_asset;
  64
  65   GList *formatters;
  66
  67   gchar *uri;
  68
  69   GList *encoding_profiles;
  70 };
  71
  72 typedef struct EmitLoadedInIdle
  73 {
  74   GESProject *project;
  75   GESTimeline *timeline;
  76 } EmitLoadedInIdle;
  77
  78 enum
  79 {
  80   LOADED_SIGNAL,
  81   ERROR_LOADING_ASSET,
  82   ASSET_ADDED_SIGNAL,
  83   ASSET_REMOVED_SIGNAL,
  84   MISSING_URI_SIGNAL,
  85   ASSET_LOADING_SIGNAL,
  86   LAST_SIGNAL
  87 };
  88
  89 static guint _signals[LAST_SIGNAL] = { 0 };
  90
  91 static guint nb_projects = 0;
  92
  93 enum
  94 {
  95   PROP_0,
  96   PROP_URI,
  97   PROP_LAST,
  98 };
  99
 100 static GParamSpec *_properties[LAST_SIGNAL] = { 0 };
 101
 102 static gboolean
 103 _emit_loaded_in_idle (EmitLoadedInIdle * data)
 104 {
 105   g_signal_emit (data->project, _signals[LOADED_SIGNAL], 0, data->timeline);
 106
 107   gst_object_unref (data->project);
 108   gst_object_unref (data->timeline);
 109   g_slice_free (EmitLoadedInIdle, data);
 110
 111   return FALSE;
 112 }
 113
 114 static void
 115 ges_project_add_formatter (GESProject * project, GESFormatter * formatter)
 116 {
 117   GESProjectPrivate *priv = GES_PROJECT (project)->priv;
 118
 119   ges_formatter_set_project (formatter, project);
 120   priv->formatters = g_list_append (priv->formatters, formatter);
 121
 122   gst_object_ref_sink (formatter);
 123 }
 124
 125 static void
 126 ges_project_remove_formatter (GESProject * project, GESFormatter * formatter)
 127 {
 128   GList *tmp;
 129   GESProjectPrivate *priv = GES_PROJECT (project)->priv;
 130
 131   for (tmp = priv->formatters; tmp; tmp = tmp->next) {
 132     if (tmp->data == formatter) {
 133       gst_object_unref (formatter);
 134       priv->formatters = g_list_delete_link (priv->formatters, tmp);
 135
 136       return;
 137     }
 138   }
 139 }
 140
 141 static void
 142 ges_project_set_uri (GESProject * project, const gchar * uri)
 143 {
 144   GESProjectPrivate *priv;
 145
 146   g_return_if_fail (GES_IS_PROJECT (project));
 147
 148   priv = project->priv;
 149   if (priv->uri) {
 150     GST_WARNING_OBJECT (project, "Trying to rest URI, this is prohibited");
 151
 152     return;
 153   }
 154
 155   if (uri == NULL) {
 156     GST_LOG_OBJECT (project, "Uri should not be NULL");
 157     return;
 158   }
 159
 160   priv->uri = g_strdup (uri);
 161
 162   /* We use that URI as ID */
 163   ges_asset_set_id (GES_ASSET (project), uri);
 164
 165   return;
 166 }
 167
 168 static gboolean
 169 _load_project (GESProject * project, GESTimeline * timeline, GError ** error)
 170 {
 171   GError *lerr = NULL;
 172   GESProjectPrivate *priv;
 173   GESFormatter *formatter;
 174
 175   priv = GES_PROJECT (project)->priv;
 176
 177   if (priv->uri == NULL) {
 178     EmitLoadedInIdle *data = g_slice_new (EmitLoadedInIdle);
 179
 180     GST_LOG_OBJECT (project, "%s, Loading an empty timeline %s"
 181         " as no URI set yet", GST_OBJECT_NAME (timeline),
 182         ges_asset_get_id (GES_ASSET (project)));
 183
 184     data->timeline = gst_object_ref (timeline);
 185     data->project = gst_object_ref (project);
 186
 187     /* Make sure the signal is emitted after the functions ends */
 188     g_idle_add ((GSourceFunc) _emit_loaded_in_idle, data);
 189     return TRUE;
 190   }
 191
 192   if (priv->formatter_asset == NULL)
 193     priv->formatter_asset = _find_formatter_asset_for_id (priv->uri);
 194
 195   if (priv->formatter_asset == NULL) {
 196     lerr = g_error_new (GES_ERROR, 0, "Could not find a suitable formatter");
 197     goto failed;
 198   }
 199
 200   formatter = GES_FORMATTER (ges_asset_extract (priv->formatter_asset, &lerr));
 201   if (lerr) {
 202     GST_WARNING_OBJECT (project, "Could not create the formatter: %s",
 203         lerr->message);
 204
 205     goto failed;
 206   }
 207
 208   ges_project_add_formatter (GES_PROJECT (project), formatter);
 209   ges_formatter_load_from_uri (formatter, timeline, priv->uri, &lerr);
 210   if (lerr) {
 211     GST_WARNING_OBJECT (project, "Could not load the timeline,"
 212         " returning: %s", lerr->message);
 213     goto failed;
 214   }
 215
 216   return TRUE;
 217
 218 failed:
 219   if (lerr)
 220     g_propagate_error (error, lerr);
 221   return FALSE;
 222 }
 223
 224 static gboolean
 225 _uri_missing_accumulator (GSignalInvocationHint * ihint, GValue * return_accu,
 226     const GValue * handler_return, gpointer data)
 227 {
 228   const gchar *ret = g_value_get_string (handler_return);
 229
 230   if (ret) {
 231     if (!gst_uri_is_valid (ret)) {
 232       GST_INFO ("The uri %s was not valid, can not work with it!", ret);
 233       return TRUE;
 234     }
 235
 236     g_value_set_string (return_accu, ret);
 237     return FALSE;
 238   }
 239
 240   return TRUE;
 241 }
 242
 243 /* GESAsset vmethod implementation */
 244 static GESExtractable *
 245 ges_project_extract (GESAsset * project, GError ** error)
 246 {
 247   GESTimeline *timeline = g_object_new (GES_TYPE_TIMELINE, NULL);
 248
 249   ges_extractable_set_asset (GES_EXTRACTABLE (timeline), GES_ASSET (project));
 250   if (_load_project (GES_PROJECT (project), timeline, error))
 251     return GES_EXTRACTABLE (timeline);
 252
 253   gst_object_unref (timeline);
 254   return NULL;
 255 }
 256
 257 static void
 258 _add_media_new_paths_recursing (const gchar * value)
 259 {
 260   GFileInfo *info;
 261   GFileEnumerator *fenum;
 262   GFile *file = g_file_new_for_uri (value);
 263
 264   if (!(fenum = g_file_enumerate_children (file,
 265               "standard::*", G_FILE_QUERY_INFO_NONE, NULL, NULL))) {
 266     GST_INFO ("%s is not a folder", value);
 267
 268     goto done;
 269   }
 270
 271   GST_INFO ("Adding folder: %s", value);
 272   g_ptr_array_add (new_paths, g_strdup (value));
 273   info = g_file_enumerator_next_file (fenum, NULL, NULL);
 274   while (info != NULL) {
 275     if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY) {
 276       GFile *f = g_file_enumerator_get_child (fenum, info);
 277       gchar *uri = g_file_get_uri (f);
 278
 279       _add_media_new_paths_recursing (uri);
 280       gst_object_unref (f);
 281       g_free (uri);
 282     }
 283     g_object_unref (info);
 284     info = g_file_enumerator_next_file (fenum, NULL, NULL);
 285   }
 286
 287 done:
 288   gst_object_unref (file);
 289   if (fenum)
 290     gst_object_unref (fenum);
 291 }
 292
 293 gboolean
 294 ges_add_missing_uri_relocation_uri (const gchar * uri, gboolean recurse)
 295 {
 296   g_return_val_if_fail (gst_uri_is_valid (uri), FALSE);
 297
 298   if (new_paths == NULL)
 299     new_paths = g_ptr_array_new_with_free_func (g_free);
 300
 301   if (recurse)
 302     _add_media_new_paths_recursing (uri);
 303   else
 304     g_ptr_array_add (new_paths, g_strdup (uri));
 305
 306   return TRUE;
 307 }
 308
 309 static gchar *
 310 ges_missing_uri_default (GESProject * self, GError * error,
 311     GESAsset * wrong_asset)
 312 {
 313   guint i;
 314   const gchar *old_uri = ges_asset_get_id (wrong_asset);
 315
 316   if (new_paths == NULL)
 317     return NULL;
 318
 319   if (tried_uris == NULL)
 320     tried_uris = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 321
 322   for (i = 0; i < new_paths->len; i++) {
 323     gchar *basename, *res;
 324
 325     basename = g_path_get_basename (old_uri);
 326     res = g_build_filename (new_paths->pdata[i], basename, NULL);
 327     g_free (basename);
 328
 329     if (g_strcmp0 (old_uri, res) == 0) {
 330       g_hash_table_add (tried_uris, res);
 331     } else if (g_hash_table_lookup (tried_uris, res)) {
 332       GST_DEBUG_OBJECT (self, "File already tried: %s", res);
 333       g_free (res);
 334     } else {
 335       g_hash_table_add (tried_uris, g_strdup (res));
 336       GST_DEBUG_OBJECT (self, "Trying: %s\n", res);
 337       return res;
 338     }
 339   }
 340
 341   return NULL;
 342 }
 343
 344 static void
 345 ges_uri_assets_validate_uri (const gchar * nid)
 346 {
 347   if (tried_uris)
 348     g_hash_table_remove (tried_uris, nid);
 349 }
 350
 351 /* GObject vmethod implementation */
 352 static void
 353 _dispose (GObject * object)
 354 {
 355   GList *tmp;
 356   GESProjectPrivate *priv = GES_PROJECT (object)->priv;
 357
 358   if (priv->assets)
 359     g_hash_table_unref (priv->assets);
 360   if (priv->loading_assets)
 361     g_hash_table_unref (priv->loading_assets);
 362   if (priv->loaded_with_error)
 363     g_hash_table_unref (priv->loaded_with_error);
 364   if (priv->formatter_asset)
 365     gst_object_unref (priv->formatter_asset);
 366
 367   for (tmp = priv->formatters; tmp; tmp = tmp->next)
 368     ges_project_remove_formatter (GES_PROJECT (object), tmp->data);;
 369
 370   G_OBJECT_CLASS (ges_project_parent_class)->dispose (object);
 371 }
 372
 373 static void
 374 _finalize (GObject * object)
 375 {
 376   GESProjectPrivate *priv = GES_PROJECT (object)->priv;
 377
 378   if (priv->uri)
 379     g_free (priv->uri);
 380
 381   G_OBJECT_CLASS (ges_project_parent_class)->finalize (object);
 382 }
 383
 384 static void
 385 _get_property (GESProject * project, guint property_id,
 386     GValue * value, GParamSpec * pspec)
 387 {
 388   GESProjectPrivate *priv = project->priv;
 389
 390   switch (property_id) {
 391     case PROP_URI:
 392       g_value_set_string (value, priv->uri);
 393       break;
 394     default:
 395       G_OBJECT_WARN_INVALID_PROPERTY_ID (project, property_id, pspec);
 396   }
 397 }
 398
 399 static void
 400 _set_property (GESProject * project, guint property_id,
 401     const GValue * value, GParamSpec * pspec)
 402 {
 403   switch (property_id) {
 404     case PROP_URI:
 405       project->priv->uri = g_value_dup_string (value);
 406       break;
 407     default:
 408       G_OBJECT_WARN_INVALID_PROPERTY_ID (project, property_id, pspec);
 409   }
 410 }
 411
 412 static void
 413 ges_project_class_init (GESProjectClass * klass)
 414 {
 415   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 416
 417   g_type_class_add_private (klass, sizeof (GESProjectPrivate));
 418
 419   klass->asset_added = NULL;
 420   klass->missing_uri = ges_missing_uri_default;
 421   klass->loading_error = NULL;
 422   klass->asset_removed = NULL;
 423   object_class->get_property = (GObjectGetPropertyFunc) _get_property;
 424   object_class->set_property = (GObjectSetPropertyFunc) _set_property;
 425
 426   /**
 427    * GESProject::uri:
 428    *
 429    * The location of the project to use.
 430    */
 431   _properties[PROP_URI] = g_param_spec_string ("uri", "URI",
 432       "uri of the project", NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
 433
 434   g_object_class_install_properties (object_class, PROP_LAST, _properties);
 435
 436   /**
 437    * GESProject::asset-added:
 438    * @project: the #GESProject
 439    * @asset: The #GESAsset that has been added to @project
 440    */
 441   _signals[ASSET_ADDED_SIGNAL] =
 442       g_signal_new ("asset-added", G_TYPE_FROM_CLASS (klass),
 443       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GESProjectClass, asset_added),
 444       NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1, GES_TYPE_ASSET);
 445
 446   /**
 447    * GESProject::asset-loading:
 448    * @project: the #GESProject
 449    * @asset: The #GESAsset that started loading
 450    *
 451    * Since: 1.8
 452    */
 453   _signals[ASSET_LOADING_SIGNAL] =
 454       g_signal_new ("asset-loading", G_TYPE_FROM_CLASS (klass),
 455       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GESProjectClass, asset_loading),
 456       NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1, GES_TYPE_ASSET);
 457
 458   /**
 459    * GESProject::asset-removed:
 460    * @project: the #GESProject
 461    * @asset: The #GESAsset that has been removed from @project
 462    */
 463   _signals[ASSET_REMOVED_SIGNAL] =
 464       g_signal_new ("asset-removed", G_TYPE_FROM_CLASS (klass),
 465       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GESProjectClass, asset_removed),
 466       NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1, GES_TYPE_ASSET);
 467
 468   /**
 469    * GESProject::loaded:
 470    * @project: the #GESProject that is done loading a project.
 471    * @timeline: The #GESTimeline that complete loading
 472    */
 473   _signals[LOADED_SIGNAL] =
 474       g_signal_new ("loaded", G_TYPE_FROM_CLASS (klass),
 475       G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GESProjectClass, loaded),
 476       NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE,
 477       1, GES_TYPE_TIMELINE);
 478
 479   /**
 480    * GESProject::missing-uri:
 481    * @project: the #GESProject reporting that a file has moved
 482    * @error: The error that happened
 483    * @wrong_asset: The asset with the wrong ID, you should us it and its content
 484    * only to find out what the new location is.
 485    *
 486    * |[
 487    * static gchar
 488    * source_moved_cb (GESProject *project, GError *error, GESAsset *asset_with_error)
 489    * {
 490    *   return g_strdup ("file:///the/new/uri.ogg");
 491    * }
 492    *
 493    * static int
 494    * main (int argc, gchar ** argv)
 495    * {
 496    *   GESTimeline *timeline;
 497    *   GESProject *project = ges_project_new ("file:///some/uri.xges");
 498    *
 499    *   g_signal_connect (project, "missing-uri", source_moved_cb, NULL);
 500    *   timeline = ges_asset_extract (GES_ASSET (project));
 501    * }
 502    * ]|
 503    *
 504    * Returns: (transfer full) (allow-none): The new URI of @wrong_asset
 505    */
 506   _signals[MISSING_URI_SIGNAL] =
 507       g_signal_new ("missing-uri", G_TYPE_FROM_CLASS (klass),
 508       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GESProjectClass, missing_uri),
 509       _uri_missing_accumulator, NULL, g_cclosure_marshal_generic,
 510       G_TYPE_STRING, 2, G_TYPE_ERROR, GES_TYPE_ASSET);
 511
 512   /**
 513    * GESProject::error-loading-asset:
 514    * @project: the #GESProject on which a problem happend when creted a #GESAsset
 515    * @error: The #GError defining the error that accured, might be %NULL
 516    * @id: The @id of the asset that failed loading
 517    * @extractable_type: The @extractable_type of the asset that
 518    * failed loading
 519    *
 520    * Informs you that a #GESAsset could not be created. In case of
 521    * missing GStreamer plugins, the error will be set to #GST_CORE_ERROR
 522    * #GST_CORE_ERROR_MISSING_PLUGIN
 523    */
 524   _signals[ERROR_LOADING_ASSET] =
 525       g_signal_new ("error-loading-asset", G_TYPE_FROM_CLASS (klass),
 526       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GESProjectClass, loading_error),
 527       NULL, NULL, g_cclosure_marshal_generic,
 528       G_TYPE_NONE, 3, G_TYPE_ERROR, G_TYPE_STRING, G_TYPE_GTYPE);
 529
 530   object_class->dispose = _dispose;
 531   object_class->finalize = _finalize;
 532
 533   GES_ASSET_CLASS (klass)->extract = ges_project_extract;
 534 }
 535
 536 static void
 537 ges_project_init (GESProject * project)
 538 {
 539   GESProjectPrivate *priv = project->priv =
 540       G_TYPE_INSTANCE_GET_PRIVATE (project,
 541       GES_TYPE_PROJECT, GESProjectPrivate);
 542
 543   priv->uri = NULL;
 544   priv->formatters = NULL;
 545   priv->formatter_asset = NULL;
 546   priv->encoding_profiles = NULL;
 547   priv->assets = g_hash_table_new_full (g_str_hash, g_str_equal,
 548       g_free, gst_object_unref);
 549   priv->loading_assets = g_hash_table_new_full (g_str_hash, g_str_equal,
 550       g_free, gst_object_unref);
 551   priv->loaded_with_error = g_hash_table_new_full (g_str_hash, g_str_equal,
 552       g_free, NULL);
 553 }
 554
 555 static void
 556 _send_error_loading_asset (GESProject * project, GESAsset * asset,
 557     GError * error)
 558 {
 559   const gchar *id = ges_asset_get_id (asset);
 560
 561   GST_DEBUG_OBJECT (project, "Sending error loading asset for %s", id);
 562   g_hash_table_remove (project->priv->loading_assets, id);
 563   g_hash_table_add (project->priv->loaded_with_error, g_strdup (id));
 564   g_signal_emit (project, _signals[ERROR_LOADING_ASSET], 0, error, id,
 565       ges_asset_get_extractable_type (asset));
 566 }
 567
 568 gchar *
 569 ges_project_try_updating_id (GESProject * project, GESAsset * asset,
 570     GError * error)
 571 {
 572   gchar *new_id = NULL;
 573   const gchar *id;
 574
 575   g_return_val_if_fail (GES_IS_PROJECT (project), NULL);
 576   g_return_val_if_fail (GES_IS_ASSET (asset), NULL);
 577   g_return_val_if_fail (error, NULL);
 578
 579   id = ges_asset_get_id (asset);
 580   GST_DEBUG_OBJECT (project, "Try to proxy %s", id);
 581   if (ges_asset_request_id_update (asset, &new_id, error) == FALSE) {
 582     GST_DEBUG_OBJECT (project, "Type: %s can not be proxied for id: %s "
 583         "and error: %s", g_type_name (G_OBJECT_TYPE (asset)), id,
 584         error->message);
 585     _send_error_loading_asset (project, asset, error);
 586
 587     return NULL;
 588   }
 589
 590   if (new_id == NULL) {
 591     GST_DEBUG_OBJECT (project, "Sending 'missing-uri' signal for %s", id);
 592     g_signal_emit (project, _signals[MISSING_URI_SIGNAL], 0, error, asset,
 593         &new_id);
 594   }
 595
 596   if (new_id) {
 597     GST_DEBUG_OBJECT (project, "new id found: %s", new_id);
 598     if (!ges_asset_try_proxy (asset, new_id)) {
 599       g_free (new_id);
 600       new_id = NULL;
 601     }
 602   } else {
 603     GST_DEBUG_OBJECT (project, "No new id found for %s", id);
 604   }
 605
 606   g_hash_table_remove (project->priv->loading_assets, id);
 607
 608   if (new_id == NULL)
 609     _send_error_loading_asset (project, asset, error);
 610
 611
 612   return new_id;
 613 }
 614
 615 static void
 616 new_asset_cb (GESAsset * source, GAsyncResult * res, GESProject * project)
 617 {
 618   GError *error = NULL;
 619   gchar *possible_id = NULL;
 620   GESAsset *asset = ges_asset_request_finish (res, &error);
 621
 622   if (error) {
 623     possible_id = ges_project_try_updating_id (project, source, error);
 624
 625     if (possible_id == NULL)
 626       return;
 627
 628     ges_project_create_asset (project, possible_id,
 629         ges_asset_get_extractable_type (source));
 630
 631     g_free (possible_id);
 632     g_error_free (error);
 633     return;
 634   }
 635
 636   ges_asset_set_proxy (NULL, asset);
 637   ges_project_add_asset (project, asset);
 638   if (asset)
 639     gst_object_unref (asset);
 640 }
 641
 642 /**
 643  * ges_project_set_loaded:
 644  * @project: The #GESProject from which to emit the "project-loaded" signal
 645  *
 646  * Emits the "loaded" signal. This method should be called by sublasses when
 647  * the project is fully loaded.
 648  *
 649  * Returns: %TRUE if the signale could be emitted %FALSE otherwize
 650  */
 651 gboolean
 652 ges_project_set_loaded (GESProject * project, GESFormatter * formatter)
 653 {
 654   GST_INFO_OBJECT (project, "Emit project loaded");
 655   if (GST_STATE (formatter->timeline) < GST_STATE_PAUSED) {
 656     timeline_fill_gaps (formatter->timeline);
 657   } else {
 658     ges_timeline_commit (formatter->timeline);
 659   }
 660
 661   g_signal_emit (project, _signals[LOADED_SIGNAL], 0, formatter->timeline);
 662
 663   /* We are now done with that formatter */
 664   ges_project_remove_formatter (project, formatter);
 665   return TRUE;
 666 }
 667
 668 void
 669 ges_project_add_loading_asset (GESProject * project, GType extractable_type,
 670     const gchar * id)
 671 {
 672   GESAsset *asset;
 673
 674   if ((asset = ges_asset_cache_lookup (extractable_type, id))) {
 675     if (g_hash_table_insert (project->priv->loading_assets, g_strdup (id),
 676             gst_object_ref (asset)))
 677       g_signal_emit (project, _signals[ASSET_LOADING_SIGNAL], 0, asset);
 678   }
 679 }
 680
 681 /**************************************
 682  *                                    *
 683  *         API Implementation         *
 684  *                                    *
 685  **************************************/
 686
 687 /**
 688  * ges_project_create_asset:
 689  * @project: A #GESProject
 690  * @id: (allow-none): The id of the asset to create and add to @project
 691  * @extractable_type: The #GType of the asset to create
 692  *
 693  * Create and add a #GESAsset to @project. You should connect to the
 694  * "asset-added" signal to get the asset when it finally gets added to
 695  * @project
 696  *
 697  * Returns: %TRUE if the asset started to be added %FALSE it was already
 698  * in the project
 699  */
 700 gboolean
 701 ges_project_create_asset (GESProject * project, const gchar * id,
 702     GType extractable_type)
 703 {
 704   g_return_val_if_fail (GES_IS_PROJECT (project), FALSE);
 705   g_return_val_if_fail (g_type_is_a (extractable_type, GES_TYPE_EXTRACTABLE),
 706       FALSE);
 707
 708   if (id == NULL)
 709     id = g_type_name (extractable_type);
 710
 711   if (g_hash_table_lookup (project->priv->assets, id) ||
 712       g_hash_table_lookup (project->priv->loading_assets, id) ||
 713       g_hash_table_lookup (project->priv->loaded_with_error, id))
 714     return FALSE;
 715
 716   /* TODO Add a GCancellable somewhere in our API */
 717   ges_asset_request_async (extractable_type, id, NULL,
 718       (GAsyncReadyCallback) new_asset_cb, project);
 719   ges_project_add_loading_asset (project, extractable_type, id);
 720
 721   return TRUE;
 722 }
 723
 724 /**
 725  * ges_project_create_asset_sync:
 726  * @project: A #GESProject
 727  * @id: (allow-none): The id of the asset to create and add to @project
 728  * @extractable_type: The #GType of the asset to create
 729  * @error: A #GError to be set in case of error
 730  *
 731  * Create and add a #GESAsset to @project. You should connect to the
 732  * "asset-added" signal to get the asset when it finally gets added to
 733  * @project
 734  *
 735  * Returns: The newly created #GESAsset
 736  */
 737 GESAsset *
 738 ges_project_create_asset_sync (GESProject * project, const gchar * id,
 739     GType extractable_type, GError ** error)
 740 {
 741   GESAsset *asset;
 742   gchar *possible_id = NULL;
 743   gboolean retry = TRUE;
 744
 745   g_return_val_if_fail (GES_IS_PROJECT (project), FALSE);
 746   g_return_val_if_fail (g_type_is_a (extractable_type, GES_TYPE_EXTRACTABLE),
 747       FALSE);
 748
 749   if (id == NULL)
 750     id = g_type_name (extractable_type);
 751
 752   if ((asset = g_hash_table_lookup (project->priv->assets, id)))
 753     return asset;
 754   else if (g_hash_table_lookup (project->priv->loading_assets, id) ||
 755       g_hash_table_lookup (project->priv->loaded_with_error, id))
 756     return NULL;
 757
 758   /* TODO Add a GCancellable somewhere in our API */
 759   while (retry) {
 760
 761     if (g_type_is_a (extractable_type, GES_TYPE_URI_CLIP)) {
 762       asset = GES_ASSET (ges_uri_clip_asset_request_sync (id, error));
 763     } else {
 764       asset = ges_asset_request (extractable_type, id, error);
 765     }
 766
 767     if (asset) {
 768       retry = FALSE;
 769
 770       if ((!g_hash_table_lookup (project->priv->assets,
 771                   ges_asset_get_id (asset))))
 772         g_signal_emit (project, _signals[ASSET_LOADING_SIGNAL], 0, asset);
 773
 774       if (possible_id) {
 775         g_free (possible_id);
 776         ges_uri_assets_validate_uri (id);
 777       }
 778
 779       break;
 780     } else {
 781       GESAsset *tmpasset;
 782
 783       tmpasset = ges_asset_cache_lookup (extractable_type, id);
 784       g_signal_emit (project, _signals[ASSET_LOADING_SIGNAL], 0, tmpasset);
 785       g_signal_emit (project, _signals[ERROR_LOADING_ASSET], 0, *error, id,
 786           extractable_type);
 787       possible_id = ges_project_try_updating_id (project, tmpasset, *error);
 788
 789       if (possible_id == NULL)
 790         return NULL;
 791
 792       if (error)
 793         g_clear_error (error);
 794
 795       id = possible_id;
 796     }
 797   }
 798
 799   if (!ges_asset_get_proxy_target (asset))
 800     ges_asset_set_proxy (NULL, asset);
 801
 802   ges_project_add_asset (project, asset);
 803
 804   return asset;
 805 }
 806
 807 /**
 808  * ges_project_add_asset:
 809  * @project: A #GESProject
 810  * @asset: (transfer none): A #GESAsset to add to @project
 811  *
 812  * Adds a #Asset to @project, the project will keep a reference on
 813  * @asset.
 814  *
 815  * Returns: %TRUE if the asset could be added %FALSE it was already
 816  * in the project
 817  */
 818 gboolean
 819 ges_project_add_asset (GESProject * project, GESAsset * asset)
 820 {
 821   g_return_val_if_fail (GES_IS_PROJECT (project), FALSE);
 822
 823   if (g_hash_table_lookup (project->priv->assets, ges_asset_get_id (asset)))
 824     return TRUE;
 825
 826   g_hash_table_insert (project->priv->assets,
 827       g_strdup (ges_asset_get_id (asset)), gst_object_ref (asset));
 828
 829   g_hash_table_remove (project->priv->loading_assets, ges_asset_get_id (asset));
 830   GST_DEBUG_OBJECT (project, "Asset added: %s", ges_asset_get_id (asset));
 831   g_signal_emit (project, _signals[ASSET_ADDED_SIGNAL], 0, asset);
 832
 833   return TRUE;
 834 }
 835
 836 /**
 837  * ges_project_remove_asset:
 838  * @project: A #GESProject
 839  * @asset: (transfer none): A #GESAsset to remove from @project
 840  *
 841  * remove a @asset to from @project.
 842  *
 843  * Returns: %TRUE if the asset could be removed %FALSE otherwise
 844  */
 845 gboolean
 846 ges_project_remove_asset (GESProject * project, GESAsset * asset)
 847 {
 848   gboolean ret;
 849
 850   g_return_val_if_fail (GES_IS_PROJECT (project), FALSE);
 851
 852   ret = g_hash_table_remove (project->priv->assets, ges_asset_get_id (asset));
 853   g_signal_emit (project, _signals[ASSET_REMOVED_SIGNAL], 0, asset);
 854
 855   return ret;
 856 }
 857
 858 /**
 859  * ges_project_get_asset:
 860  * @project: A #GESProject
 861  * @id: The id of the asset to retrieve
 862  * @extractable_type: The extractable_type of the asset
 863  * to retrieve from @object
 864  *
 865  * Returns: (transfer full) (allow-none): The #GESAsset with
 866  * @id or %NULL if no asset with @id as an ID
 867  */
 868 GESAsset *
 869 ges_project_get_asset (GESProject * project, const gchar * id,
 870     GType extractable_type)
 871 {
 872   GESAsset *asset;
 873
 874   g_return_val_if_fail (GES_IS_PROJECT (project), NULL);
 875   g_return_val_if_fail (g_type_is_a (extractable_type, GES_TYPE_EXTRACTABLE),
 876       NULL);
 877
 878   asset = g_hash_table_lookup (project->priv->assets, id);
 879
 880   if (asset)
 881     return gst_object_ref (asset);
 882
 883   return NULL;
 884 }
 885
 886 /**
 887  * ges_project_list_assets:
 888  * @project: A #GESProject
 889  * @filter: Type of assets to list, #GES_TYPE_EXTRACTABLE will list
 890  * all assets
 891  *
 892  * List all @asset contained in @project filtering per extractable_type
 893  * as defined by @filter. It copies the asset and thus will not be updated
 894  * in time.
 895  *
 896  * Returns: (transfer full) (element-type GESAsset): The list of
 897  * #GESAsset the object contains
 898  */
 899 GList *
 900 ges_project_list_assets (GESProject * project, GType filter)
 901 {
 902   GList *ret = NULL;
 903   GHashTableIter iter;
 904   gpointer key, value;
 905
 906   g_return_val_if_fail (GES_IS_PROJECT (project), NULL);
 907
 908   g_hash_table_iter_init (&iter, project->priv->assets);
 909   while (g_hash_table_iter_next (&iter, &key, &value)) {
 910     if (g_type_is_a (ges_asset_get_extractable_type (GES_ASSET (value)),
 911             filter))
 912       ret = g_list_append (ret, gst_object_ref (value));
 913   }
 914
 915   return ret;
 916 }
 917
 918 /**
 919  * ges_project_save:
 920  * @project: A #GESProject to save
 921  * @timeline: The #GESTimeline to save, it must have been extracted from @project
 922  * @uri: The uri where to save @project and @timeline
 923  * @formatter_asset: (allow-none): The formatter asset to use or %NULL. If %NULL,
 924  * will try to save in the same format as the one from which the timeline as been loaded
 925  * or default to the formatter with highest rank
 926  * @overwrite: %TRUE to overwrite file if it exists
 927  * @error: (out) (allow-none): An error to be set in case something wrong happens or %NULL
 928  *
 929  * Save the timeline of @project to @uri. You should make sure that @timeline
 930  * is one of the timelines that have been extracted from @project
 931  * (using ges_asset_extract (@project);)
 932  *
 933  * Returns: %TRUE if the project could be save, %FALSE otherwize
 934  */
 935 gboolean
 936 ges_project_save (GESProject * project, GESTimeline * timeline,
 937     const gchar * uri, GESAsset * formatter_asset, gboolean overwrite,
 938     GError ** error)
 939 {
 940   GESAsset *tl_asset;
 941   gboolean ret = TRUE;
 942   GESFormatter *formatter = NULL;
 943
 944   g_return_val_if_fail (GES_IS_PROJECT (project), FALSE);
 945   g_return_val_if_fail (formatter_asset == NULL ||
 946       g_type_is_a (ges_asset_get_extractable_type (formatter_asset),
 947           GES_TYPE_FORMATTER), FALSE);
 948   g_return_val_if_fail ((error == NULL || *error == NULL), FALSE);
 949
 950   tl_asset = ges_extractable_get_asset (GES_EXTRACTABLE (timeline));
 951   if (tl_asset == NULL && project->priv->uri == NULL) {
 952     GESAsset *asset = ges_asset_cache_lookup (GES_TYPE_PROJECT, uri);
 953
 954     if (asset) {
 955       GST_WARNING_OBJECT (project, "Trying to save project to %s but we already"
 956           "have %" GST_PTR_FORMAT " for that uri, can not save", uri, asset);
 957       goto out;
 958     }
 959
 960     GST_DEBUG_OBJECT (project, "Timeline %" GST_PTR_FORMAT " has no asset"
 961         " we have no uri set, so setting ourself as asset", timeline);
 962
 963     ges_extractable_set_asset (GES_EXTRACTABLE (timeline), GES_ASSET (project));
 964   } else if (tl_asset != GES_ASSET (project)) {
 965     GST_WARNING_OBJECT (project, "Timeline %" GST_PTR_FORMAT
 966         " not created by this project can not save", timeline);
 967
 968     ret = FALSE;
 969     goto out;
 970   }
 971
 972   if (formatter_asset == NULL)
 973     formatter_asset = gst_object_ref (ges_formatter_get_default ());
 974
 975   formatter = GES_FORMATTER (ges_asset_extract (formatter_asset, error));
 976   if (formatter == NULL) {
 977     GST_WARNING_OBJECT (project, "Could not create the formatter %p %s: %s",
 978         formatter_asset, ges_asset_get_id (formatter_asset),
 979         (error && *error) ? (*error)->message : "Unknown Error");
 980
 981     ret = FALSE;
 982     goto out;
 983   }
 984
 985   ges_project_add_formatter (project, formatter);
 986   ret = ges_formatter_save_to_uri (formatter, timeline, uri, overwrite, error);
 987   if (ret && project->priv->uri == NULL)
 988     ges_project_set_uri (project, uri);
 989
 990 out:
 991   if (formatter_asset)
 992     gst_object_unref (formatter_asset);
 993   ges_project_remove_formatter (project, formatter);
 994
 995   return ret;
 996 }
 997
 998 /**
 999  * ges_project_new:
1000  * @uri: (allow-none): The uri to be set after creating the project.
1001  *
1002  * Creates a new #GESProject and sets its uri to @uri if provided. Note that
1003  * if @uri is not valid or %NULL, the uri of the project will then be set
1004  * the first time you save the project. If you then save the project to
1005  * other locations, it will never be updated again and the first valid URI is
1006  * the URI it will keep refering to.
1007  *
1008  * Returns: A newly created #GESProject
1009  */
1010 GESProject *
1011 ges_project_new (const gchar * uri)
1012 {
1013   gchar *id = (gchar *) uri;
1014   GESProject *project;
1015
1016   if (uri == NULL)
1017     id = g_strdup_printf ("project-%i", nb_projects++);
1018
1019   project = GES_PROJECT (ges_asset_request (GES_TYPE_TIMELINE, id, NULL));
1020
1021   if (project && uri)
1022     ges_project_set_uri (project, uri);
1023
1024   if (uri == NULL)
1025     g_free (id);
1026
1027   return project;
1028 }
1029
1030 /**
1031  * ges_project_load:
1032  * @project: A #GESProject that has an @uri set already
1033  * @timeline: A blank timeline to load @project into
1034  * @error: (out) (allow-none): An error to be set in case something wrong happens or %NULL
1035  *
1036  * Loads @project into @timeline
1037  *
1038  * Returns: %TRUE if the project could be loaded %FALSE otherwize.
1039  */
1040 gboolean
1041 ges_project_load (GESProject * project, GESTimeline * timeline, GError ** error)
1042 {
1043   g_return_val_if_fail (GES_IS_TIMELINE (timeline), FALSE);
1044   g_return_val_if_fail (GES_IS_PROJECT (project), FALSE);
1045   g_return_val_if_fail (ges_project_get_uri (project), FALSE);
1046   g_return_val_if_fail (timeline->tracks == NULL, FALSE);
1047
1048   if (!_load_project (project, timeline, error))
1049     return FALSE;
1050
1051   ges_extractable_set_asset (GES_EXTRACTABLE (timeline), GES_ASSET (project));
1052
1053   return TRUE;
1054 }
1055
1056 /**
1057  * ges_project_get_uri:
1058  * @project: A #GESProject
1059  *
1060  * Retrieve the uri that is currently set on @project
1061  *
1062  * Returns: The uri that is set on @project
1063  */
1064 gchar *
1065 ges_project_get_uri (GESProject * project)
1066 {
1067   GESProjectPrivate *priv;
1068
1069   g_return_val_if_fail (GES_IS_PROJECT (project), FALSE);
1070
1071   priv = project->priv;
1072   if (priv->uri)
1073     return g_strdup (priv->uri);
1074   return NULL;
1075 }
1076
1077 /**
1078  * ges_project_add_encoding_profile:
1079  * @project: A #GESProject
1080  * @profile: A #GstEncodingProfile to add to the project. If a profile with
1081  * the same name already exists, it will be replaced
1082  *
1083  * Adds @profile to the project. It lets you save in what format
1084  * the project has been renders and keep a reference to those formats.
1085  * Also, those formats will be saves to the project file when possible.
1086  *
1087  * Returns: %TRUE if @profile could be added, %FALSE otherwize
1088  */
1089 gboolean
1090 ges_project_add_encoding_profile (GESProject * project,
1091     GstEncodingProfile * profile)
1092 {
1093   GList *tmp;
1094   GESProjectPrivate *priv;
1095
1096   g_return_val_if_fail (GES_IS_PROJECT (project), FALSE);
1097   g_return_val_if_fail (GST_IS_ENCODING_PROFILE (profile), FALSE);
1098
1099   priv = project->priv;
1100   for (tmp = priv->encoding_profiles; tmp; tmp = tmp->next) {
1101     GstEncodingProfile *tmpprofile = GST_ENCODING_PROFILE (tmp->data);
1102
1103     if (g_strcmp0 (gst_encoding_profile_get_name (tmpprofile),
1104             gst_encoding_profile_get_name (profile)) == 0) {
1105       GST_INFO_OBJECT (project, "Already have profile: %s, replacing it",
1106           gst_encoding_profile_get_name (profile));
1107
1108       gst_object_unref (tmp->data);
1109       tmp->data = gst_object_ref (profile);
1110       return TRUE;
1111     }
1112   }
1113
1114   priv->encoding_profiles = g_list_prepend (priv->encoding_profiles,
1115       gst_object_ref (profile));
1116
1117   return TRUE;
1118 }
1119
1120 /**
1121  * ges_project_list_encoding_profiles:
1122  * @project: A #GESProject
1123  *
1124  * Lists the encoding profile that have been set to @project. The first one
1125  * is the latest added.
1126  *
1127  * Returns: (transfer none) (element-type GstPbutils.EncodingProfile) (allow-none): The
1128  * list of #GstEncodingProfile used in @project
1129  */
1130 const GList *
1131 ges_project_list_encoding_profiles (GESProject * project)
1132 {
1133   g_return_val_if_fail (GES_IS_PROJECT (project), FALSE);
1134
1135   return project->priv->encoding_profiles;
1136 }
1137
1138 /**
1139  * ges_project_get_loading_assets:
1140  * @project: A #GESProject
1141  *
1142  * Get the assets that are being loaded
1143  *
1144  * Returns: (transfer full) (element-type GES.Asset): A set of loading asset
1145  * that will be added to @project. Note that those Asset are *not* loaded yet,
1146  * and thus can not be used
1147  */
1148 GList *
1149 ges_project_get_loading_assets (GESProject * project)
1150 {
1151   GHashTableIter iter;
1152   gpointer key, value;
1153
1154   GList *ret = NULL;
1155
1156   g_return_val_if_fail (GES_IS_PROJECT (project), NULL);
1157
1158   g_hash_table_iter_init (&iter, project->priv->loading_assets);
1159   while (g_hash_table_iter_next (&iter, &key, &value))
1160     ret = g_list_prepend (ret, gst_object_ref (value));
1161
1162   return ret;
1163 }