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