gstreamer-0.10

---

Description:

Content:

Namespaces:

• Gst

Interfaces:

• ChildProxy - This interface abstracts handling of property sets for elements with children. Imagine elements such as mixers or polyphonic generators. They all have multiple Pad or some kind of voice objects. Another use case are container elements like Bin. The element implementing the interface acts as a parent for those child objects. By implementing this interface the child properties can be accessed from the parent element by using get and set. Property names are written as "child-name::property-name". The whole naming scheme is recursive. Thus "child1::child2::property" is valid too, if "child1" and "child2" implement the ChildProxy interface.
• ImplementsInterface - Provides interface functionality on per instance basis and not per class basis, which is the case for gobject.
• Preset - 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. The interface comes with a default implementation that serves most plugins. Wrapper plugins will override most methods to implement support for the native preset format of those wrapped plugins. One method that is useful to be overridden is get_property_names. With that one can control which properties are saved and in which order.
• TagSetter - Element interface that allows setting of media metadata. Elements that support changing a stream's metadata will implement this interface. Examples of such elements are 'vorbisenc', 'theoraenc' and 'id3v2mux'. If you just want to retrieve metadata in your application then all you need to do is watch for tag messages on your pipeline's bus. This interface is only for setting metadata, not for extracting it. To set tags from the application, find tagsetter elements and set tags using e.g. merge_tags or add_tags. Also consider setting the TagMergeMode that is used for tag events that arrive at the tagsetter element (default mode is to keep existing tags). The application should do that before the element goes to PAUSED. Elements implementing the TagSetter interface often have to merge any tags received from upstream and the tags set by the application via the interface. This can be done like this:
• URIHandler - The URIHandler is an interface that is implemented by Source and Sink Element to simplify then handling of URI. An application can use the following functions to quickly get an element that handles the given URI for reading or writing (gst_element_make_from_uri()). Source and Sink plugins should implement this interface when possible. Last reviewed on 2005-11-09 (0.9.4)

Classes:

• AllocTrace - The main tracing object
• AtomicQueue - The AtomicQueue object implements a queue that can be used from multiple threads without performing any blocking operations.
• Bin - Subclasses can override the add_element and remove_element to update the list of children in the bin. The handle_message method can be overridden to implement custom message handling. handle_message takes ownership of the message, just like post_message.
• Buffer - Buffers are the basic unit of data transfer in GStreamer. The Buffer type provides all the state necessary to define a region of memory as part of a stream. Sub-buffers are also supported, allowing a smaller region of a buffer to become its own buffer, with mechanisms in place to ensure that neither memory space goes away prematurely. Buffers are usually created with Buffer. After a buffer has been created one will typically allocate memory for it and set the size of the buffer data. The following example creates a buffer that can hold a given video frame with a given width, height and bits per plane.
• BufferList -
• BufferListIterator - Opaque iterator for a BufferList.
• Bus - The Bus is an object responsible for delivering Message packets in a first-in first-out way from the streaming threads (see Task) to the application. Since the application typically only wants to deal with delivery of these messages from one thread, the GstBus will marshall the messages between different threads. This is important since the actual streaming of media is done in another thread than the application. The GstBus provides support for Source based notifications. This makes it possible to handle the delivery in the glib mainloop. The Source callback function async_signal_func can be used to convert all bus messages into signal emissions. A message is posted on the bus with the post method. With the peek and pop methods one can look at or retrieve a previously posted message. The bus can be polled with the poll method. This methods blocks up to the specified timeout value until one of the specified messages types is posted on the bus. The application can then pop the messages from the bus to handle them. Alternatively the application can register an asynchronous bus function using add_watch_full or gst_bus_add_watch. This function will install a Source in the default glib main loop and will deliver messages a short while after they have been posted. Note that the main loop should be running for the asynchronous callbacks. It is also possible to get messages from the bus without any thread marshalling with the set_sync_handler method. This makes it possible to react to a message in the same thread that posted the message on the bus. This should only be used if the application is able to deal with messages from different threads. Every Pipeline has one bus. Note that a Pipeline will set its bus into flushing state when changing from READY to NULL state. Last reviewed on 2006-03-12 (0.10.5)
• Caps - Caps (capabilities) are lighweight refcounted objects describing media types. They are composed of an array of Structure. Caps are exposed on PadTemplate to describe all possible types a given pad can handle. They are also stored in the Registry along with a description of the Element. Caps are exposed on the element pads using the get_caps pad function. This function describes the possible types that the pad can handle or produce at runtime. Caps are also attached to buffers to describe to content of the data pointed to by the buffer with set_caps. Caps attached to a Buffer allow for format negotiation upstream and downstream. A Caps can be constructed with the following code fragment:
• Clock - GStreamer clock class. Override the vmethods to implement the clock functionality.
• ClockEntry - 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.
• ClockID - A datatype to hold the handle to an outstanding sync or async clock callback.
• Date -
• DateTime - Struct to store date, time and timezone information altogether. DateTime is refcounted and immutable. Date information is handled using the proleptic Gregorian calendar. Provides basic creation functions and accessor functions to its fields.
• DebugCategory - This is the struct that describes the categories. Once initialized with init, its values can't be changed anymore.
• DebugMessage -
• Element - GStreamer element class. Override the vmethods to implement the element functionality.
• ElementFactory - ElementFactory is used to create instances of elements. A GstElementfactory can be added to a Plugin as it is also a PluginFeature. Use the find and create functions to create element instances or use make as a convenient shortcut. The following code example shows you how to create a GstFileSrc element.
• ElementFactoryListType -
• Event - The event class provides factory methods to construct events for sending and functions to query (parse) received events. Events are usually created with gst_event_new_*() which takes event-type specific parameters as arguments. To send an event application will usually use send_event and elements will use send_event or push_event. The event should be unreffed with unref if it has not been sent. Events that have been received can be parsed with their respective gst_event_parse_*() functions. It is valid to pass null for unwanted details. Events are passed between elements in parallel to the data stream. Some events are serialized with buffers, others are not. Some events only travel downstream, others only upstream. Some events can travel both upstream and downstream. The events are used to signal special conditions in the datastream such as EOS (end of stream) or the start of a new stream-segment. Events are also used to flush the pipeline of any pending data. Most of the event API is used inside plugins. Applications usually only construct and use seek events. To do that Event.seek is used to create a seek event. It takes the needed parameters to specity seeking time and mode.
• GError -
• GhostPad - GhostPads are useful when organizing pipelines with Bin 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 Element. 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. If the target pad is known at creation time, GhostPad is the function to use to get a ghost-pad. Otherwise one can use GhostPad.no_target to create the ghost-pad and use set_target to establish the association later on. Note that GhostPads add overhead to the data processing of a pipeline. Last reviewed on 2005-11-18 (0.9.5)
• Index - GstIndex is used to generate a stream index of one or more elements in a pipeline. Elements will overload the set_index and get_index virtual methods in Element. When streaming data, the element will add index entries if it has an index set. Each element that adds to the index will do that using a writer_id. The writer_id is obtained from get_writer_id. The application that wants to index the stream will create a new index object using Index or make. The index is assigned to a specific element, a bin or the whole pipeline. This will cause indexable elements to add entires to the index while playing.
• IndexEntry - The basic element of an index.
• IndexFactory - GstIndexFactory is used to dynamically create GstIndex implementations.
• Iterator - A GstIterator is used to retrieve multiple objects from another object in a threadsafe way. Various GStreamer objects provide access to their internal structures using an iterator. In general, whenever calling a GstIterator function results in your code receiving a refcounted object, the refcount for that object will have been increased. Your code is responsible for unrefing that object after use. The basic use pattern of an iterator is as follows:
• Message - Messages are implemented as a subclass of MiniObject with a generic Structure as the content. This allows for writing custom messages without requiring an API change while allowing a wide range of different types of messages. Messages are posted by objects in the pipeline and are passed to the application using the Bus. The basic use pattern of posting a message on a Bus is as follows:
• MiniObject - MiniObject is a baseclass like Object, but has been stripped down of features to be fast and small. It offers sub-classing and ref-counting in the same way as Object does. It has no properties and no signal-support though. Last reviewed on 2005-11-23 (0.9.5)
• Object - GStreamer base object class.
• Pad - A Element is linked to other elements via "pads", which are extremely light-weight generic link points. After two pads are retrieved from an element with get_pad, the pads can be link with link. (For quick links, you can also use link, which will make the obvious link for you if it's straightforward.) Pads are typically created from a PadTemplate with Pad.from_template. Pads have Caps attached to it to describe the media type they are capable of dealing with. get_caps and set_caps are used to manipulate the caps of the pads. Pads created from a pad template cannot set capabilities that are incompatible with the pad template capabilities. Pads without pad templates can be created with Pad, which takes a direction and a name as an argument. If the name is NULL, then a guaranteed unique name will be assigned to it. gst_pad_get_parent will retrieve the Element that owns the pad. A Element creating a pad will typically use the various gst_pad_set_*_function() calls to register callbacks for various events on the pads. GstElements will use push and pull_range to push out or pull in a buffer. To send a Event on a pad, use send_event and push_event. Last reviewed on 2006-07-06 (0.10.9)
• PadTemplate - 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). Pad and PadTemplates have Caps attached to it to describe the media type they are capable of dealing with. get_caps or GST_PAD_TEMPLATE_CAPS are used to get the caps of a padtemplate. It's not possible to modify the caps of a padtemplate after creation. PadTemplates have a PadPresence property which identifies the lifetime of the pad and that can be retrieved with GST_PAD_TEMPLATE_PRESENCE. Also the direction of the pad can be retrieved from the PadTemplate with GST_PAD_TEMPLATE_DIRECTION. The GST_PAD_TEMPLATE_NAME_TEMPLATE is important for GST_PAD_REQUEST pads because it has to be used as the name in the get_request_pad call to instantiate a pad from this template. Padtemplates can be created with PadTemplate or with get, which creates a PadTemplate from a StaticPadTemplate that can be filled with the convenient GST_STATIC_PAD_TEMPLATE macro. A padtemplate can be used to create a pad (see Pad.from_template or Pad.from_static_template) or to add to an element class (see add_pad_template). The following code example shows the code to create a pad from a padtemplate.
• ParamSpecFraction - A GParamSpec derived structure that contains the meta data for fractional properties.
• ParamSpecMiniObject - A ParamSpec derived structure that contains the meta data for MiniObject properties.
• ParseContext - Opaque structure.
• Pipeline - A Pipeline is a special Bin used as the toplevel container for the filter graph. The Pipeline will manage the selection and distribution of a global Clock as well as provide a Bus to the application. It will also implement a default behavour for managing seek events (see seek). Pipeline is used to create a pipeline. when you are done with the pipeline, use unref to free its resources including all added Element objects (if not otherwise referenced). Elements are added and removed from the pipeline using the Bin methods like add and remove (see Bin). Before changing the state of the Pipeline (see Element ) a Bus can be retrieved with get_bus . This bus can then be used to receive Message from the elements in the pipeline. By default, a Pipeline will automatically flush the pending Bus messages when going to the NULL state to ensure that no circular references exist when no messages are read from the Bus. This behaviour can be changed with set_auto_flush_bus. When the Pipeline performs the PAUSED to PLAYING state change it will select a clock for the elements. The clock selection algorithm will by default select a clock provided by an element that is most upstream (closest to the source). For live pipelines (ones that return NO_PREROLL from the set_state call) this will select the clock provided by the live source. For normal pipelines this will select a clock provided by the sinks (most likely the audio sink). If no element provides a clock, a default SystemClock is used. The clock selection can be controlled with the use_clock method, which will enforce a given clock on the pipeline. With auto_clock the default clock selection algorithm can be restored. A Pipeline maintains a running time for the elements. The running time is defined as the difference between the current clock time and the base time. When the pipeline goes to READY or a flushing seek is performed on it, the running time is reset to 0. When the pipeline is set from PLAYING to PAUSED, the current clock time is sampled and used to configure the base time for the elements when the pipeline is set to PLAYING again. The effect is that the running time (as the difference between the clock time and the base time) will count how much time was spent in the PLAYING state. This default behaviour can be changed with the set_start_time method. When sending a flushing seek event to a GstPipeline (see seek), it will make sure that the pipeline is properly PAUSED and resumed as well as set the new running time to 0 when the seek succeeded. Last reviewed on 2009-05-29 (0.10.24)
• Plugin -
• PluginFeature - This is a base class for anything that can be added to a Plugin.
• Poll - A Poll keeps track of file descriptors much like fd_set (used with select) or a struct pollfd array (used with poll). Once created with Poll, the set can be used to wait for file descriptors to be readable and/or writeable. It is possible to make this wait be controlled by specifying true for the controllable flag when creating the set (or later calling set_controllable). New file descriptors are added to the set using add_fd, and removed using remove_fd. Controlling which file descriptors should be waited for to become readable and/or writeable are done using ctl_read and ctl_write. Use wait to wait for the file descriptors to actually become readable and/or writeable, or to timeout if no file descriptor is available in time. The wait can be controlled by calling restart and set_flushing. Once the file descriptor set has been waited for, one can use has_closed to see if the file descriptor has been closed, has_error to see if it has generated an error, can_read to see if it is possible to read from the file descriptor, and can_write to see if it is possible to write to it.
• ProxyPad -
• Query - GstQuery functions are used to register new query types to the gstreamer core and use them. Queries can be performed on pads (gst_pad_query()) and elements (gst_element_query()). Please note that some queries might need a running pipeline to work. Queries can be created using the gst_query_new_*() functions. Query values can be set using gst_query_set_*(), and parsed using gst_query_parse_*() helpers. The following example shows how to query the duration of a pipeline:
• Registry - One registry holds the metadata of a set of plugins. Design: The Registry object is a list of plugins and some functions for dealing with them. Each Plugin is matched 1-1 with a file on disk, and may or may not be loaded at a given time. There may be multiple Registry objects, but the "default registry" is the only object that has any meaning to the core. The registry file is actually a cache of plugin information. This is unlike versions prior to 0.10, where the registry file was the primary source of plugin information, and was created by the gst-register command. The primary source, at all times, of plugin information is each plugin file itself. Thus, if an application wants information about a particular plugin, or wants to search for a feature that satisfies given criteria, the primary means of doing so is to load every plugin and look at the resulting information that is gathered in the default registry. Clearly, this is a time consuming process, so we cache information in the registry file. The format and location of the cache file is internal to gstreamer. On startup, plugins are searched for in the plugin search path. The following locations are checked in this order:
• Segment - This helper structure holds the relevant values for tracking the region of interest in a media file, called a segment. The structure can be used for two purposes:
• Structure - A Structure is a collection of key/value pairs. The keys are expressed as GQuarks and the values can be of any GType. In addition to the key/value pairs, a Structure also has a name. The name starts with a letter and can be folled by letters, numbers and any of "/-_.:". Structure is used by various GStreamer subsystems to store information in a flexible and extensible way. A Structure does not have a refcount because it usually is part of a higher level object such as Caps. It provides a means to enforce mutability using the refcount of the parent with the set_parent_refcount method. A Structure can be created with Structure.empty or Structure, which both take a name and an optional set of key/value pairs along with the types of the values. Field values can be changed with set_value or set. Field values can be retrieved with get_value or the more convenient gst_structure_get_*() functions. Fields can be removed with remove_field or remove_fields. Strings in structures must be ASCII or UTF-8 encoded. Other encodings are not allowed. Strings must not be empty either, but may be NULL. Last reviewed on 2009-06-08 (0.10.23)
• SystemClock - The GStreamer core provides a GstSystemClock based on the system time. Asynchronous callbacks are scheduled from an internal thread. Clock implementors are encouraged to subclass this systemclock as it implements the async notification. Subclasses can however override all of the important methods for sync and async notifications to implement their own callback methods or blocking wait operations. Last reviewed on 2006-03-08 (0.10.4)
• TagList - List of tags and values used to describe media metadata. Strings must be in ASCII or UTF-8 encoding. No other encodings are allowed. Last reviewed on 2009-06-09 (0.10.23)
• Task - Task is used by Element and Pad to provide the data passing threads in a Pipeline. A Pad will typically start a Task to push or pull data to/from the peer pads. Most source elements start a Task to push data. In some cases a demuxer element can start a Task to pull data from a peer element. This is typically done when the demuxer can perform random access on the upstream peer element for improved performance. Although convenience functions exist on Pad to start/pause/stop tasks, it might sometimes be needed to create a Task manually if it is not related to a Pad. Before the Task can be run, it needs a StaticRecMutex that can be set with set_lock. The task can be started, paused and stopped with start, pause and stop respectively or with the set_state function. A Task will repeatedly call the TaskFunction with the user data that was provided when creating the task with create. While calling the function it will acquire the provided lock. The provided lock is released when the task pauses or stops. Stopping a task with stop will not immediately make sure the task is not running anymore. Use join to make sure the task is completely stopped and the thread is stopped. After creating a Task, use unref to free its resources. This can only be done it the task is not running anymore. Task functions can send a Message to send out-of-band data to the application. The application can receive messages from the Bus in its mainloop. For debugging perposes, the task will configure its object name as the thread name on Linux. Please note that the object name should be configured before the task is started; changing the object name after the task has been started, has no effect on the thread name. Last reviewed on 2010-03-15 (0.10.29)
• TaskPool - The TaskPool object.
• TaskThreadCallbacks - Custom GstTask thread callback functions that can be installed.
• Trace - Traces allows to track object allocation. They provide a instance counter per Type. The counter is incremented for each object allocated and decremented it when it's freed.
• TraceEntry -
• TypeFind - The following functions allow you to detect the media type of an unknown stream. Last reviewed on 2005-11-09 (0.9.4)
• TypeFindFactory - These functions allow querying informations about registered typefind functions. How to create and register these functions is described in the section
  "Writing typefind functions".
• TypeNameData - Structure used for filtering based on name and type.
• ValueTable - VTable for the Value type.
• XML - GStreamer pipelines can be saved to xml files using write_file. They can be loaded back using parse_doc / parse_file / parse_memory. Additionally one can load saved pipelines into the gst-editor to inspect the graph. Element implementations need to override the Object.save_thyself() and Object .restore_thyself() virtual functions of Object. broken for all but the most simple pipelines. It will most likely be removed in future. Don't use it.

Structs:

• Array -
• ClockTime - A datatype to hold a time, measured in nanoseconds.
• ClockTimeDiff - A datatype to hold a time difference, measured in nanoseconds.
• DoubleRange -
• ElementDetails - This struct defines the public information about a Element. It contains meta-data about the element that is mostly for the benefit of editors. The klass member can be used by applications to filter elements based on functionality.
• FormatDefinition - A format definition
• Fraction -
• FractionRange -
• IndexAssociation - An association in an entry.
• IntRange -
• List -
• PluginDesc - 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. BSD, MIT/X11, Proprietary, unknown.
• PollFD - A file descriptor object.
• QueryTypeDefinition - A Query Type definition
• StaticCaps - Datastructure to initialize Caps from a string description usually used in conjunction with GST_STATIC_CAPS and get to instantiate a Caps.
• StaticPadTemplate - Structure describing the StaticPadTemplate.
• Value -

Enums:

• ActivateMode - The status of a GstPad. After activating a pad, which usually happens when the parent element goes from READY to PAUSED, the GstActivateMode defines if the pad operates in push or pull mode.
• AllocTraceFlags - Flags indicating which tracing feature to enable.
• AssocFlags - Flags for an association entry.
• BinFlags - GstBinFlags are a set of flags specific to bins. Most are set/used internally. They can be checked using the flag_is_set macro, and (un)set using flag_set and flag_unset.
• BufferCopyFlags - A set of flags that can be provided to the copy_metadata function to specify which metadata fields should be copied.
• BufferFlag - A set of buffer flags used to describe properties of a Buffer.
• BufferListItem - The result of the BufferListFunc.
• BufferingMode - The different types of buffering methods.
• BusFlags - The standard flags that a bus may have.
• BusSyncReply - The result values for a GstBusSyncHandler.
• CapsFlags - Extra flags for a caps.
• CapsIntersectMode - Modes of caps intersection by iterating on the caps' structures as the following matrix shows:
• ClockEntryType - The type of the clock entry
• ClockFlags - The capabilities of this clock
• ClockReturn - The return value of a clock operation.
• ClockType - The different kind of clocks.
• DebugColorFlags - These are some terminal style flags you can use when creating your debugging categories to make them stand out in debugging output.
• DebugGraphDetails - Available details for pipeline graphs produced by debug_bin_to_dot_file and debug_bin_to_dot_file_with_ts.
• DebugLevel - 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.
• ElementFlags - The standard flags that an element may have.
• EventType - EventType lists the standard event types that can be sent in a pipeline. The custom event types can be used for private messages between elements that can't be expressed using normal GStreamer buffer passing semantics. Custom events carry an arbitrary Structure. Specific custom events are distinguished by the name of the structure.
• EventTypeFlags - EventTypeFlags indicate the aspects of the different EventType values. You can get the type flags of a EventType with the get_flags function.
• FlowReturn - sent yet) (unused/unimplemented). this error should post an error message with more details. this (and higher) to define custom success codes. Since 0.10.7. custom success code to this to avoid compiler warnings). Since 0.10.29. this (and lower) to define custom error codes. Since 0.10.7. custom error code to this to avoid compiler warnings). Since 0.10.29. The result of passing data to a pad. Note that the custom return values should not be exposed outside of the element scope and are available since 0.10.7.
• Format - Standard predefined formats
• IndexCertainty - The certainty of a group in the index.
• IndexEntryType - The different types of entries in the index.
• IndexFlags - Flags for this index
• IndexLookupMethod - Specify the method to find an index entry in the index.
• IndexResolverMethod - The method used to resolve index writers
• IteratorItem - The result of a IteratorItemFunction.
• IteratorResult - The result of next.
• LibraryError - Library errors are for errors from the library being used by elements (initializing, finalizing, settings, ...)
• MessageType - The different message types that are available.
• MiniObjectFlags - Flags for the mini object
• ObjectFlags - The standard flags that an gstobject may have.
• PadDirection - The direction of a pad.
• PadFlags - Pad state flags
• PadLinkCheck - 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.
• PadLinkReturn - Result values from gst_pad_link and friends.
• PadPresence - Indicates when this pad will become available.
• PadTemplateFlags - Flags for the padtemplate
• ParseError - The different parsing errors that can occur.
• ParseFlags - Parsing options.
• PipelineFlags - Pipeline flags
• PluginDependencyFlags - Flags used in connection with add_dependency.
• PluginError - The plugin loading errors
• PluginFlags - The plugin loading state
• ProgressType - The type of a PROGRESS. The progress messages inform the application of the status of assynchronous tasks.
• QOSType - The different types of QoS events that can be given to the Event.qos_full method.
• QueryType - Standard predefined Query types
• Rank - Element priority ranks. Defines the order in which the autoplugger (or similar rank-picking mechanisms, such as e.g. make_from_uri) will choose this element over an alternative one with the same function. These constants serve as a rough guidance for defining the rank of a PluginFeature. Any value is valid, including values bigger than
• ResourceError - 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.
• SearchMode - The different search modes.
• SeekFlags - Flags to be used with seek or Event.seek. All flags can be used together. A non flushing seek might take some time to perform as the currently playing data in the pipeline will not be cleared. An accurate seek might be slower for formats that don't have any indexes or timestamp markers in the stream. Specifying this flag might require a complete scan of the file in those cases. no EOS will be emmited by the element that performed the seek, but a SEGMENT_DONE message will be posted on the bus by the element. When this message is posted, it is possible to send a new seek event to continue playback. With this seek method it is possible to perform seemless looping or simple linear editing. When doing fast forward (rate > 1.0) or fast reverse (rate < -1.0) trickmode playback, the GST_SEEK_FLAG_SKIP flag can be used to instruct decoders and demuxers to adjust the playback rate by skipping frames. This can improve performance and decrease CPU usage because not all frames need to be decoded. Also see part-seeking.txt in the GStreamer design documentation for more details on the meaning of these flags and the behaviour expected of elements that handle them.
• SeekType - The different types of seek events. When constructing a seek event with Event.seek, a format, a seek method and optional flags are to be provided. The seek event is then inserted into the graph with send_event or send_event.
• State - The possible states an element can be in. States can be changed using set_state and checked using get_state.
• StateChange - These are the different state changes an element goes through. NULL &rArr; PLAYING is called an upwards state change and PLAYING &rArr; NULL a downwards state change.
• StateChangeReturn - The possible return values from a state change function. Only
• StreamError - Stream errors are for anything related to the stream being processed: format errors, media type errors, ... They're typically used by decoders, demuxers, converters, ...
• StreamStatusType - The type of a STREAM_STATUS. The stream status messages inform the application of new streaming threads and their status.
• StructureChangeType - The type of a STRUCTURE_CHANGE.
• TagFlag - Extra tag flags used when registering tags.
• TagMergeMode -
• TaskState - The different states a task can be in
• TypeFindProbability - The probability of the typefind function. Higher values have more certainty in doing a reliable typefind.
• URIType - The different types of URI direction.

Error domains:

• CoreError - Core errors are errors inside the core GStreamer library.

Constants:

• public const int BUFFER_COPY_ALL
• public const int BUFFER_OFFSET_NONE
• public const unowned string BUFFER_TRACE_NAME
• public const unowned string CLOCK_ENTRY_TRACE_NAME
• public const int CLOCK_TIME_NONE
• public const int DEBUG_BG_MASK
• public const int DEBUG_FG_MASK
• public const int DEBUG_FORMAT_MASK
• public const unowned string ELEMENT_FACTORY_KLASS_DECODER
• public const unowned string ELEMENT_FACTORY_KLASS_DEMUXER
• public const unowned string ELEMENT_FACTORY_KLASS_DEPAYLOADER
• public const unowned string ELEMENT_FACTORY_KLASS_ENCODER
• public const unowned string ELEMENT_FACTORY_KLASS_FORMATTER
• public const unowned string ELEMENT_FACTORY_KLASS_MEDIA_AUDIO
• public const unowned string ELEMENT_FACTORY_KLASS_MEDIA_IMAGE
• public const unowned string ELEMENT_FACTORY_KLASS_MEDIA_METADATA
• public const unowned string ELEMENT_FACTORY_KLASS_MEDIA_SUBTITLE
• public const unowned string ELEMENT_FACTORY_KLASS_MEDIA_VIDEO
• public const unowned string ELEMENT_FACTORY_KLASS_MUXER
• public const unowned string ELEMENT_FACTORY_KLASS_PARSER
• public const unowned string ELEMENT_FACTORY_KLASS_PAYLOADER
• public const unowned string ELEMENT_FACTORY_KLASS_SINK
• public const unowned string ELEMENT_FACTORY_KLASS_SRC
• public const int ELEMENT_FACTORY_TYPE_ANY
• public const int ELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS
• public const int ELEMENT_FACTORY_TYPE_AUDIO_ENCODER
• public const int ELEMENT_FACTORY_TYPE_DECODABLE
• public const int ELEMENT_FACTORY_TYPE_DECODER
• public const int ELEMENT_FACTORY_TYPE_DEMUXER
• public const int ELEMENT_FACTORY_TYPE_DEPAYLOADER
• public const int ELEMENT_FACTORY_TYPE_ENCODER
• public const int ELEMENT_FACTORY_TYPE_FORMATTER
• public const int ELEMENT_FACTORY_TYPE_MAX_ELEMENTS
• public const int ELEMENT_FACTORY_TYPE_MEDIA_ANY
• public const int ELEMENT_FACTORY_TYPE_MEDIA_AUDIO
• public const int ELEMENT_FACTORY_TYPE_MEDIA_IMAGE
• public const int ELEMENT_FACTORY_TYPE_MEDIA_METADATA
• public const int ELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE
• public const int ELEMENT_FACTORY_TYPE_MEDIA_VIDEO
• public const int ELEMENT_FACTORY_TYPE_MUXER
• public const int ELEMENT_FACTORY_TYPE_PARSER
• public const int ELEMENT_FACTORY_TYPE_PAYLOADER
• public const int ELEMENT_FACTORY_TYPE_SINK
• public const int ELEMENT_FACTORY_TYPE_SRC
• public const int ELEMENT_FACTORY_TYPE_VIDEO_ENCODER
• public const unowned string EVENT_TRACE_NAME
• public const int EVENT_TYPE_BOTH
• public const int EVENT_TYPE_SHIFT
• public const unowned string FOURCC_FORMAT
• public const unowned string LICENSE_UNKNOWN
• public const unowned string MESSAGE_TRACE_NAME
• public const int MSECOND
• public const int NSECOND
• public const int PAD_LINK_CHECK_DEFAULT
• public const int PARAM_CONTROLLABLE
• public const int PARAM_MUTABLE_PAUSED
• public const int PARAM_MUTABLE_PLAYING
• public const int PARAM_MUTABLE_READY
• public const int PARAM_USER_SHIFT
• public const int SECOND
• public const unowned string TAG_ALBUM
• public const unowned string TAG_ALBUM_ARTIST
• public const unowned string TAG_ALBUM_ARTIST_SORTNAME
• public const unowned string TAG_ALBUM_GAIN
• public const unowned string TAG_ALBUM_PEAK
• public const unowned string TAG_ALBUM_SORTNAME
• public const unowned string TAG_ALBUM_VOLUME_COUNT
• public const unowned string TAG_ALBUM_VOLUME_NUMBER
• public const unowned string TAG_APPLICATION_DATA
• public const unowned string TAG_APPLICATION_NAME
• public const unowned string TAG_ARTIST
• public const unowned string TAG_ARTIST_SORTNAME
• public const unowned string TAG_ATTACHMENT
• public const unowned string TAG_AUDIO_CODEC
• public const unowned string TAG_BEATS_PER_MINUTE
• public const unowned string TAG_BITRATE
• public const unowned string TAG_CODEC
• public const unowned string TAG_COMMENT
• public const unowned string TAG_COMPOSER
• public const unowned string TAG_COMPOSER_SORTNAME
• public const unowned string TAG_CONTACT
• public const unowned string TAG_CONTAINER_FORMAT
• public const unowned string TAG_COPYRIGHT
• public const unowned string TAG_COPYRIGHT_URI
• public const unowned string TAG_DATE
• public const unowned string TAG_DATE_TIME
• public const unowned string TAG_DESCRIPTION
• public const unowned string TAG_DEVICE_MANUFACTURER
• public const unowned string TAG_DEVICE_MODEL
• public const unowned string TAG_DURATION
• public const unowned string TAG_ENCODED_BY
• public const unowned string TAG_ENCODER
• public const unowned string TAG_ENCODER_VERSION
• public const unowned string TAG_EXTENDED_COMMENT
• public const unowned string TAG_GENRE
• public const unowned string TAG_GEO_LOCATION_CAPTURE_DIRECTION
• public const unowned string TAG_GEO_LOCATION_CITY
• public const unowned string TAG_GEO_LOCATION_COUNTRY
• public const unowned string TAG_GEO_LOCATION_ELEVATION
• public const unowned string TAG_GEO_LOCATION_HORIZONTAL_ERROR
• public const unowned string TAG_GEO_LOCATION_LATITUDE
• public const unowned string TAG_GEO_LOCATION_LONGITUDE
• public const unowned string TAG_GEO_LOCATION_MOVEMENT_DIRECTION
• public const unowned string TAG_GEO_LOCATION_MOVEMENT_SPEED
• public const unowned string TAG_GEO_LOCATION_NAME
• public const unowned string TAG_GEO_LOCATION_SUBLOCATION
• public const unowned string TAG_GROUPING
• public const unowned string TAG_HOMEPAGE
• public const unowned string TAG_IMAGE
• public const unowned string TAG_IMAGE_ORIENTATION
• public const unowned string TAG_ISRC
• public const unowned string TAG_KEYWORDS
• public const unowned string TAG_LANGUAGE_CODE
• public const unowned string TAG_LICENSE
• public const unowned string TAG_LICENSE_URI
• public const unowned string TAG_LOCATION
• public const unowned string TAG_LYRICS
• public const unowned string TAG_MAXIMUM_BITRATE
• public const unowned string TAG_MINIMUM_BITRATE
• public const unowned string TAG_NOMINAL_BITRATE
• public const unowned string TAG_ORGANIZATION
• public const unowned string TAG_PERFORMER
• public const unowned string TAG_PREVIEW_IMAGE
• public const unowned string TAG_REFERENCE_LEVEL
• public const unowned string TAG_SERIAL
• public const unowned string TAG_SHOW_EPISODE_NUMBER
• public const unowned string TAG_SHOW_NAME
• public const unowned string TAG_SHOW_SEASON_NUMBER
• public const unowned string TAG_SHOW_SORTNAME
• public const unowned string TAG_SUBTITLE_CODEC
• public const unowned string TAG_TITLE
• public const unowned string TAG_TITLE_SORTNAME
• public const unowned string TAG_TRACK_COUNT
• public const unowned string TAG_TRACK_GAIN
• public const unowned string TAG_TRACK_NUMBER
• public const unowned string TAG_TRACK_PEAK
• public const unowned string TAG_USER_RATING
• public const unowned string TAG_VERSION
• public const unowned string TAG_VIDEO_CODEC
• public const unowned string TIME_FORMAT
• public const int USECOND
• public const int VALUE_EQUAL
• public const int VALUE_GREATER_THAN
• public const int VALUE_LESS_THAN
• public const int VALUE_UNORDERED
• public const int VERSION_MAJOR
• public const int VERSION_MICRO
• public const int VERSION_MINOR
• public const int VERSION_NANO

Delegates:

• public delegate weak Buffer BufferListDoFunction (Buffer buffer)
• public delegate BufferListItem BufferListFunc (out Buffer buffer, uint group, uint idx)
• public delegate bool BufferProbeCallback (Pad pad, Buffer buffer)
• public delegate bool BusFunc (Bus bus, Message message)
• public delegate BusSyncReply BusSyncHandler (Bus bus, Message message)
• public delegate bool ClockCallback (Clock clock, ClockTime time, ClockID id)
• public delegate void* CopyFunction (void* object)
• public delegate bool DataProbeCallback (Pad pad, MiniObject data)
• public delegate void DebugFuncPtr ()
• public delegate bool EventProbeCallback (Pad pad, Event event)
• public delegate bool FilterFunc (void* obj)
• public delegate bool IndexFilter (Index index, IndexEntry entry)
• public delegate bool IndexResolver (Index index, Object writer, string writer_string)
• public delegate void IteratorDisposeFunction (void* owner)
• public delegate bool IteratorFoldFunction<T> (T item, ref Value ret)
• public delegate void IteratorFreeFunction (Iterator it)
• public delegate IteratorItem IteratorItemFunction<T> (Iterator it, out T item)
• public delegate IteratorResult IteratorNextFunction<T> (Iterator it, out T result)
• public delegate void IteratorResyncFunction (Iterator it)
• public delegate void LogFunction (DebugCategory category, DebugLevel level, string file, string function, int line, Object object, DebugMessage message)
• public delegate weak MiniObject MiniObjectCopyFunction (MiniObject obj)
• public delegate void MiniObjectFinalizeFunction (MiniObject obj)
• public delegate void MiniObjectWeakNotify (void* data, MiniObject where_the_mini_object_was)
• public delegate bool PadAcceptCapsFunction (Pad pad, Caps caps)
• public delegate bool PadActivateFunction (Pad pad)
• public delegate bool PadActivateModeFunction (Pad pad, bool active)
• public delegate void PadBlockCallback (Pad pad, bool blocked)
• public delegate FlowReturn PadBufferAllocFunction (Pad pad, uint64 offset, uint size, Caps caps, out Buffer buf)
• public delegate FlowReturn PadChainFunction (Pad pad, owned Buffer buffer)
• public delegate FlowReturn PadChainListFunction (Pad pad, owned BufferList list)
• public delegate bool PadCheckGetRangeFunction (Pad pad)
• public delegate bool PadDispatcherFunction (Pad pad)
• public delegate bool PadEventFunction (Pad pad, owned Event event)
• public delegate void PadFixateCapsFunction (Pad pad, Caps caps)
• public delegate Caps PadGetCapsFunction (Pad pad)
• public delegate FlowReturn PadGetRangeFunction (Pad pad, uint64 offset, uint length, out Buffer buffer)
• public delegate List<Pad> PadIntLinkFunction (Pad pad)
• public delegate Iterator<Pad> PadIterIntLinkFunction (Pad pad)
• public delegate PadLinkReturn PadLinkFunction (Pad pad, Pad peer)
• public delegate bool PadQueryFunction (Pad pad, Query query)
• public delegate QueryType PadQueryTypeFunction (Pad pad)
• public delegate bool PadSetCapsFunction (Pad pad, Caps caps)
• public delegate void PadUnlinkFunction (Pad pad)
• public delegate bool PluginFeatureFilter (PluginFeature feature)
• public delegate bool PluginFilter (Plugin plugin)
• public delegate bool PluginInitFullFunc (Plugin plugin)
• public delegate bool PluginInitFunc (Plugin plugin)
• public delegate bool StructureForeachFunc (Quark field_id, Value value)
• public delegate bool StructureMapFunc (Quark field_id, ref Value value)
• public delegate void TagForeachFunc (TagList list, string tag)
• public delegate void TagMergeFunc (Value dest, Value src)
• public delegate void TaskFunction ()
• public delegate void TaskPoolFunction ()
• public delegate void TypeFindFunction (TypeFind find)
• public delegate int ValueCompareFunc (Value value1, Value value2)
• public delegate bool ValueDeserializeFunc (Value dest, string s)
• public delegate bool ValueIntersectFunc (Value dest, Value value1, Value value2)
• public delegate unowned string ValueSerializeFunc (Value value1)
• public delegate bool ValueSubtractFunc (Value dest, Value minuend, Value subtrahend)
• public delegate bool ValueUnionFunc (Value dest, Value value1, Value value2)

Methods:

• public void atomic_int_set (int atomic_int, int value)
  Unconditionally sets the atomic integer to value.
• public Quark core_error_quark ()
• public void debug_add_log_function (LogFunction func, void* data)
  Adds the logging function to the list of logging functions. Be sure to use G_GNUC_NO_INSTRUMENT on that function, it is needed.
• public void debug_bin_to_dot_file (Bin bin, DebugGraphDetails details, string prefix)
• public void debug_bin_to_dot_file_with_ts (Bin bin, DebugGraphDetails details, string prefix)
• public unowned string debug_construct_term_color (uint colorinfo)
  Constructs a string that can be used for getting the desired color in color terminals. You need to free the string after use. definition
• public int debug_construct_win_color (uint colorinfo)
  Constructs an integer that can be used for getting the desired color in windows' terminals (cmd.exe). As there is no mean to underline, we simply ignore this attribute. This function returns 0 on non-windows machines.
• public SList<DebugCategory> debug_get_all_categories ()
  Returns a snapshot of a all categories that are currently in use . This list may change anytime. The caller has to free the list after use. debug categories
• public DebugLevel debug_get_default_threshold ()
  Returns the default threshold that is used for new categories.
• public bool debug_is_active ()
  Checks if debugging output is activated.
• public bool debug_is_colored ()
  Checks if the debugging output should be colored.
• public void debug_log (DebugCategory category, DebugLevel level, string file, string function, int line, Object object, string format)
  Logs the given message using the currently registered debugging handlers.
• public void debug_log_default (DebugCategory category, DebugLevel level, string file, string function, int line, Object object, DebugMessage message, void* unused)
  The default logging handler used by GStreamer. Logging functions get called whenever a macro like GST_DEBUG or similar is used. This function outputs the message and additional info to stderr (or the log file specified via the GST_DEBUG_FILE environment variable). You can add other handlers by using debug_add_log_function. And you can remove this handler by calling gst_debug_remove_log_function(gst_debug_log_default);
• public void debug_log_valist (DebugCategory category, DebugLevel level, string file, string function, int line, Object object, string format, void* args)
  Logs the given message using the currently registered debugging handlers.
• public void debug_print_stack_trace ()
  If GST_ENABLE_FUNC_INSTRUMENTATION is defined a stacktrace is available for gstreamer code, which can be printed with this function.
• public uint debug_remove_log_function (LogFunction func)
  Removes all registered instances of the given logging functions.
• public uint debug_remove_log_function_by_data (void* data)
  Removes all registered instances of log functions with the given user data.
• public void debug_set_active (bool active)
  If activated, debugging messages are sent to the debugging handlers. It makes sense to deactivate it for speed issues.
• public void debug_set_colored (bool colored)
  Sets or unsets the use of coloured debugging output. This function may be called before init.
• public void debug_set_default_threshold (DebugLevel level)
  Sets the default threshold to the given level and updates all categories to use this threshold. This function may be called before init.
• public void debug_set_threshold_for_name (string name, DebugLevel level)
  Sets all categories which match the given glob style pattern to the given level.
• public void debug_unset_threshold_for_name (string name)
  Resets all categories with the given name back to the default level.
• public bool default_registry_check_feature_version (string feature_name, uint min_major, uint min_minor, uint min_micro)
  Checks whether a plugin feature by the given name exists in the default registry and whether its version is at least the version required. the same as the required version or newer, and false otherwise.
• public void deinit ()
  Clean up any resources created by GStreamer in init. It is normally not needed to call this function in a normal application as the resources will automatically be freed when the program terminates. This function is therefore mostly used by testsuites and other memory profiling tools. After this call GStreamer (including this method) should not be used anymore.
• public Type double_range_get_type ()
• public string error_get_message (Quark domain, int code)
  Get a string describing the error message in the current locale. the error message (in UTF-8 encoding)
• public unowned string filename_to_uri (string filename) throws Error
  Similar to to_uri, but attempts to handle relative file paths as well. Before converting filename into an URI, it will be prefixed by the current working directory if it is a relative path, and then the path will be canonicalised so that it doesn't contain any './' or '../' segments. On Windows filename should be in UTF-8 encoding.
• public List filter_run (List list, FilterFunc func, bool first)
  Iterates over the elements in list, calling func with the list item data for each item. If func returns TRUE, data is prepended to the list of results returned. If first is true, the search is halted after the first result is found. Since filter_run knows nothing about the type of data, no reference will be taken (if data refers to an object) and no copy of results. when no longer needed (the data contained in the list is a flat copy and does need to be unreferenced or freed).
• public Quark flow_to_quark (FlowReturn ret)
  Get the unique quark for the given GstFlowReturn. invalid return was specified.
• public Format format_get_by_nick (string nick)
  Return the format registered with the given nick. if the format was not registered.
• public FormatDefinition format_get_details (Format format)
• public Iterator<FormatDefinition> format_iterate_definitions ()
  Iterate all the registered formats. The format definition is read only.
• public Format format_register (string nick, string description)
  Create a new GstFormat based on the nick or return an already registered format with that nick. with the same nick. MT safe.
• public Quark format_to_quark (Format format)
• public bool formats_contains (Format formats, Format format)
  See if the given format is inside the format array.
• public Type fourcc_get_type ()
• public Type fraction_get_type ()
• public Type fraction_range_get_type ()
• public void init (ref string[] argv)
  Initializes the GStreamer library, setting up internal path lists, registering built-in elements, and loading standard plugins. Unless the plugin registry is disabled at compile time, the registry will be loaded. By default this will also check if the registry cache needs to be updated and rescan all plugins if needed. See update_registry for details and section Running GStreamer Applications for how to disable automatic registry updates. This function should be called before calling any other GLib functions. If this is not an option, your program must initialise the GLib thread system using g_thread_init before any other GLib functions are called.
• public bool init_check (ref string[] argv) throws Error
  Initializes the GStreamer library, setting up internal path lists, registering built-in elements, and loading standard plugins. This function will return false if GStreamer could not be initialized for some reason. If you want your program to fail fatally, use init instead. This function should be called before calling any other GLib functions. If this is not an option, your program must initialise the GLib thread system using g_thread_init before any other GLib functions are called.
• public OptionGroup init_get_option_group ()
  Returns a OptionGroup with GStreamer's argument specifications. The group is set up to use standard GOption callbacks, so when using this group in combination with GOption parsing methods, all argument parsing and initialization is automated. This function is useful if you want to integrate GStreamer with other libraries that use GOption (see add_group ). If you use this function, you should make sure you initialise the GLib threading system as one of the very first things in your program (see the example at the beginning of this section).
• public Type int64_range_get_type ()
• public Type int_range_get_type ()
• public bool is_initialized ()
  Use this function to check if GStreamer has been initialized with init or init_check.
• public bool is_tag_list (void* p)
  Checks if the given pointer is a taglist.
• public Quark library_error_quark ()
• public void marshal_BOOLEAN__POINTER (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_BOOLEAN__VOID (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_BOXED__BOXED (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_POINTER__POINTER (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__BOXED_OBJECT (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__INT64 (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__INT_INT (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__OBJECT_BOXED (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__OBJECT_BOXED_STRING (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__OBJECT_OBJECT (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__OBJECT_OBJECT_STRING (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__OBJECT_PARAM (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__OBJECT_POINTER (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__OBJECT_STRING (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__POINTER_OBJECT (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public void marshal_VOID__UINT_BOXED (Closure closure, Value return_value, uint n_param_values, Value param_values, void* invocation_hint, void* marshal_data)
• public weak ParamSpec param_spec_fraction (string name, string nick, string blurb, int min_num, int min_denom, int max_num, int max_denom, int default_num, int default_denom, ParamFlags flags)
  This function creates a fraction GParamSpec for use by objects/elements that want to expose properties of fraction type. This function is typically used in connection with install_property in a GObjects's instance_init function.
• public weak ParamSpec param_spec_mini_object (string name, string nick, string blurb, Type object_type, ParamFlags flags)
  Creates a new ParamSpec instance that hold MiniObject references.
• public Element? parse_bin_from_description (string bin_description, bool ghost_unlinked_pads) throws Error
  This is a convenience wrapper around parse_launch to create a Bin from a gst-launch-style pipeline description. See parse_launch and the gst-launch man page for details about the syntax. Ghost pads on the bin for unlinked source or sink pads within the bin can automatically be created (but only a maximum of one ghost pad for each direction will be created; if you expect multiple unlinked source pads or multiple unlinked sink pads and want them all ghosted, you will have to create the ghost pads yourself).
• public Element? parse_bin_from_description_full (string bin_description, bool ghost_unlinked_pads, ParseContext? context, ParseFlags flags) throws Error
  This is a convenience wrapper around parse_launch to create a Bin from a gst-launch-style pipeline description. See parse_launch and the gst-launch man page for details about the syntax. Ghost pads on the bin for unlinked source or sink pads within the bin can automatically be created (but only a maximum of one ghost pad for each direction will be created; if you expect multiple unlinked source pads or multiple unlinked sink pads and want them all ghosted, you will have to create the ghost pads yourself).
• public Quark parse_error_quark ()
  Get the error quark used by the parsing subsystem.
• public Element? parse_launch (string pipeline_description) throws Error
  Create a new pipeline based on command line syntax. Please note that you might get a return value that is not null even though the error is set. In this case there was a recoverable parsing error and you can try to play the pipeline. more than one toplevel element is specified by the pipeline_description, all elements are put into a Pipeline, which than is returned.
• public Element? parse_launch_full (string pipeline_description, ParseContext? context, ParseFlags flags) throws Error
  Create a new pipeline based on command line syntax. Please note that you might get a return value that is not null even though the error is set. In this case there was a recoverable parsing error and you can try to play the pipeline. more than one toplevel element is specified by the pipeline_description, all elements are put into a Pipeline, which then is returned.
• public Element? parse_launchv (string[] argv) throws Error
  Create a new element based on command line syntax. An error does not mean that the pipeline could not be constructed.
• public Element? parse_launchv_full (string[] argv, ParseContext? context, ParseFlags flags) throws Error
  Create a new element based on command line syntax. An error does not mean that the pipeline could not be constructed. or a partially-constructed bin or element will be returned and error will be set (unless you passed FATAL_ERRORS in flags, then null will always be returned on failure)
• public void print_element_args (StringBuilder buf, int indent, Element element)
  Print the element argument in a human readable format in the given GString.
• public void print_pad_caps (StringBuilder buf, int indent, Pad pad)
  Write the pad capabilities in a human readable format into the given GString.
• public Quark resource_error_quark ()
• public bool segtrap_is_enabled ()
  Some functions in the GStreamer core might install a custom SIGSEGV handler to better catch and report errors to the application. Currently this feature is enabled by default when loading plugins. Applications might want to disable this behaviour with the segtrap_set_enabled function. This is typically done if the application wants to install its own handler without GStreamer interfering.
• public void segtrap_set_enabled (bool enabled)
  Applications might want to disable/enable the SIGSEGV handling of the GStreamer core. See segtrap_is_enabled for more information.
• public Quark stream_error_quark ()
• public bool tag_exists (string tag)
  Checks if the given type is already registered.
• public unowned string tag_get_description (string tag)
  Returns the human-readable description of this tag, You must not change or free this string.
• public TagFlag tag_get_flag (string tag)
  Gets the flag of tag.
• public unowned string tag_get_nick (string tag)
  Returns the human-readable name of this tag, You must not change or free this string.
• public Type tag_get_type (string tag)
  Gets the Type used for this tag.
• public bool tag_is_fixed (string tag)
  Checks if the given tag is fixed. A fixed tag can only contain one value. Unfixed tags can contain lists of values.
• public void tag_merge_strings_with_comma (Value dest, Value src)
  This is a convenience function for the func argument of tag_register. It concatenates all given strings using a comma. The tag must be registered as a G_TYPE_STRING or this function will fail.
• public void tag_merge_use_first (Value dest, Value src)
  This is a convenience function for the func argument of tag_register. It creates a copy of the first value from the list.
• public void tag_register (string name, TagFlag flag, Type type, string nick, string blurb, TagMergeFunc func)
  Registers a new tag type for the use with GStreamer's type system. If a type with that name is already registered, that one is used. The old registration may have used a different type however. So don't rely on your supplied values. that there can only be one single value for this tag in a tag list and any additional values will silenty be discarded when being added (unless REPLACE, REPLACE_ALL, or PREPEND is used as merge mode, in which case the new value will replace the old one in the list). The merge function will be called from copy_value when it is required that one or more values for a tag be condensed into one single value. This may happen from get_string, get_int, get_double etc. What will happen exactly in that case depends on how the tag was registered and if a merge function was supplied and if so which one. tag_merge_strings_with_comma.
• public bool update_registry ()
  Forces GStreamer to re-scan its plugin paths and update the default plugin registry. Applications will almost never need to call this function, it is only useful if the application knows new plugins have been installed (or old ones removed) since the start of the application (or, to be precise, the first call to init) and the application wants to make use of any newly-installed plugins without restarting the application. Applications should assume that the registry update is neither atomic nor thread-safe and should therefore not have any dynamic pipelines running (including the playbin and decodebin elements) and should also not create any elements or access the GStreamer registry while the update is in progress. Note that this function may block for a significant amount of time. imply that there were changes), otherwise false .
• public unowned string uri_construct (string protocol, string location)
  Constructs a URI for a given valid protocol and location. URI. Returns NULL if the given URI protocol is not valid, or the given location is NULL.
• public unowned string uri_get_location (string uri)
  Extracts the location out of a given valid URI, ie. the protocol and "://" are stripped from the URI, which means that the location returned includes the hostname if one is specified. The returned string must be freed using g_free. URI. Returns NULL if the URI isn't valid. If the URI does not contain a location, an empty string is returned.
• public unowned string uri_get_protocol (string uri)
  Extracts the protocol out of a given valid URI. The returned string must be freed using g_free.
• public bool uri_has_protocol (string uri, string protocol)
  Checks if the protocol of a given valid URI matches protocol.
• public bool uri_is_valid (string uri)
  Tests if the given string is a valid URI identifier. URIs start with a valid scheme followed by ":" and maybe a string identifying the location.
• public bool uri_protocol_is_supported (URIType type, string protocol)
  Checks if an element exists that supports the given URI protocol. Note that a positive return value does not imply that a subsequent call to make_from_uri is guaranteed to work.
• public bool uri_protocol_is_valid (string protocol)
  Tests if the given string is a valid protocol identifier. Protocols must consist of alphanumeric characters, '+', '-' and '.' and must start with a alphabetic character. See RFC 3986 Section 3.1.
• public void* util_array_binary_search (void* array, uint num_elements, size_t element_size, CompareDataFunc search_func, SearchMode mode, void* search_data)
  Searches inside array for search_data by using the comparison function As search_data is always passed as second argument to search_func it's not required that search_data has the same type as the array elements. The complexity of this search function is O(log (num_elements)).
• public void util_double_to_fraction (double src, int dest_n, int dest_d)
  Transforms a double to a fraction and simplifies the result.
• public void util_dump_mem (uchar[] mem, uint size)
  Dumps the memory block into a hex representation. Useful for debugging.
• public bool util_fraction_add (int a_n, int a_d, int b_n, int b_d, int res_n, int res_d)
  Adds the fractions a_n/@a_d and b_n/@b_d and stores the result in res_n and res_d.
• public int util_fraction_compare (int a_n, int a_d, int b_n, int b_d)
  Compares the fractions a_n/@a_d and b_n/@b_d and returns -1 if a < b, 0 if a = b and 1 if a > b.
• public bool util_fraction_multiply (int a_n, int a_d, int b_n, int b_d, int res_n, int res_d)
  Multiplies the fractions a_n/@a_d and b_n/@b_d and stores the result in res_n and res_d.
• public void util_fraction_to_double (int src_n, int src_d, double dest)
  Transforms a fraction to a double.
• public uint64 util_gdouble_to_guint64 (double value)
• public ClockTime util_get_timestamp ()
  Get a timestamp as GstClockTime to be used for interval meassurements. The timestamp should not be interpreted in any other way.
• public int util_greatest_common_divisor (int a, int b)
  Calculates the greatest common divisor of a and b.
• public double util_guint64_to_gdouble (uint64 value)
• public int32 util_seqnum_compare (uint32 s1, uint32 s2)
  Compare two sequence numbers, handling wraparound. The current implementation just returns (gint32)(@s1 - s2). positive number if s1 is after s2.
• public uint32 util_seqnum_next ()
  Return a constantly incrementing sequence number. This function is used internally to GStreamer to be able to determine which events and messages are "the same". For example, elements may set the seqnum on a segment-done message to be the same as that of the last seek event, to indicate that event and the message correspond to the same segment. overflow back to 0 at some point. Use util_seqnum_compare to make sure you handle wraparound correctly.
• public void util_set_object_arg (Object object, string name, string value)
  Convertes the string value to the type of the objects argument and sets the argument with it. Note that this function silently returns if object has no property named
• public void util_set_value_from_string (Value value, string value_str)
  Converts the string to the type of the value and sets the value with it. Note that this function is dangerous as it does not return any indication if the conversion worked or not.
• public uint64 util_uint64_scale (uint64 val, uint64 num, uint64 denom)
  Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. This function can potentially be very slow if val and num are both greater than G_MAXUINT32. function returns G_MAXUINT64. If the result is not exactly representable as an integer it is truncated. See also util_uint64_scale_round, util_uint64_scale_ceil, util_uint64_scale_int, util_uint64_scale_int_round, util_uint64_scale_int_ceil.
• public uint64 util_uint64_scale_ceil (uint64 val, uint64 num, uint64 denom)
  Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. This function can potentially be very slow if val and num are both greater than G_MAXUINT32. function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded up. See also util_uint64_scale, util_uint64_scale_round, util_uint64_scale_int, util_uint64_scale_int_round, util_uint64_scale_int_ceil.
• public uint64 util_uint64_scale_int (uint64 val, int num, int denom)
  Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. num must be non-negative and function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is truncated. See also util_uint64_scale_int_round, util_uint64_scale_int_ceil, util_uint64_scale, util_uint64_scale_round, util_uint64_scale_ceil.
• public uint64 util_uint64_scale_int_ceil (uint64 val, int num, int denom)
  Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. num must be non-negative and function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded up. See also util_uint64_scale_int, util_uint64_scale_int_round, util_uint64_scale, util_uint64_scale_round, util_uint64_scale_ceil.
• public uint64 util_uint64_scale_int_round (uint64 val, int num, int denom)
  Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. num must be non-negative and function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded to the nearest integer (half-way cases are rounded up). See also util_uint64_scale_int, util_uint64_scale_int_ceil, util_uint64_scale, util_uint64_scale_round, util_uint64_scale_ceil.
• public uint64 util_uint64_scale_round (uint64 val, uint64 num, uint64 denom)
  Scale val by the rational number num / denom, avoiding overflows and underflows and without loss of precision. This function can potentially be very slow if val and num are both greater than G_MAXUINT32. function returns G_MAXUINT64. If the result is not exactly representable as an integer, it is rounded to the nearest integer (half-way cases are rounded up). See also util_uint64_scale, util_uint64_scale_ceil, util_uint64_scale_int, util_uint64_scale_int_round, util_uint64_scale_int_ceil.
• public weak MiniObject value_dup_mini_object (Value value)
  Get the contents of a typeof (MiniObject) derived Value, increasing its reference count. If the contents of the Value are null, null will be returned.
• public int64 value_get_int64_range_max (Value value)
  Gets the maximum of the range specified by value.
• public int64 value_get_int64_range_min (Value value)
  Gets the minimum of the range specified by value.
• public void value_list_merge (Value dest, Value value1, Value value2)
  Merges copies of value1 and value2. Values that are not of type GST_TYPE_LIST are treated as if they were lists of length 1. The result will be put into dest and will either be a list that will not contain any duplicates, or a non-list type (if value1 and value2 were equal).
• public void value_set_int64_range (Value value, int64 start, int64 end)
  Sets value to the range specified by start and end.
• public void version (out uint major, out uint minor, out uint micro, out uint nano)
  Gets the version number of the GStreamer library.
• public string version_string ()
  This function returns a string that is useful for describing this version of GStreamer.