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