Struct gstreamer_editing_services::Asset

pub struct Asset { /* private fields */ }

A Asset in the GStreamer Editing Services represents a resources that can be used. In particular, any class that implements the Extractable interface may have some associated assets with a corresponding extractable-type, from which its objects can be extracted using AssetExt::extract(). Some examples would be Clip, Formatter and TrackElement.

All assets that are created within GES are stored in a cache; one per each id and extractable-type pair. These assets can be fetched, and initialized if they do not yet exist in the cache, using request().

⚠️ The following code is in c ⚠️

GESAsset *effect_asset;
GESEffect *effect;

// You create an asset for an effect
effect_asset = ges_asset_request (GES_TYPE_EFFECT, "agingtv", NULL);

// And now you can extract an instance of GESEffect from that asset
effect = GES_EFFECT (ges_asset_extract (effect_asset));

The advantage of using assets, rather than simply creating the object directly, is that the currently loaded resources can be listed with ges_list_assets() and displayed to an end user. For example, to show which media files have been loaded, and a standard list of effects. In fact, the GES library already creates assets for TransitionClip and Formatter, which you can use to list all the available transition types and supported formats.

The other advantage is that Asset implements MetaContainer, so metadata can be set on the asset, with some subclasses automatically creating this metadata on initiation.

For example, to display information about the supported formats, you could do the following:

   GList *formatter_assets, *tmp;

   //  List all  the transitions
   formatter_assets = ges_list_assets (GES_TYPE_FORMATTER);

   // Print some infos about the formatter GESAsset
   for (tmp = formatter_assets; tmp; tmp = tmp->next) {
     gst_print ("Name of the formatter: %s, file extension it produces: %s",
       ges_meta_container_get_string (
         GES_META_CONTAINER (tmp->data), GES_META_FORMATTER_NAME),
       ges_meta_container_get_string (
         GES_META_CONTAINER (tmp->data), GES_META_FORMATTER_EXTENSION));
   }

   g_list_free (transition_assets);

ID

Each asset is uniquely defined in the cache by its extractable-type and id. Depending on the extractable-type, the id can be used to parametrise the creation of the object upon extraction. By default, a class that implements Extractable will only have a single associated asset, with an id set to the type name of its objects. However, this is overwritten by some implementations, which allow a class to have multiple associated assets. For example, for TransitionClip the id will be a nickname of the vtype. You should check the documentation for each extractable type to see if they differ from the default.

Moreover, each extractable-type may also associate itself with a specific asset subclass. In such cases, when their asset is requested, an asset of this subclass will be returned instead.

Managing

You can use a Project to easily manage the assets of a Timeline.

Proxies

Some assets can (temporarily) act as the proxy of another asset. When the original asset is requested from the cache, the proxy will be returned in its place. This can be useful if, say, you want to substitute a UriClipAsset corresponding to a high resolution media file with the asset of a lower resolution stand in.

An asset may even have several proxies, the first of which will act as its default and be returned on requests, but the others will be ordered to take its place once it is removed. You can add a proxy to an asset, or set its default, using AssetExt::set_proxy(), and you can remove them with AssetExt::unproxy().

Properties

extractable-type

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

Readable | Writeable | Construct Only

id

The ID of the asset. This should be unique amongst all assets with the same extractable-type. Depending on the associated Extractable implementation, this id may convey some information about the glib::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.

Readable | Writeable | Construct Only

proxy

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

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

Readable | Writeable

proxy-target

The asset that this asset is a proxy for, or None 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.

Readable

Implements

AssetExt, [trait@glib::ObjectExt], MetaContainerExt

Implementations

impl Asset

pub const NONE: Option<&'static Asset> = None

pub fn needs_reload(extractable_type: Type, id: Option<&str>) -> bool

Indicate that an existing 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 request() or request_async().

extractable_type

The extractable-type of the asset that needs reloading

id

The id of the asset asset that needs reloading

Returns

true if the specified asset exists in the cache and could be marked for reloading.

pub fn request( extractable_type: Type, id: Option<&str> ) -> Result<Option<Asset>, Error>

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 None 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 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 None 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 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 UriClip. For such assets this method will fail, and you should use request_async() instead. In the case of UriClip, you can use UriClipAsset::request_sync() if you only want to wait for the request to finish.

extractable_type

The extractable-type of the asset

id

The id of the asset

Returns

A reference to the requested asset, or None if an error occurred.

pub fn request_async<P: FnOnce(Result<Asset, Error>) + 'static>( extractable_type: Type, id: Option<&str>, cancellable: Option<&impl IsA<Cancellable>>, callback: P )

Requests an asset with the given properties asynchronously (see 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_request_finish() method on the given GAsyncResult.

Note that the source object passed to the callback will be the Asset corresponding to the request, but it may not have loaded correctly and therefore can not be used as is. Instead, ges_asset_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 running under the same GMainContext that ges_init() was called in. So, if you wish the callback to be invoked outside the default GMainContext, you can call g_main_context_push_thread_default() in a new thread before calling ges_init().

Example of an asynchronous asset request: ⚠️ The following code is in c ⚠️

// 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);

extractable_type

The extractable-type of the asset

id

The id of the asset

cancellable

An object to allow cancellation of the asset request, or None to ignore

callback

A function to call when the initialization is finished

pub fn request_future( extractable_type: Type, id: Option<&str> ) -> Pin<Box_<dyn Future<Output = Result<Asset, Error>> + 'static>>

Trait Implementations

impl Clone for Asset

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Asset

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HasParamSpec for Asset

type ParamSpec = ParamSpecObject

type SetValue = Asset

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecObjectBuilder<'_, Asset>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Asset

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Asset

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl ParentClassIs for Asset

type Parent = Object

impl<OT: ObjectType> PartialEq<OT> for Asset

fn eq(&self, other: &OT) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT: ObjectType> PartialOrd<OT> for Asset

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Asset

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Asset

impl IsA<Asset> for ClipAsset

impl IsA<Asset> for EffectAsset

impl IsA<Asset> for Project

impl IsA<Asset> for SourceClipAsset

impl IsA<Asset> for TrackElementAsset

impl IsA<Asset> for UriClipAsset

impl IsA<Asset> for UriSourceAsset

impl IsA<MetaContainer> for Asset

impl Send for Asset

impl Sync for Asset