Alias for #GstMapInfo to be used with g_auto():
A datatype to hold the handle to an outstanding sync or async clock callback.
A datatype to hold a time, measured in nanoseconds.
A datatype to hold a time difference, measured in nanoseconds.
A type defining the type of an element factory.
Alias for #GstMapInfo to be used with g_auto():
Flags for allocators.
GstBinFlags are a set of flags specific to bins. Most are set/used internally. They can be checked using the GST_OBJECT_FLAG_IS_SET() macro, and (un)set using GST_OBJECT_FLAG_SET() and GST_OBJECT_FLAG_UNSET().
A set of flags that can be provided to the gst.buffer.Buffer.copyInto function to specify which items should be copied.
A set of buffer flags used to describe properties of a #GstBuffer.
Additional flags to control the allocation of a buffer
The different types of buffering methods.
The standard flags that a bus may have.
The result values for a GstBusSyncHandler.
Extra flags for a caps.
Modes of caps intersection
The type of the clock entry
The capabilities of this clock
The return value of a clock operation.
The different kind of clocks.
Core errors are errors inside the core GStreamer library.
These are some terminal style flags you can use when creating your debugging categories to make them stand out in debugging output.
Available details for pipeline graphs produced by GST_DEBUG_BIN_TO_DOT_FILE() and GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS().
The level defines the importance of a debugging message. The more important a message is, the greater the probability that the debugging system outputs it.
The standard flags that an element may have.
#GstEventType lists the standard event types that can be sent in a pipeline.
#GstEventTypeFlags indicate the aspects of the different #GstEventType values. You can get the type flags of a #GstEventType with the gst.global.eventTypeGetFlags function.
The result of passing data to a pad.
Standard predefined formats
The different flags that can be set on #GST_EVENT_GAP events. See gst.event.Event.setGapFlags for details.
The result of a #GstIteratorItemFunction.
The result of gst.iterator.Iterator.next.
Library errors are for errors from the library being used by elements (initializing, finalizing, settings, ...)
Flags used when locking miniobjects
Flags used when mapping memory
Flags for wrapped memory.
The different message types that are available.
Extra metadata flags.
Flags for the mini object
The standard flags that an gstobject may have.
The direction of a pad.
Pad state flags
The amount of checking to be done when linking pads. @GST_PAD_LINK_CHECK_CAPS and @GST_PAD_LINK_CHECK_TEMPLATE_CAPS are mutually exclusive. If both are specified, expensive but safe @GST_PAD_LINK_CHECK_CAPS are performed.
Result values from gst_pad_link and friends.
The status of a GstPad. After activating a pad, which usually happens when the parent element goes from READY to PAUSED, the GstPadMode defines if the pad operates in push or pull mode.
Indicates when this pad will become available.
Different return values for the #GstPadProbeCallback.
The different probing types that can occur. When either one of @GST_PAD_PROBE_TYPE_IDLE or @GST_PAD_PROBE_TYPE_BLOCK is used, the probe will be a blocking probe.
Flags for the padtemplate
The different parsing errors that can occur.
Parsing options.
Pipeline flags
Flags used in connection with gst.plugin.Plugin.addDependency.
The plugin loading errors
The plugin loading state
The type of a gst.types.MessageType.Progress. The progress messages inform the application of the status of asynchronous tasks.
The result of a #GstPromise
The different types of QoS events that can be given to the gst.event.Event.newQos method.
Standard predefined Query types
#GstQueryTypeFlags indicate the aspects of the different #GstQueryType values. You can get the type flags of a #GstQueryType with the gst.global.queryTypeGetFlags function.
Element priority ranks. Defines the order in which the autoplugger (or similar rank-picking mechanisms, such as e.g. gst.element.Element.makeFromUri) will choose this element over an alternative one with the same function.
Resource errors are for any resource used by an element: memory, files, network connections, process space, ... They're typically used by source and sink elements.
The different scheduling flags.
The different search modes.
Flags to be used with gst.element.Element.seek or gst.event.Event.newSeek. All flags can be used together.
The different types of seek events. When constructing a seek event with gst.event.Event.newSeek or when doing gst_segment_do_seek ().
Flags for the GstSegment structure. Currently mapped to the corresponding values of the seek flags.
The possible states an element can be in. States can be changed using gst.element.Element.setState and checked using gst.element.Element.getState.
These are the different state changes an element goes through. gst.types.State.Null ⇒ gst.types.State.Playing is called an upwards state change and gst.types.State.Playing ⇒ gst.types.State.Null a downwards state change.
The possible return values from a state change function such as gst.element.Element.setState. Only @GST_STATE_CHANGE_FAILURE is a real failure.
Stream errors are for anything related to the stream being processed: format errors, media type errors, ... They're typically used by decoders, demuxers, converters, ...
The type of a gst.types.MessageType.StreamStatus. The stream status messages inform the application of new streaming threads and their status.
#GstStreamType describes a high level classification set for flows of data in #GstStream objects.
The type of a gst.types.MessageType.StructureChange.
Extra tag flags used when registering tags.
The different tag merging modes are basically replace, overwrite and append, but they can be seen from two directions. Given two taglists: (A) the tags already in the element and (B) the ones that are supplied to the element ( e.g. via gst.tag_setter.TagSetter.mergeTags / gst.tag_setter.TagSetter.addTags or a gst.types.EventType.Tag), how are these tags merged? In the table below this is shown for the cases that a tag exists in the list (A) or does not exists (!A) and combinations thereof.
GstTagScope specifies if a taglist applies to the complete medium or only to one single stream.
The different states a task can be in
The different types of TOC entries (see #GstTocEntry).
How a #GstTocEntry should be repeated. By default, entries are played a single time.
The scope of a TOC.
Flag that describe the value. These flags help applications processing the logs to understand the values.
Tracing record will contain fields that contain a measured value or extra meta-data. One such meta data are values that tell where a measurement was taken. This enumerating declares to which scope such a meta data field relates to. If it is e.g. gst.types.TracerValueScope.Pad, then each of the log events may contain values for different #GstPads.
The probability of the typefind function. Higher values have more certainty in doing a reliable typefind.
Different URI-related errors that can occur.
The different types of URI direction.
Parameters to control the allocation of memory
Memory is usually created by allocators with a gst.allocator.Allocator.alloc method call. When null is used as the allocator, the default allocator will be used.
The #GstAllocator is used to create new memory.
The #GstAtomicQueue object implements a queue that can be used from multiple threads without performing any blocking operations.
#GstBin is an element that can contain other #GstElement, allowing them to be managed as a group. Pads from the child elements can be ghosted to the bin, see #GstGhostPad. This makes the bin look like any other elements and enables creation of higher-level abstraction elements.
Subclasses can override #GstBinClass::add_element and #GstBinClass::remove_element to update the list of children in the bin.
A fundamental type that describes a 64-bit bitmask
Buffers are the basic unit of data transfer in GStreamer. They contain the timing and offset along with other arbitrary metadata that is associated with the #GstMemory blocks that the buffer contains.
Buffer lists are an object containing a list of buffers.
A #GstBufferPool is an object that can be used to pre-allocate and recycle buffers of the same size and with the same properties.
Parameters passed to the gst.buffer_pool.BufferPool.acquireBuffer function to control the allocation of the buffer.
The #GstBufferPool class.
The #GstBus is an object responsible for delivering #GstMessage packets in a first-in first-out way from the streaming threads (see #GstTask) to the application.
GStreamer bus class.
Interface for an array of bytes. It is expected to be subclassed to implement @resize virtual method using language native array implementation, such as GLib's #GByteArray, C++'s std::vector<uint8_t> or Rust's Vec<u8>.
Caps (capabilities) are lightweight refcounted objects describing media types. They are composed of an array of #GstStructure.
#GstCapsFeatures can optionally be set on a #GstCaps to add requirements for additional features for a specific #GstStructure. Caps structures with the same name but with a non-equal set of caps features are not compatible. If a pad supports multiple sets of features it has to add multiple equal structures with different feature sets to the caps.
This interface abstracts handling of property sets for elements with children. Imagine elements such as mixers or polyphonic generators. They all have multiple #GstPad or some kind of voice objects. Another use case are container elements like #GstBin. The element implementing the interface acts as a parent for those child objects.
#GstChildProxy interface.
GStreamer uses a global clock to synchronize the plugins in a pipeline. Different clock implementations are possible by implementing this abstract base class or, more conveniently, by subclassing #GstSystemClock.
GStreamer clock class. Override the vmethods to implement the clock functionality.
All pending timeouts or periodic notifies are converted into an entry. Note that GstClockEntry should be treated as an opaque structure. It must not be extended or allocated using a custom allocator.
#GstContext is a container object used to store contexts like a device context, a display server connection and similar concepts that should be shared between multiple elements.
A base class for value mapping objects that attaches control sources to #GObject properties. Such an object is taking one or more #GstControlSource instances, combines them and maps the resulting value to the type and value range of the bound property.
The class structure of #GstControlBinding.
The #GstControlSource is a base class for control value sources that could be used to get timestamp-value pairs. A control source essentially is a function over time.
The class structure of #GstControlSource.
Extra custom metadata. The @structure field is the same as returned by gst.custom_meta.CustomMeta.getStructure.
Struct to store date, time and timezone information altogether. #GstDateTime is refcounted and immutable.
This is the struct that describes the categories. Once initialized with #GST_DEBUG_CATEGORY_INIT, its values can't be changed anymore.
#GstDevice are objects representing a device, they contain relevant metadata about the device, such as its class and the #GstCaps representing the media types it can produce or handle.
The class structure for a #GstDevice object.
Applications should create a #GstDeviceMonitor when they want to probe, list and monitor devices of a specific type. The #GstDeviceMonitor will create the appropriate #GstDeviceProvider objects and manage them. It will then post messages on its #GstBus for devices that have been added and removed.
Opaque device monitor class structure.
A #GstDeviceProvider subclass is provided by a plugin that handles devices if there is a way to programmatically list connected devices. It can also optionally provide updates to the list of connected devices.
The structure of the base #GstDeviceProviderClass
#GstDeviceProviderFactory is used to create instances of device providers. A GstDeviceProviderfactory can be added to a #GstPlugin as it is also a #GstPluginFeature.
The opaque #GstDeviceProviderFactoryClass data structure.
A fundamental type that describes a #gdouble range
#GstDynamicTypeFactory is used to represent a type that can be automatically loaded the first time it is used. For example, a non-standard type for use in caps fields.
GstElement is the abstract base class needed to construct an element that can be used in a GStreamer pipeline. Please refer to the plugin writers guide for more information on creating #GstElement subclasses.
GStreamer element class. Override the vmethods to implement the element functionality.
#GstElementFactory is used to create instances of elements. A GstElementFactory can be added to a #GstPlugin as it is also a #GstPluginFeature.
The event class provides factory methods to construct events for sending and functions to query (parse) received events.
A fundamental type that describes a 32-bit flag bitfield, with 32-bit mask indicating which of the bits in the field are explicitly set.
A format definition
A fundamental type that describes a fraction of an integer numerator over an integer denominator
A fundamental type that describes a #GstFractionRange range
GhostPads are useful when organizing pipelines with #GstBin like elements. The idea here is to create hierarchical element graphs. The bin element contains a sub-graph. Now one would like to treat the bin-element like any other #GstElement. This is where GhostPads come into play. A GhostPad acts as a proxy for another pad. Thus the bin can have sink and source ghost-pads that are associated with sink and source pads of the child elements.
A fundamental type that describes a #gint64 range
A fundamental type that describes a #gint range
A GstIterator is used to retrieve multiple objects from another object in a threadsafe way.
A structure containing the result of a map operation such as gst.memory.Memory.map. It contains the data and size.
GstMemory is a lightweight refcounted object that wraps a region of memory. They are typically used to manage the data of a #GstBuffer.
Messages are implemented as a subclass of #GstMiniObject with a generic #GstStructure as the content. This allows for writing custom messages without requiring an API change while allowing a wide range of different types of messages.
The #GstMeta structure should be included as the first member of a #GstBuffer metadata structure. The structure defines the API of the metadata and should be accessible to all elements using the metadata.
The #GstMetaInfo provides information about a specific metadata structure.
Extra data passed to a "gst-copy" transform #GstMetaTransformFunction.
#GstMiniObject is a simple structure that can be used to implement refcounted types.
#GstObject provides a root for the object hierarchy tree filed in by the GStreamer library. It is currently a thin wrapper on top of #GInitiallyUnowned. It is an abstract class that is not very usable on its own.
GStreamer base object class.
A #GstElement is linked to other elements via "pads", which are extremely light-weight generic link points.
Info passed in the #GstPadProbeCallback.
Padtemplates describe the possible media types a pad or an elementfactory can handle. This allows for both inspection of handled types before loading the element plugin as well as identifying pads on elements that are not yet created (request or sometimes pads).
A fundamental type that describes a #GParamSpec for arrays of values
A fundamental type that describes a #GParamSpec for fractional properties
A GParamSpec derived structure for arrays of values.
A GParamSpec derived structure that contains the meta data for fractional properties.
The #GstParentBufferMeta is a #GstMeta which can be attached to a #GstBuffer to hold a reference to another buffer that is only released when the child #GstBuffer is released.
Opaque structure.
A #GstPipeline is a special #GstBin used as the toplevel container for the filter graph. The #GstPipeline will manage the selection and distribution of a global #GstClock as well as provide a #GstBus to the application.
GStreamer is extensible, so #GstElement instances can be loaded at runtime. A plugin system can provide one or more of the basic GStreamer #GstPluginFeature subclasses.
A plugin should export a variable of this type called plugin_desc. The plugin loader will use the data provided there to initialize the plugin.
This is a base class for anything that can be added to a #GstPlugin.
A #GstPoll keeps track of file descriptors much like fd_set (used with select ()) or a struct pollfd array (used with poll ()). Once created with gst.poll.Poll.new_, the set can be used to wait for file descriptors to be readable and/or writable. It is possible to make this wait be controlled by specifying true for the @controllable flag when creating the set (or later calling gst.poll.Poll.setControllable).
A file descriptor object.
This interface offers methods to query and manipulate parameter preset sets. A preset is a bunch of property settings, together with meta data and a name. The name of a preset serves as key for subsequent method calls to manipulate single presets. All instances of one type will share the list of presets. The list is created on demand, if presets are not used, the list is not created.
#GstPreset interface.
The #GstPromise object implements the container for values that may be available later. i.e. a Future or a Promise in <https://en.wikipedia.org/wiki/Futures_and_promises>. As with all Future/Promise-like functionality, there is the concept of the producer of the value and the consumer of the value.
Metadata type that holds information about a sample from a protection-protected track, including the information needed to decrypt it (if it is encrypted).
Queries can be performed on pads (gst.pad.Pad.query) and elements (gst.element.Element.query). Please note that some queries might need a running pipeline to work.
#GstReferenceTimestampMeta can be used to attach alternative timestamps and possibly durations to a #GstBuffer. These are generally not according to the pipeline clock and could be e.g. the NTP timestamp when the media was captured.
One registry holds the metadata of a set of plugins.
A #GstSample is a small object containing data, a type, timing and extra arbitrary information.
This helper structure holds the relevant values for tracking the region of interest in a media file, called a segment.
The #GstSharedTaskPool object.
The #GstSharedTaskPoolClass object.
Data structure to initialize #GstCaps from a string description usually used in conjunction with GST_STATIC_CAPS() and gst.static_caps.StaticCaps.get to instantiate a #GstCaps.
Structure describing the #GstStaticPadTemplate.
A high-level object representing a single stream. It might be backed, or not, by an actual flow of data in a pipeline (#GstPad).
GstStream class structure
A collection of #GstStream that are available.
GstStreamCollection class structure
A #GstStructure is a collection of key/value pairs. The keys are expressed as GQuarks and the values can be of any GType.
The GStreamer core provides a GstSystemClock based on the system time. Asynchronous callbacks are scheduled from an internal thread.
List of tags and values used to describe media metadata.
Element interface that allows setting of media metadata.
#GstTagSetterInterface interface.
#GstTask is used by #GstElement and #GstPad to provide the data passing threads in a #GstPipeline.
This object provides an abstraction for creating threads. The default implementation uses a regular GThreadPool to start tasks.
The #GstTaskPoolClass object.
Structure for storing a timestamp and a value.
#GstToc functions are used to create/free #GstToc and #GstTocEntry structures. Also they are used to convert #GstToc into #GstStructure and vice versa.
Element interface that allows setting of the TOC.
#GstTocSetterInterface interface.
Tracing modules will subclass #GstTracer and register through gst.tracer.Tracer.register. Modules can attach to various hook-types - see gst.global.tracingRegisterHook. When invoked they receive hook specific contextual data, which they must not modify.
Use gst.tracer_factory.TracerFactory.getList to get a list of tracer factories known to GStreamer.
Tracing modules will create instances of this class to announce the data they will log and create a log formatter.
The following functions allow you to detect the media type of an unknown stream.
These functions allow querying information about registered typefind functions. How to create and register these functions is described in the section <link linkend="gstreamer-Writing-typefind-functions"> "Writing typefind functions"</link>.
The #GstURIHandler is an interface that is implemented by Source and Sink #GstElement to unify handling of URI.
Any #GstElement using this interface should implement these methods.
A #GstUri object can be used to parse and split a URI string into its constituent parts. Two #GstUri objects can be joined to make a new #GstUri using the algorithm described in RFC3986.
A fundamental type that describes an ordered list of #GValue
A fundamental type that describes an unordered list of #GValue
VTable for the #GValue @type.