ges_asset_get_extractable_type ()

GType
ges_asset_get_extractable_type (GESAsset *self);

Gets the type of object that can be extracted from self

ges_asset_get_id ()

const gchar *
ges_asset_get_id (GESAsset *self);

Gets the ID of a GESAsset

ges_asset_request ()

GESAsset *
ges_asset_request (GType extractable_type,
                   const gchar *id,
                   GError **error);

Create a GESAsset in the most simple cases, you should look at the extractable_type documentation to see if that constructor can be called for this particular type

As it is recommanded not to instanciate assets for GESUriClip synchronously, it will not work with this method, but you can instead use the specific ges_uri_clip_asset_request_sync method if you really want to.

ges_asset_request_async ()

void
ges_asset_request_async (GType extractable_type,
                         const gchar *id,
                         GCancellable *cancellable,
                         GAsyncReadyCallback callback,
                         gpointer user_data);

The callback will be called from a running GMainLoop which is iterating a GMainContext. Note that, users should ensure the GMainContext, since this method will notify callback from the thread which was associated with a thread default GMainContext at calling ges_init(). For example, if a user wants non-default GMainContext to be associated with callback , ges_init() must be called after g_main_context_push_thread_default() with custom GMainContext.

Request a new GESAsset asyncronously, callback will be called when the materail is ready to be used or if an error occured.

Example of request of a GESAsset async:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// The request callback
static void
asset_loaded_cb (GESAsset * source, GAsyncResult * res, gpointer user_data)
{
  GESAsset *asset;
  GError *error = NULL;

  asset = ges_asset_request_finish (res, &error);
  if (asset) {
   g_print ("The file: %s is usable as a FileSource",
       ges_asset_get_id (asset));
  } else {
   g_print ("The file: %s is *not* usable as a FileSource because: %s",
       ges_asset_get_id (source), error->message);
  }

  gst_object_unref (mfs);
}

// The request:
ges_asset_request_async (GES_TYPE_URI_CLIP, some_uri, NULL,
   (GAsyncReadyCallback) asset_loaded_cb, user_data);

ges_asset_request_finish ()

GESAsset *
ges_asset_request_finish (GAsyncResult *res,
                          GError **error);

Finalize the request of an async GESAsset

ges_asset_extract ()

GESExtractable *
ges_asset_extract (GESAsset *self,
                   GError **error);

Extracts a new GObject from asset . The type of the object is defined by the extractable-type of asset , you can check what type will be extracted from asset using ges_asset_get_extractable_type

ges_asset_get_error ()

GError *
ges_asset_get_error (GESAsset *self);

Since: 1.8

ges_list_assets ()

GList *
ges_list_assets (GType filter);

List all asset filtering per filter as defined by filter . It copies the asset and thus will not be updated in time.

ges_asset_set_proxy ()

gboolean
ges_asset_set_proxy (GESAsset *asset,
                     GESAsset *proxy);

A proxying asset is an asset that can substitue the real asset . For example if you have a full HD GESUriClipAsset you might want to set a lower resolution (HD version of the same file) as proxy. Note that when an asset is proxied, calling ges_asset_request will actually return the proxy asset.

ges_asset_list_proxies ()

GList *
ges_asset_list_proxies (GESAsset *asset);

ges_asset_get_proxy_target ()

GESAsset *
ges_asset_get_proxy_target (GESAsset *proxy);

ges_asset_get_proxy ()

GESAsset *
ges_asset_get_proxy (GESAsset *asset);

ges_asset_needs_reload ()

gboolean
ges_asset_needs_reload (GType extractable_type,
                        const gchar *id);

Sets an asset from the internal cache as needing reload. An asset needs reload in the case where, for example, we were missing a GstPlugin to use it and that plugin has been installed, or, that particular asset content as changed meanwhile (in the case of the usage of proxies).

Once an asset has been set as "needs reload", requesting that asset again will lead to it being re discovered, and reloaded as if it was not in the cache before.

GESAsset

typedef struct _GESAsset GESAsset;