ges-uri-asset.c 19.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/* GStreamer Editing Services
 *
 * Copyright (C) 2012 Thibault Saunier <thibault.saunier@collabora.com>
 * Copyright (C) 2012 Volodymyr Rudyi <vladimir.rudoy@gmail.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
/**
22
 * SECTION: gesuriclipasset
23
 * @short_description: A GESAsset subclass specialized in GESUriClip extraction
24
 *
25
 * The #GESUriClipAsset is a special #GESAsset that lets you handle
26
27
28
29
30
31
32
 * the media file to use inside the GStreamer Editing Services. It has APIs that
 * let you get information about the medias. Also, the tags found in the media file are
 * set as Metadatas of the Asser.
 */
#include <gst/pbutils/pbutils.h>
#include "ges.h"
#include "ges-internal.h"
33
#include "ges-track-element-asset.h"
34
35
36
37
38
39
40
41
42

static GHashTable *parent_newparent_table = NULL;
static void
initable_iface_init (GInitableIface * initable_iface)
{
  /*  We can not iniate synchronously */
  initable_iface->init = NULL;
}

43
G_DEFINE_TYPE_WITH_CODE (GESUriClipAsset, ges_uri_clip_asset,
44
    GES_TYPE_CLIP_ASSET,
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
    G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, initable_iface_init));

/* TODO: We should monitor files here, and add some way of reporting changes
 * to user
 */
enum
{
  PROP_0,
  PROP_DURATION,
  PROP_LAST
};
static GParamSpec *properties[PROP_LAST];

static void discoverer_discovered_cb (GstDiscoverer * discoverer,
    GstDiscovererInfo * info, GError * err, gpointer user_data);

61
struct _GESUriClipAssetPrivate
62
63
64
65
{
  GstDiscovererInfo *info;
  GstClockTime duration;
  gboolean is_image;
66
67
68
69

  GList *asset_trackfilesources;
};

70
struct _GESUriSourceAssetPrivate
71
72
{
  GstDiscovererStreamInfo *sinfo;
73
  GESUriClipAsset *parent_asset;
74
75

  const gchar *uri;
76
77
78
79
};


static void
80
ges_uri_clip_asset_get_property (GObject * object, guint property_id,
81
82
    GValue * value, GParamSpec * pspec)
{
83
  GESUriClipAssetPrivate *priv = GES_URI_CLIP_ASSET (object)->priv;
84
85
86
87
88
89
90
91
92
93
94

  switch (property_id) {
    case PROP_DURATION:
      g_value_set_uint64 (value, priv->duration);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
  }
}

static void
95
ges_uri_clip_asset_set_property (GObject * object, guint property_id,
96
97
    const GValue * value, GParamSpec * pspec)
{
98
  GESUriClipAssetPrivate *priv = GES_URI_CLIP_ASSET (object)->priv;
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

  switch (property_id) {
    case PROP_DURATION:
      priv->duration = g_value_get_uint64 (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
  }
}

static GESAssetLoadingReturn
_start_loading (GESAsset * asset, GError ** error)
{
  gboolean ret;
  const gchar *uri;
114
  GESUriClipAssetClass *class = GES_URI_CLIP_ASSET_GET_CLASS (asset);
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

  GST_DEBUG ("Started loading %p", asset);

  uri = ges_asset_get_id (asset);

  ret = gst_discoverer_discover_uri_async (class->discoverer, uri);
  if (ret)
    return GES_ASSET_LOADING_ASYNC;

  return GES_ASSET_LOADING_ERROR;
}

static gboolean
_request_id_update (GESAsset * self, gchar ** proposed_new_id, GError * error)
{
  if (error->domain == GST_RESOURCE_ERROR &&
131
132
      (error->code == GST_RESOURCE_ERROR_NOT_FOUND ||
          error->code == GST_RESOURCE_ERROR_OPEN_READ)) {
133
134
135
136
137
138
139
140
141
142
143
144
    const gchar *uri = ges_asset_get_id (self);
    GFile *parent, *file = g_file_new_for_uri (uri);

    /* Check if we have the new parent in cache */
    parent = g_file_get_parent (file);
    if (parent) {
      GFile *new_parent = g_hash_table_lookup (parent_newparent_table, parent);

      if (new_parent) {
        gchar *basename = g_file_get_basename (file);
        GFile *new_file = g_file_get_child (new_parent, basename);

145
146
147
148
149
150
        /* FIXME Handle the GCancellable */
        if (g_file_query_exists (file, NULL)) {
          *proposed_new_id = g_file_get_uri (new_file);
          GST_DEBUG_OBJECT (self, "Proposing path: %s as proxy",
              *proposed_new_id);
        }
151

152
        gst_object_unref (new_file);
153
154
        g_free (basename);
      }
155
      gst_object_unref (parent);
156
157
    }

158
    gst_object_unref (file);
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

    return TRUE;
  }

  return FALSE;
}

static void
_asset_proxied (GESAsset * self, const gchar * new_uri)
{
  const gchar *uri = ges_asset_get_id (self);
  GFile *parent, *new_parent, *new_file = g_file_new_for_uri (new_uri),
      *file = g_file_new_for_uri (uri);

  parent = g_file_get_parent (file);
  new_parent = g_file_get_parent (new_file);
  g_hash_table_insert (parent_newparent_table, parent, new_parent);
176
177
  gst_object_unref (file);
  gst_object_unref (new_file);
178
179
180
}

static void
181
ges_uri_clip_asset_class_init (GESUriClipAssetClass * klass)
182
183
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
184
  g_type_class_add_private (klass, sizeof (GESUriClipAssetPrivate));
185

186
187
  object_class->get_property = ges_uri_clip_asset_get_property;
  object_class->set_property = ges_uri_clip_asset_set_property;
188
189
190
191
192
193
194

  GES_ASSET_CLASS (klass)->start_loading = _start_loading;
  GES_ASSET_CLASS (klass)->request_id_update = _request_id_update;
  GES_ASSET_CLASS (klass)->inform_proxy = _asset_proxied;


  /**
195
   * GESUriClipAsset:duration:
196
197
198
199
200
201
202
203
204
205
   *
   * The duration (in nanoseconds) of the media file
   */
  properties[PROP_DURATION] =
      g_param_spec_uint64 ("duration", "Duration", "The duration to use", 0,
      G_MAXUINT64, GST_CLOCK_TIME_NONE, G_PARAM_READWRITE);
  g_object_class_install_property (object_class, PROP_DURATION,
      properties[PROP_DURATION]);

  klass->discoverer = gst_discoverer_new (GST_SECOND, NULL);
206
  klass->sync_discoverer = gst_discoverer_new (GST_SECOND, NULL);
207
208
209
210
211
212
213
  g_signal_connect (klass->discoverer, "discovered",
      G_CALLBACK (discoverer_discovered_cb), NULL);

  /* We just start the discoverer and let it live */
  gst_discoverer_start (klass->discoverer);
  if (parent_newparent_table == NULL) {
    parent_newparent_table = g_hash_table_new_full (g_file_hash,
214
        (GEqualFunc) g_file_equal, gst_object_unref, gst_object_unref);
215
216
217
218
  }
}

static void
219
ges_uri_clip_asset_init (GESUriClipAsset * self)
220
{
221
  GESUriClipAssetPrivate *priv;
222
223

  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
224
      GES_TYPE_URI_CLIP_ASSET, GESUriClipAssetPrivate);
225
226
227
228
229
230

  priv->info = NULL;
  priv->duration = GST_CLOCK_TIME_NONE;
  priv->is_image = FALSE;
}

231
static void
232
_create_uri_source_asset (GESUriClipAsset * asset,
233
234
235
    GstDiscovererStreamInfo * sinfo, GESTrackType type)
{
  GESAsset *tck_filesource_asset;
236
  GESUriSourceAssetPrivate *priv_tckasset;
237
  GESUriClipAssetPrivate *priv = asset->priv;
238
239
240
241
242
243
244
245
246
  gchar *stream_id =
      g_strdup (gst_discoverer_stream_info_get_stream_id (sinfo));

  if (stream_id == NULL) {
    GST_WARNING ("No stream ID found, using the pointer instead");

    stream_id = g_strdup_printf ("%i", GPOINTER_TO_INT (sinfo));
  }

247
248
249
250
251
252
  if (type == GES_TRACK_TYPE_VIDEO)
    tck_filesource_asset = ges_asset_request (GES_TYPE_VIDEO_URI_SOURCE,
        stream_id, NULL);
  else
    tck_filesource_asset = ges_asset_request (GES_TYPE_AUDIO_URI_SOURCE,
        stream_id, NULL);
253
254
  g_free (stream_id);

255
  priv_tckasset = GES_URI_SOURCE_ASSET (tck_filesource_asset)->priv;
256
  priv_tckasset->uri = ges_asset_get_id (GES_ASSET (asset));
257
  priv_tckasset->sinfo = gst_object_ref (sinfo);
258
  priv_tckasset->parent_asset = asset;
259
  ges_track_element_asset_set_track_type (GES_TRACK_ELEMENT_ASSET
260
      (tck_filesource_asset), type);
261
262
263
264
265

  priv->asset_trackfilesources = g_list_append (priv->asset_trackfilesources,
      gst_object_ref (tck_filesource_asset));
}

266
static void
267
ges_uri_clip_asset_set_info (GESUriClipAsset * self, GstDiscovererInfo * info)
268
269
270
271
{
  GList *tmp, *stream_list;

  GESTrackType supportedformats = GES_TRACK_TYPE_UNKNOWN;
272
  GESUriClipAssetPrivate *priv = GES_URI_CLIP_ASSET (self)->priv;
273
274
275
276

  /* Extract infos from the GstDiscovererInfo */
  stream_list = gst_discoverer_info_get_stream_list (info);
  for (tmp = stream_list; tmp; tmp = tmp->next) {
277
    GESTrackType type = GES_TRACK_TYPE_UNKNOWN;
278
279
280
281
282
283
284
285
    GstDiscovererStreamInfo *sinf = (GstDiscovererStreamInfo *) tmp->data;

    if (GST_IS_DISCOVERER_AUDIO_INFO (sinf)) {
      if (supportedformats == GES_TRACK_TYPE_UNKNOWN)
        supportedformats = GES_TRACK_TYPE_AUDIO;
      else
        supportedformats |= GES_TRACK_TYPE_AUDIO;

286
      type = GES_TRACK_TYPE_AUDIO;
287
288
289
290
291
292
    } else if (GST_IS_DISCOVERER_VIDEO_INFO (sinf)) {
      if (supportedformats == GES_TRACK_TYPE_UNKNOWN)
        supportedformats = GES_TRACK_TYPE_VIDEO;
      else
        supportedformats |= GES_TRACK_TYPE_VIDEO;
      if (gst_discoverer_video_info_is_image ((GstDiscovererVideoInfo *)
293
              sinf))
294
        priv->is_image = TRUE;
295
296
297
      type = GES_TRACK_TYPE_VIDEO;
    }

298
    GST_DEBUG_OBJECT (self, "Creating GESUriSourceAsset for stream: %s",
299
        gst_discoverer_stream_info_get_stream_id (sinf));
300
    _create_uri_source_asset (self, sinf, type);
301
  }
302
  ges_clip_asset_set_supported_formats (GES_CLIP_ASSET
303
      (self), supportedformats);
304
305
306
307
308
309
310
311

  if (stream_list)
    gst_discoverer_stream_info_list_free (stream_list);

  if (priv->is_image == FALSE)
    priv->duration = gst_discoverer_info_get_duration (info);
  /* else we keep #GST_CLOCK_TIME_NONE */

312
  priv->info = gst_object_ref (info);
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
}

static void
_set_meta_foreach (const GstTagList * tags, const gchar * tag,
    GESMetaContainer * container)
{
  GValue value = { 0 };

  gst_tag_list_copy_value (&value, tags, tag);
  ges_meta_container_set_meta (container, tag, &value);
  g_value_unset (&value);
}

static void
discoverer_discovered_cb (GstDiscoverer * discoverer,
    GstDiscovererInfo * info, GError * err, gpointer user_data)
{
  const GstTagList *tags;

  const gchar *uri = gst_discoverer_info_get_uri (info);
333
334
  GESUriClipAsset *mfs =
      GES_URI_CLIP_ASSET (ges_asset_cache_lookup (GES_TYPE_URI_CLIP, uri));
335
336
337
338
339
340

  tags = gst_discoverer_info_get_tags (info);
  if (tags)
    gst_tag_list_foreach (tags, (GstTagForeachFunc) _set_meta_foreach, mfs);

  if (err == NULL)
341
342
    ges_uri_clip_asset_set_info (mfs, info);
  ges_asset_cache_set_loaded (GES_TYPE_URI_CLIP, uri, err);
343
344
345
346
}

/* API implementation */
/**
347
 * ges_uri_clip_asset_get_info:
348
349
350
351
352
353
354
 * @self: Target asset
 *
 * Gets #GstDiscovererInfo about the file
 *
 * Returns: (transfer none): #GstDiscovererInfo of specified asset
 */
GstDiscovererInfo *
355
ges_uri_clip_asset_get_info (const GESUriClipAsset * self)
356
{
357
358
  g_return_val_if_fail (GES_IS_URI_CLIP_ASSET (self), NULL);

359
360
361
362
  return self->priv->info;
}

/**
363
364
 * ges_uri_clip_asset_get_duration:
 * @self: a #GESUriClipAsset
365
366
367
368
369
370
 *
 * Gets duration of the file represented by @self
 *
 * Returns: The duration of @self
 */
GstClockTime
371
ges_uri_clip_asset_get_duration (GESUriClipAsset * self)
372
{
373
  g_return_val_if_fail (GES_IS_URI_CLIP_ASSET (self), GST_CLOCK_TIME_NONE);
374
375
376
377
378

  return self->priv->duration;
}

/**
379
 * ges_uri_clip_asset_is_image:
380
 * @self: a #indent: Standard input:311: Error:Unexpected end of file
381
GESUriClipAsset
382
383
384
385
386
387
 *
 * Gets Whether the file represented by @self is an image or not
 *
 * Returns: Whether the file represented by @self is an image or not
 */
gboolean
388
ges_uri_clip_asset_is_image (GESUriClipAsset * self)
389
{
390
  g_return_val_if_fail (GES_IS_URI_CLIP_ASSET (self), FALSE);
391
392
393
394
395

  return self->priv->is_image;
}

/**
396
397
 * ges_uri_clip_asset_new:
 * @uri: The URI of the file for which to create a #GESUriClipAsset
398
399
400
401
 * @cancellable: optional %GCancellable object, %NULL to ignore.
 * @callback: (scope async): a #GAsyncReadyCallback to call when the initialization is finished
 * @user_data: The user data to pass when @callback is called
 *
402
 * Creates a #GESUriClipAsset for @uri
403
 *
404
 * Example of request of a GESUriClipAsset:
405
406
407
408
409
410
 * |[
 * // The request callback
 * static void
 * filesource_asset_loaded_cb (GESAsset * source, GAsyncResult * res, gpointer user_data)
 * {
 *   GError *error = NULL;
411
 *   GESUriClipAsset *filesource_asset;
412
 *
413
 *   filesource_asset = GES_URI_CLIP_ASSET (ges_asset_request_finish (res, &error));
414
415
416
 *   if (filesource_asset) {
 *    g_print ("The file: %s is usable as a FileSource, it is%s an image and lasts %" GST_TIME_FORMAT,
 *        ges_asset_get_id (GES_ASSET (filesource_asset))
417
418
 *        ges_uri_clip_asset_is_image (filesource_asset) ? "" : " not",
 *        GST_TIME_ARGS (ges_uri_clip_asset_get_duration (filesource_asset));
419
420
421
422
423
 *   } else {
 *    g_print ("The file: %s is *not* usable as a FileSource because: %s",
 *        ges_asset_get_id (source), error->message);
 *   }
 *
424
 *   gst_object_unref (mfs);
425
426
427
 * }
 *
 * // The request:
428
 * ges_uri_clip_asset_new (uri, (GAsyncReadyCallback) filesource_asset_loaded_cb, user_data);
429
430
431
 * ]|
 */
void
432
ges_uri_clip_asset_new (const gchar * uri, GCancellable * cancellable,
433
434
    GAsyncReadyCallback callback, gpointer user_data)
{
435
  ges_asset_request_async (GES_TYPE_URI_CLIP, uri, cancellable,
436
437
438
      callback, user_data);
}

439
/**
440
 * ges_uri_clip_asset_request_sync:
Lubosz Sarnecki's avatar
Lubosz Sarnecki committed
441
442
 * @uri: The URI of the file for which to create a #GESUriClipAsset.
 * You can also use multi file uris for #GESMultiFileSource.
443
444
445
446
447
 * @error: (allow-none): An error to be set in case something wrong happens or %NULL
 *
 * Creates a #GESUriClipAsset for @uri syncronously. You should avoid
 * to use it in application, and rather create #GESUriClipAsset asynchronously
 *
448
 * Returns: (transfer none): A reference to the requested asset or %NULL if an error happend
449
450
451
452
453
454
455
456
 */
GESUriClipAsset *
ges_uri_clip_asset_request_sync (const gchar * uri, GError ** error)
{
  GError *lerror = NULL;
  GstDiscovererInfo *info;
  GstDiscoverer *discoverer;
  GESUriClipAsset *asset;
Lubosz Sarnecki's avatar
Lubosz Sarnecki committed
457
  gchar *first_file, *first_file_uri;
458
459
460
461
462
463
464

  asset = GES_URI_CLIP_ASSET (ges_asset_request (GES_TYPE_URI_CLIP, uri,
          &lerror));

  if (asset)
    return asset;

465
466
  if (lerror && lerror->domain == GES_ERROR &&
      lerror->code == GES_ERROR_ASSET_WRONG_ID) {
467
468
469
470
471
472
473
474
    g_propagate_error (error, lerror);

    return NULL;
  }

  asset = g_object_new (GES_TYPE_URI_CLIP_ASSET, "id", uri,
      "extractable-type", GES_TYPE_URI_CLIP, NULL);
  discoverer = GES_URI_CLIP_ASSET_GET_CLASS (asset)->sync_discoverer;
Lubosz Sarnecki's avatar
Lubosz Sarnecki committed
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490

  if (g_str_has_prefix (uri, GES_MULTI_FILE_URI_PREFIX)) {
    GESMultiFileURI *uri_data;

    uri_data = ges_multi_file_uri_new (uri);
    first_file = g_strdup_printf (uri_data->location, uri_data->start);
    first_file_uri = gst_filename_to_uri (first_file, &lerror);
    info = gst_discoverer_discover_uri (discoverer, first_file_uri, &lerror);
    GST_DEBUG ("Got multifile uri. Discovering first file %s", first_file_uri);
    g_free (uri_data);
    g_free (first_file_uri);
    g_free (first_file);
  } else {
    info = gst_discoverer_discover_uri (discoverer, uri, &lerror);
  }

491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
  if (info == NULL || lerror != NULL) {
    gst_object_unref (asset);
    if (lerror)
      g_propagate_error (error, lerror);

    return NULL;
  }

  ges_asset_cache_put (gst_object_ref (asset), NULL);
  ges_uri_clip_asset_set_info (asset, info);
  ges_asset_cache_set_loaded (GES_TYPE_URI_CLIP, uri, lerror);

  return asset;
}

506
/**
507
 * ges_uri_clip_asset_class_set_timeout:
Lubosz Sarnecki's avatar
Lubosz Sarnecki committed
508
 * @klass: The #GESUriClipAssetClass on which to set the discoverer timeout
509
510
 * @timeout: The timeout to set
 *
511
 * Sets the timeout of #GESUriClipAsset loading
512
513
 */
void
Lubosz Sarnecki's avatar
Lubosz Sarnecki committed
514
ges_uri_clip_asset_class_set_timeout (GESUriClipAssetClass * klass,
515
516
    GstClockTime timeout)
{
Lubosz Sarnecki's avatar
Lubosz Sarnecki committed
517
  g_return_if_fail (GES_IS_URI_CLIP_ASSET_CLASS (klass));
518

Lubosz Sarnecki's avatar
Lubosz Sarnecki committed
519
520
  g_object_set (klass->discoverer, "timeout", timeout, NULL);
  g_object_set (klass->sync_discoverer, "timeout", timeout, NULL);
521
}
522
523

/**
524
525
 * ges_uri_clip_asset_get_stream_assets:
 * @self: A #GESUriClipAsset
526
 *
527
 * Get the GESUriSourceAsset @self containes
528
 *
529
530
 * Returns: (transfer none) (element-type GESUriSourceAsset): a
 * #GList of #GESUriSourceAsset
531
532
 */
const GList *
533
ges_uri_clip_asset_get_stream_assets (GESUriClipAsset * self)
534
{
535
  g_return_val_if_fail (GES_IS_URI_CLIP_ASSET (self), FALSE);
536
537
538
539
540

  return self->priv->asset_trackfilesources;
}

/*****************************************************************
541
 *            GESUriSourceAsset implementation             *
542
543
 *****************************************************************/
/**
544
 * SECTION: gesurisourceasset
545
 * @short_description: A GESAsset subclass specialized in GESUriSource extraction
546
547
 *
 * NOTE: You should never request such a #GESAsset as they will be created automatically
548
 * by #GESUriClipAsset-s.
549
550
 */

551
G_DEFINE_TYPE (GESUriSourceAsset, ges_uri_source_asset,
552
    GES_TYPE_TRACK_ELEMENT_ASSET);
553
554
555
556

static GESExtractable *
_extract (GESAsset * asset, GError ** error)
{
557
  GESTrackElement *trackelement;
558
  GESUriSourceAssetPrivate *priv = GES_URI_SOURCE_ASSET (asset)->priv;
559
560
561
562
563
564
565
566
567
568
569
570
571

  if (GST_IS_DISCOVERER_STREAM_INFO (priv->sinfo) == FALSE) {
    GST_WARNING_OBJECT (asset, "Can not extract as no strean info set");

    return NULL;
  }

  if (priv->uri == NULL) {
    GST_WARNING_OBJECT (asset, "Can not extract as no uri set");

    return NULL;
  }

Lubosz Sarnecki's avatar
Lubosz Sarnecki committed
572
573
574
575
576
  if (g_str_has_prefix (priv->uri, GES_MULTI_FILE_URI_PREFIX)) {
    trackelement =
        GES_TRACK_ELEMENT (ges_multi_file_source_new (g_strdup (priv->uri)));
  } else if (GST_IS_DISCOVERER_VIDEO_INFO (priv->sinfo)
      && gst_discoverer_video_info_is_image ((GstDiscovererVideoInfo *)
577
578
579
          priv->sinfo))
    trackelement =
        GES_TRACK_ELEMENT (ges_image_source_new (g_strdup (priv->uri)));
580
581
582
  else if (GST_IS_DISCOVERER_VIDEO_INFO (priv->sinfo))
    trackelement =
        GES_TRACK_ELEMENT (ges_video_uri_source_new (g_strdup (priv->uri)));
583
584
  else
    trackelement =
585
586
        GES_TRACK_ELEMENT (ges_audio_uri_source_new (g_strdup (priv->uri)));

587
588
  ges_track_element_set_track_type (trackelement,
      ges_track_element_asset_get_track_type (GES_TRACK_ELEMENT_ASSET (asset)));
589

590
  return GES_EXTRACTABLE (trackelement);
591
592
593
}

static void
594
ges_uri_source_asset_class_init (GESUriSourceAssetClass * klass)
595
{
596
  g_type_class_add_private (klass, sizeof (GESUriSourceAssetPrivate));
597
598
599
600
601

  GES_ASSET_CLASS (klass)->extract = _extract;
}

static void
602
ges_uri_source_asset_init (GESUriSourceAsset * self)
603
{
604
  GESUriSourceAssetPrivate *priv;
605
606

  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
607
      GES_TYPE_URI_SOURCE_ASSET, GESUriSourceAssetPrivate);
608
609
610
611
612
613

  priv->sinfo = NULL;
  priv->parent_asset = NULL;
  priv->uri = NULL;
}

Thibault Saunier's avatar
Thibault Saunier committed
614
/**
615
 * ges_uri_source_asset_get_stream_info:
616
 * @asset: A #GESUriClipAsset
Thibault Saunier's avatar
Thibault Saunier committed
617
618
619
 *
 * Get the #GstDiscovererStreamInfo user by @asset
 *
620
 * Returns: (transfer none): a #GESUriClipAsset
Thibault Saunier's avatar
Thibault Saunier committed
621
 */
622
GstDiscovererStreamInfo *
623
ges_uri_source_asset_get_stream_info (GESUriSourceAsset * asset)
624
{
625
  g_return_val_if_fail (GES_IS_URI_SOURCE_ASSET (asset), NULL);
626
627
628
629
630

  return asset->priv->sinfo;
}

const gchar *
631
ges_uri_source_asset_get_stream_uri (GESUriSourceAsset * asset)
632
{
633
  g_return_val_if_fail (GES_IS_URI_SOURCE_ASSET (asset), NULL);
634
635
636
637
638

  return asset->priv->uri;
}

/**
639
 * ges_uri_source_asset_get_filesource_asset:
640
 * @asset: A #GESUriClipAsset
641
 *
642
 * Get the #GESUriClipAsset @self is contained in
643
 *
644
 * Returns: a #GESUriClipAsset
645
 */
646
const GESUriClipAsset *
647
ges_uri_source_asset_get_filesource_asset (GESUriSourceAsset * asset)
648
{
649
  g_return_val_if_fail (GES_IS_URI_SOURCE_ASSET (asset), NULL);
650
651
652

  return asset->priv->parent_asset;
}