GESAsset

GES.Asset

GObject.Object
    ╰──GES.Asset
        ╰──GES.ClipAsset
        ╰──GES.Project
        ╰──GES.TrackElementAsset

GES.Asset.prototype.extract

function GES.Asset.prototype.extract(): {
    // javascript wrapper for 'ges_asset_extract'
}

Extracts a new extractable-type object from the asset. The id of the asset may determine the properties and state of the newly created object.

GES.Asset.prototype.get_error

function GES.Asset.prototype.get_error(): {
    // javascript wrapper for 'ges_asset_get_error'
}

Retrieve the error that was set on the asset when it was loaded.

Since : 1.8

GES.Asset.prototype.get_extractable_type

function GES.Asset.prototype.get_extractable_type(): {
    // javascript wrapper for 'ges_asset_get_extractable_type'
}

Gets the extractable-type of the asset.

GES.Asset.prototype.get_id

function GES.Asset.prototype.get_id(): {
    // javascript wrapper for 'ges_asset_get_id'
}

Gets the id of the asset.

GES.Asset.prototype.get_proxy

function GES.Asset.prototype.get_proxy(): {
    // javascript wrapper for 'ges_asset_get_proxy'
}

Gets the default proxy of the asset.

GES.Asset.prototype.get_proxy_target

function GES.Asset.prototype.get_proxy_target(): {
    // javascript wrapper for 'ges_asset_get_proxy_target'
}

Gets the proxy-target of the asset.

Note that the proxy target may have loaded with an error, so you should call GES.Asset.prototype.get_error on the returned target.

GES.Asset.prototype.list_proxies

function GES.Asset.prototype.list_proxies(): {
    // javascript wrapper for 'ges_asset_list_proxies'
}

Get all the proxies that the asset has. The first item of the list will be the default proxy. The second will be the proxy that is 'next in line' to be default, and so on.

GES.Asset.prototype.set_proxy

function GES.Asset.prototype.set_proxy(proxy: GES.Asset): {
    // javascript wrapper for 'ges_asset_set_proxy'
}

Sets the proxy for the asset.

If proxy is among the existing proxies of the asset (see GES.Asset.prototype.list_proxies) it will be moved to become the default proxy. Otherwise, if proxy is not null, it will be added to the list of proxies, as the new default. The previous default proxy will become 'next in line' for if the new one is removed, and so on. As such, this will **not** actually remove the previous default proxy (use GES.Asset.prototype.unproxy for that).

Note that an asset can only act as a proxy for one other asset.

As a special case, if proxy is null, then this method will actually remove all proxies from the asset.

GES.Asset.prototype.unproxy

function GES.Asset.prototype.unproxy(proxy: GES.Asset): {
    // javascript wrapper for 'ges_asset_unproxy'
}

Removes the proxy from the available list of proxies for the asset. If the given proxy is the default proxy of the list, then the next proxy in the available list (see GES.Asset.prototype.list_proxies) will become the default. If there are no other proxies, then the asset will no longer have a default proxy.

GES.Asset.prototype.needs_reload

function GES.Asset.prototype.needs_reload(extractable_type: GObject.Type, id: String): {
    // javascript wrapper for 'ges_asset_needs_reload'
}

Indicate that an existing GES.Asset in the cache should be reloaded upon the next request. This can be used when some condition has changed, which may require that an existing asset should be updated. For example, if an external resource has changed or now become available.

Note, the asset is not immediately changed, but will only actually reload on the next call to GES.Asset.prototype.request or GES.Asset.prototype.request_async.

GES.Asset.prototype.request

function GES.Asset.prototype.request(extractable_type: GObject.Type, id: String): {
    // javascript wrapper for 'ges_asset_request'
}

Returns an asset with the given properties. If such an asset already exists in the cache (it has been previously created in GES), then a reference to the existing asset is returned. Otherwise, a newly created asset is returned, and also added to the cache.

If the requested asset has been loaded with an error, then error is set, if given, and null will be returned instead.

Note that the given id may not be exactly the id that is set on the returned asset. For instance, it may be adjusted into a standard format. Or, if a GES.Extractable type does not have its extraction parametrised, as is the case by default, then the given id may be ignored entirely and the id set to some standard, in which case a null id can be given.

Similarly, the given extractable_type may not be exactly the extractable-type that is set on the returned asset. Instead, the actual extractable type may correspond to a subclass of the given extractable_type, depending on the given id.

Moreover, depending on the given extractable_type, the returned asset may belong to a subclass of GES.Asset.

Finally, if the requested asset has a proxy, then the proxy that is found at the end of the chain of proxies is returned (a proxy's proxy will take its place, and so on, unless it has no proxy).

Some asset subclasses only support asynchronous construction of its assets, such as GES.UriClip. For such assets this method will fail, and you should use GES.Asset.prototype.request_async instead. In the case of GES.UriClip, you can use GES.UriClipAsset.prototype.request_sync if you only want to wait for the request to finish.

GES.Asset.prototype.request_async

function GES.Asset.prototype.request_async(extractable_type: GObject.Type, id: String, cancellable: Gio.Cancellable, callback: Gio.AsyncReadyCallback, user_data: Object): {
    // javascript wrapper for 'ges_asset_request_async'
}

Requests an asset with the given properties asynchronously (see GES.Asset.prototype.request). When the asset has been initialized or fetched from the cache, the given callback function will be called. The asset can then be retrieved in the callback using the GES.Asset.prototype.request_finish method on the given Gio.AsyncResult.

Note that the source object passed to the callback will be the GES.Asset corresponding to the request, but it may not have loaded correctly and therefore can not be used as is. Instead, GES.Asset.prototype.request_finish should be used to fetch a usable asset, or indicate that an error occurred in the asset's creation.

Note that the callback will be called in the GMainLoop (not introspectable) running under the same GMainContext (not introspectable) that GES.prototype.init was called in. So, if you wish the callback to be invoked outside the default GMainContext (not introspectable), you can call GLib.MainContext.prototype.push_thread_default in a new thread before calling GES.prototype.init.

Example of an asynchronous asset request:

// 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) {
   gst_print ("The file: %s is usable as a GESUriClip",
       ges_asset_get_id (asset));
  } else {
   gst_print ("The file: %s is *not* usable as a GESUriClip because: %s",
       ges_asset_get_id (source), error->message);
  }

  gst_object_unref (asset);
}

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

GES.Asset.prototype.request_finish

function GES.Asset.prototype.request_finish(res: Gio.AsyncResult): {
    // javascript wrapper for 'ges_asset_request_finish'
}

Fetches an asset requested by GES.Asset.prototype.request_async, which finalises the request.

extractable-type

“extractable-type” GObject.Type

The GES.Extractable object type that can be extracted from the asset.

Flags : Read / Write / Construct Only

id

“id” String

The ID of the asset. This should be unique amongst all assets with the same extractable-type. Depending on the associated GES.Extractable implementation, this id may convey some information about the GObject.Object that should be extracted. Note that, as such, the ID will have an expected format, and you can not choose this value arbitrarily. By default, this will be set to the type name of the extractable-type, but you should check the documentation of the extractable type to see whether they differ from the default behaviour.

Flags : Read / Write / Construct Only

proxy

“proxy” GES.Asset

The default proxy for this asset, or null if it has no proxy. A proxy will act as a substitute for the original asset when the original is requested (see GES.Asset.prototype.request).

Setting this property will not usually remove the existing proxy, but will replace it as the default (see GES.Asset.prototype.set_proxy).

Flags : Read / Write

proxy-target

“proxy-target” GES.Asset

The asset that this asset is a proxy for, or null if it is not a proxy for another asset.

Note that even if this asset is acting as a proxy for another asset, but this asset is not the default proxy, then proxy-target will still point to this other asset. So you should check the proxy property of target-proxy before assuming it is the current default proxy for the target.

Note that the notify for this property is emitted after the proxy notify for the corresponding (if any) asset it is now the proxy of/no longer the proxy of.

Flags : Read

vfunc_extract

function vfunc_extract(self: GES.Asset): {
    // javascript implementation of the 'extract' virtual method
}

A method that returns a new object of the asset's extractable-type, or null if an error occurs. The default implementation will fetch the properties of the GES.Extractable from its get_parameters_from_id class method and set them on a new extractable-type GObject.Object, which is returned.

vfunc_inform_proxy

function vfunc_inform_proxy(self: GES.Asset, proxy_id: String): {
    // javascript implementation of the 'inform_proxy' virtual method
}

vfunc_proxied

function vfunc_proxied(self: GES.Asset, proxy: GES.Asset): {
    // javascript implementation of the 'proxied' virtual method
}

Deprecated: 1.18: This vmethod is no longer called.

vfunc_request_id_update

function vfunc_request_id_update(self: GES.Asset, proposed_new_id: String, error: GError (not introspectable)): {
    // javascript implementation of the 'request_id_update' virtual method
}

A method called by a GES.Project when an asset has failed to load. error is the error given by ges_asset_request_finish (). Returns: true if a new id for self was passed to proposed_new_id.

vfunc_start_loading

function vfunc_start_loading(self: GES.Asset): {
    // javascript implementation of the 'start_loading' virtual method
}

A method to be called when an asset is being requested asynchronously. This will be after the properties of the asset have been set, so it is tasked with (re)loading the 'state' of the asset. The return value should indicated whether the loading is complete, is carrying on asynchronously, or an error occurred. The default implementation will simply return that loading is already complete (the asset is already in a usable state after the properties have been set).

GES.prototype.list_assets

function GES.prototype.list_assets(filter: GObject.Type): {
    // javascript wrapper for 'ges_list_assets'
}

List all the assets in the current cache whose extractable-type are of the given type (including subclasses).

Note that, since only a GES.Extractable can be extracted from an asset, using GES_TYPE_EXTRACTABLE as filter will return all the assets in the current cache.

GES.AssetLoadingReturn