Meta#

class Meta(*args, **kwargs)#

The Meta structure should be included as the first member of a Buffer metadata structure. The structure defines the API of the metadata and should be accessible to all elements using the metadata.

A metadata API is registered with api_type_register() which takes a name for the metadata API and some tags associated with the metadata. With api_type_has_tag() one can check if a certain metadata API contains a given tag.

Multiple implementations of a metadata API can be registered. To implement a metadata API, register() should be used. This function takes all parameters needed to create, free and transform metadata along with the size of the metadata. The function returns a MetaInfo structure that contains the information for the implementation of the API.

A specific implementation can be retrieved by name with get_info().

See Buffer for how the metadata can be added, retrieved and removed from buffers.

Methods#

class Meta
classmethod api_type_aggregate_params(api: GType, aggregated_params: Structure, params0: Structure, params1: Structure) → bool#

When a element like tee decides the allocation, each downstream element may fill different parameters and pass them to add_allocation_meta(). In order to keep these parameters, a merge operation is needed. This aggregate function can combine the parameters from params0 and param1, and write the result back into aggregated_params.

Added in version 1.26.

Parameters:

  • api – the GType of the API for which the parameters are being aggregated.

  • aggregated_params – This structure will be updated with the combined parameters from both params0 and params1.

  • params0 – a Structure containing the new parameters to be aggregated.

  • params1 – a Structure containing the new parameters to be aggregated.

classmethod api_type_get_tags(api: GType) → list[str]#

Added in version 1.2.

Parameters:

api – an API

classmethod api_type_has_tag(api: GType, tag: int) → bool#

Check if api was registered with tag.

Parameters:

  • api – an API

  • tag – the tag to check

classmethod api_type_register(api: str, tags: list[str]) → GType#

Register and return a GType for the api and associate it with tags.

Parameters:

  • api – an API to register

  • tags – tags for api

classmethod api_type_set_params_aggregator(api: GType, aggregator: Callable[[Structure, Structure, Structure], bool]) → None#

This function sets the aggregator function for a specific API type.

Added in version 1.26.

Parameters:

  • api – the Type of the API for which the aggregator function is being set.

  • aggregator – the aggregator function to be associated with the given API type.

classmethod api_type_tags_contain_only(api: GType, valid_tags: list[str]) → bool#

Added in version 1.28.

Parameters:

  • api – an API

  • valid_tags – a list of valid tags

compare_seqnum(meta2: Meta) → int#

Meta sequence number compare function. Can be used as CompareFunc or a CompareDataFunc.

Added in version 1.16.

Parameters:

meta2 – a Meta

classmethod deserialize(buffer: Buffer, data: list[int]) → tuple[Meta | None, int]#

Recreate a Meta from serialized data returned by serialize() and add it to buffer.

Note that the meta must have been previously registered by calling one of gst_*_meta_get_info () functions.

consumed is set to the number of bytes that can be skipped from data to find the next meta serialization, if any. In case of parsing error that does not allow to determine that size, consumed is set to 0.

Added in version 1.24.

Parameters:
classmethod get_info(impl: str) → MetaInfo | None#

Lookup a previously registered meta info structure by its implementation name impl.

Parameters:

impl – the name

get_seqnum() → int#

Gets seqnum for this meta.

Added in version 1.16.

classmethod register_custom(name: str, tags: list[str], transform_func: Callable[[Buffer, CustomMeta, Buffer, int, Any, Any], bool] | None = None, user_data: Any = None) → MetaInfo#

Register a new custom Meta implementation, backed by an opaque structure holding a Structure.

The registered info can be retrieved later with get_info() by using name as the key.

The backing Structure can be retrieved with get_structure(), its mutability is conditioned by the writability of the buffer the meta is attached to.

When transform_func is None, the meta and its backing Structure will always be copied when the transform operation is copy, other operations are discarded, copy regions are ignored.

Added in version 1.20.

Parameters:

  • name – the name of the Meta implementation

  • tags – tags for api

  • transform_func – a MetaTransformFunction

  • user_data – user data passed to transform_func

classmethod register_custom_simple(name: str) → MetaInfo#

Simplified version of register_custom(), with no tags and no transform function.

Added in version 1.24.

Parameters:

name – the name of the Meta implementation

serialize(data: ByteArrayInterface) → bool#

Serialize meta into a format that can be stored or transmitted and later deserialized by deserialize().

This is only supported for meta that implements MetaInfo.serialize_func, False is returned otherwise.

Upon failure, data->data pointer could have been reallocated, but data->len won’t be modified. This is intended to be able to append multiple metas into the same GByteArray.

Since serialization size is often the same for every buffer, caller may want to remember the size of previous data to preallocate the next.

Added in version 1.24.

Parameters:

data – ByteArrayInterface to append serialization data

serialize_simple(data: list[int]) → bool#

Same as serialize() but with a GByteArray instead of ByteArrayInterface.

Added in version 1.24.

Parameters:

data – GByteArray to append serialization data

Fields#

class Meta
flags#

Extra flags for the metadata

info#

Pointer to the MetaInfo