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