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. The opaque #GstAdapter data structure. The main tracing object Flags indicating which tracing feature to enable. Flags for an association entry. The opaque #GstBaseSink data structure. Subclasses can override any of the available virtual methods or not, as needed. At the minimum, the @render method should be overridden to output/present buffers. The opaque #GstBaseSrc data structure. Subclasses can override any of the available virtual methods or not, as needed. At the minimum, the @create method should be overridden to produce buffers. The #GstElement flags that a basesrc element may have. The opaque #GstBaseTransform data structure. Subclasses can override any of the available virtual methods or not, as needed. At minimum either @transform or @transform_ip need to be overridden. If the element can overwrite the input data with the results (data is of the same type and quantity) it should provide @transform_ip. The GstBin base class. Subclasses can access these fields provided the LOCK is taken. 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 #gst_element_post_message. 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 bit reader instance. The structure of a #GstBuffer. Use the associated macros to access the public variables. A set of flags that can be provided to the gst_buffer_copy_metadata() function to specify which metadata fields should be copied. A set of buffer flags used to describe properties of a #GstBuffer. A function for accessing the last buffer returned by gst_buffer_list_iterator_next(). The function can leave @buffer in the list, replace @buffer in the list or remove @buffer from the list, depending on the return value. If the function returns NULL, @buffer will be removed from the list, otherwise @buffer will be replaced with the returned buffer. The last buffer returned by gst_buffer_list_iterator_next() will be replaced with the buffer returned from the function. The function takes ownership of unreffed. If NULL is returned, the buffer will be removed from the list. The list must be writable. from the list the buffer to replace @buffer in the list, or NULL to remove @buffer the #GstBuffer user data A function that will be called from gst_buffer_list_foreach(). The @buffer field will point to a the reference of the buffer at @idx in @group. When this function returns #GST_BUFFER_LIST_CONTINUE, the next buffer will be returned. When #GST_BUFFER_LIST_SKIP_GROUP is returned, all remaining buffers in the current group will be skipped and the first buffer of the next group is returned (if any). When GST_BUFFER_LIST_END is returned, gst_buffer_list_foreach() will return. When @buffer is set to NULL, the item will be removed from the bufferlist. When @buffer has been made writable, the new buffer reference can be assigned to @buffer. This function is responsible for unreffing the old buffer when removing or modifying. a #GstBufferListItem pointer the buffer the group index of @buffer the index in @group of @buffer user data passed to gst_buffer_list_foreach() The result of the #GstBufferListFunc. The different types of buffering methods. The opaque #GstBus data structure. The standard flags that a bus may have. Specifies the type of function passed to gst_bus_add_watch() or gst_bus_add_watch_full(), which is called from the mainloop when a message is available on the bus. The message passed to the function will be unreffed after execution of this function so it should not be freed in the function. Note that this function is used as a GSourceFunc which means that returning FALSE will remove the GSource from the mainloop. %FALSE if the event source should be removed. the #GstBus that sent the message the #GstMessage user data that has been given, when registering the handler Handler will be invoked synchronously, when a new message has been injected into the bus. This function is mostly used internally. Only one sync handler can be attached to a given bus. If the handler returns GST_BUS_DROP, it should unref the message, else the message should not be unreffed by the sync handler. #GstBusSyncReply stating what to do with the message the #GstBus that sent the message the #GstMessage user data that has been given, when registering the handler The result values for a GstBusSyncHandler. A byte reader instance. A byte writer instance. Object describing media types. Extra flags for a caps. Opaque #GstChildProxy data structure. #GstChildProxy interface. #GstClock base structure. The values of this structure are protected for subclasses, use the methods to use the #GstClock. The function prototype of the callback. %TRUE or %FALSE (currently unused) The clock that triggered the callback The time it was triggered The #GstClockID that expired user data passed in the gst_clock_id_wait_async() function 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. The type of the clock entry The capabilities of this clock The return value of a clock operation. The different kind of clocks. Structure used by the collect_pads. A function that will be called when the #GstCollectData will be freed. It is passed the pointer to the structure and should free any custom memory and resources allocated for it. the #GstCollectData that will be freed Collectpads object. Note that @data doesn't contain the complete #GstCollectData list at all times and should not be used for iterating them. A function that will be called when @buffer is received on the pad managed by @data in the collecpad object @pads. The function should use the segment of @data and the negotiated media type on the pad to perform clipping of @buffer. This function takes ownership of @buffer. the buffer has been clipped completely. a #GstBuffer that contains the clipped data of @buffer or NULL when a #GstCollectPads a #GstCollectData a #GstBuffer user data A function that will be called when all pads have received data. #GST_FLOW_OK for success the #GstCollectPads that triggered the callback user data passed to gst_collect_pads_set_function() A function to create a copy of some object or increase its reference count. a copy of the object or the same object with increased reference count The object to copy Core errors are errors inside the core GStreamer library. Opaque #GstDataQueue structure. The prototype of the function used to inform the queue that it should be considered as full. #TRUE if the queue should be considered full. a #GstDataQueue. The number of visible items currently in the queue. The amount of bytes currently in the queue. The accumulated duration of the items currently in the queue. The #gpointer registered when the #GstDataQueue was created. Structure used by #GstDataQueue. You can supply a different structure, as long as the top of the structure is identical to this structure. Structure describing the size of a queue. This is the struct that describes the categories. Once initialized with #GST_DEBUG_CATEGORY_INIT, its values can't be changed anymore. 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. GStreamer element abstract base class. (inout) (out) (inout) (out) GStreamer element class. Override the vmethods to implement the element functionality. This struct defines the public information about a #GstElement. 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. The opaque #GstElementFactory data structure. The standard flags that an element may have. A #GstEvent. #GstEventType 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 #GstStructure. Specific custom events are distinguished by the name of the structure. #GstEventTypeFlags indicate the aspects of the different #GstEventType values. You can get the type flags of a #GstEventType with the gst_event_type_get_flags() function. Function prototype for a filter callback taht can be use in gst_filter_run(). The function should apply its filtering to @obj. Additional data passed to gst_filter_run() are in @data. %TRUE for success. the object filter data 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. Standard predefined formats A format definition Opaque #GstGhostPad structure. Opaque #GstImplementsInterface structure. Opaque #GstIndex structure. An association in an entry. The certainty of a group in the index. The basic element of an index. The different types of entries in the index. The GstIndexFactory object Function to filter out entries in the index. to the index, %FALSE otherwise. This function should return %TRUE if the entry is to be added The index being queried The entry to be added. User data passed to the function. Flags for this index A group of related entries in an index. Specify the method to find an index entry in the index. Function to resolve ids to writer descriptions. %TRUE if an id could be assigned to the writer. the index being queried. The object that wants to write A description of the writer. user_data as registered The method used to resolve index writers #GstIterator base structure. The values of this structure are protected for subclasses, use the methods to use the #GstIterator. The function that will be called when a #GList iterator is freed. The owner of the #GList iterator can then clean up its resources. the owner of the iterator A function to be passed to gst_iterator_fold(). TRUE if the fold should continue, FALSE if it should stop. the item to fold a #GValue collecting the result data passed to gst_iterator_fold() This function will be called when the iterator is freed. Implementors of a #GstIterator should implement this function and pass it to the constructor of the custom iterator. The function will be called with the iterator lock held. the iterator The result of a #GstIteratorItemFunction. The function that will be called after the next item of the iterator has been retrieved. This function will typically increase the refcount of the item or make a copy. Implementors of a #GstIterator should implement this function and pass it to the constructor of the custom iterator. The function will be called with the iterator lock held. the result of the operation. the iterator the item being retrieved. The function that will be called when the next element of the iterator should be retrieved. Implementors of a #GstIterator should implement this function and pass it to the constructor of the custom iterator. The function will be called with the iterator lock held. the result of the operation. the iterator a pointer to hold the next item The result of gst_iterator_next(). This function will be called whenever a concurrent update happened to the iterated datastructure. The implementor of the iterator should restart the iterator from the beginning and clean up any state it might have. Implementors of a #GstIterator should implement this function and pass it to the constructor of the custom iterator. The function will be called with the iterator lock held. the iterator Library errors are for errors from the library being used by elements (initializing, finalizing, settings, ...) Function prototype for a logging function that can be registered with gst_debug_add_log_function(). Use G_GNUC_NO_INSTRUMENT on that function. a #GstDebugCategory a #GstDebugLevel file name function name line number a #GObject the message user data for the log function A #GstMessage. The different message types that are available. Base class for refcounted lightweight objects. Virtual function prototype for methods to create copies of instances. reference to cloned instance. MiniObject to copy Virtual function prototype for methods to free ressources used by mini-objects. Subclasses of the mini object are allowed to revive the passed object by doing a gst_mini_object_ref(). If the object is not revived after the finalize function, the memory associated with the object is freed. MiniObject to finalize Flags for the padtemplate GStreamer base object class. GStreamer base object class. The standard flags that an gstobject may have. The #GstPad structure. Use the functions to update the variables. Check if @pad can accept @caps. By default this function will see if @caps intersect with the result from gst_pad_get_caps() by can be overridden to perform extra checks. TRUE if the caps can be accepted by the pad. the #GstPad to check the #GstCaps to check This function is called when the pad is activated during the element READY to PAUSED state change. By default this function will call the activate function that puts the pad in push mode but elements can override this function to activate the pad in pull mode if they wish. TRUE if the pad could be activated. a #GstPad The prototype of the push and pull activate functions. TRUE if the pad could be activated or deactivated. a #GstPad activate or deactivate the pad. Callback used by gst_pad_set_blocked_async(). Gets called when the blocking operation succeeds. the #GstPad that is blockend or unblocked. blocking state for the pad the gpointer to optional user data. Ask the sinkpad @pad to allocate a buffer with @offset, @size and @caps. The result will be stored in @buf. The purpose of this function is to allocate a buffer that is optimal to be processed by @pad. The function is mostly overridden by elements that can provide a hardware buffer in order to avoid additional memcpy operations. The function can return a buffer that has caps different from the requested new caps. If a format change was requested, the returned buffer will be one to hold the data of said new caps, so its size might be different from the requested When this function returns anything else than #GST_FLOW_OK, the buffer allocation failed and @buf does not contain valid data. If the function returns #GST_FLOW_OK and the @buf is NULL, a #GstBuffer will be created with @caps, @offset and @size. By default this function returns a new buffer of @size and with @caps containing purely malloced data. The buffer should be freed with gst_buffer_unref() after usage. value means @buf does not hold a valid buffer. #GST_FLOW_OK if @buf contains a valid buffer, any other return a sink #GstPad the desired offset of the buffer the desired size of the buffer the desired caps of the buffer pointer to hold the allocated buffer. A function that will be called on sinkpads when chaining buffers. The function typically processes the data contained in the buffer and either consumes the data or passes it on to the internally linked pad(s). The implementer of this function receives a refcount to @buffer and should gst_buffer_unref() when the buffer is no longer needed. When a chain function detects an error in the data stream, it must post an error on the bus and return an appropriate #GstFlowReturn value. #GST_FLOW_OK for success the sink #GstPad that performed the chain. the #GstBuffer that is chained, not %NULL. A function that will be called on sinkpads when chaining buffer lists. The function typically processes the data contained in the buffer list and either consumes the data or passes it on to the internally linked pad(s). The implementer of this function receives a refcount to @list and should gst_buffer_list_unref() when the list is no longer needed. When a chainlist function detects an error in the data stream, it must post an error on the bus and return an appropriate #GstFlowReturn value. #GST_FLOW_OK for success the sink #GstPad that performed the chain. the #GstBufferList that is chained, not %NULL. Check if @pad can be activated in pull mode. This function will be deprecated after 0.10; use the seeking query to check if a pad can support random access. TRUE if the pad can operate in pull mode. a #GstPad The direction of a pad. A dispatcher function is called for all internally linked pads, see gst_pad_dispatcher(). TRUE if the dispatching procedure has to be stopped. the #GstPad that is dispatched. the gpointer to optional user data. Function signature to handle an event for the pad. TRUE if the pad could handle the event. the #GstPad to handle the event. the #GstEvent to handle. Given possibly unfixed caps @caps, let @pad use its default prefered format to make a fixed caps. @caps should be writable. By default this function will pick the first value of any ranges or lists in the caps but elements can override this function to perform other behaviour. a #GstPad the #GstCaps to fixate Pad state flags Returns a copy of the capabilities of the specified pad. By default this function will return the pad template capabilities, but can optionally be overridden by elements. a newly allocated copy #GstCaps of the pad. the #GstPad to get the capabilities of. This function will be called on source pads when a peer element request a buffer at the specified @offset and @length. If this function returns #GST_FLOW_OK, the result buffer will be stored in @buffer. The contents of @buffer is invalid for any other return value. This function is installed on a source pad with gst_pad_set_getrange_function() and can only be called on source pads after they are successfully activated with gst_pad_activate_pull(). between 0 and the length in bytes of the data available on @pad. The length (duration in bytes) can be retrieved with a #GST_QUERY_DURATION or with a #GST_QUERY_SEEKING. Any @offset larger or equal than the length will make the function return #GST_FLOW_UNEXPECTED, which corresponds to EOS. In this case @buffer does not contain a valid buffer. The buffer size of @buffer will only be smaller than @length when @offset is near the end of the stream. In all other cases, the size of @buffer must be exactly the requested size. It is allowed to call this function with a 0 @length and valid @offset, in which case @buffer will contain a 0-sized buffer and the function returns #GST_FLOW_OK. When this function is called with a -1 @offset, the sequentially next buffer of length @length in the stream is returned. When this function is called with a -1 @length, a buffer with a default optimal length is returned in @buffer. The length might depend on the value of @offset. return value leaves @buffer undefined. #GST_FLOW_OK for success and a valid buffer in @buffer. Any other the src #GstPad to perform the getrange on. the offset of the range the length of the range a memory location to hold the result buffer, cannot be NULL. The signature of the internal pad link function. returns The #GstPad to query. The signature of the internal pad link iterator function. linked to the given pad on the inside of the parent element. the caller must call gst_iterator_free() after usage. Since 0.10.21 a new #GstIterator that will iterate over all pads that are The #GstPad to query. 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. <warning><para> Only disable some of the checks if you are 100% certain you know the link will not fail because of hierarchy/caps compatibility failures. If uncertain, use the default checks (%GST_PAD_LINK_CHECK_DEFAULT) or the regular methods for linking the pads. </para></warning> Result values from gst_pad_link and friends. Indicates when this pad will become available. The signature of the query function. TRUE if the query could be performed. the #GstPad to query. the #GstQuery object to execute The signature of the query types function. a constant array of query types a #GstPad to query Set @caps on @pad. By default this function updates the caps of the pad but the function can be overriden by elements to perform extra actions or verifications. TRUE if the caps could be set on the pad. the #GstPad to set the capabilities of. the #GstCaps to set The padtemplate object. Flags for the padtemplate A GParamSpec derived structure that contains the meta data for fractional properties. A %GParamSpec derived structure that contains the meta data for %GstMiniObject properties. Opaque structure. The different parsing errors that can occur. Parsing options. The #GstPipeline structure. Pipeline flags The plugin object Flags used in connection with gst_plugin_add_dependency(). 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. The plugin loading errors Opaque #GstPluginFeature structure. A function that can be used with e.g. gst_registry_feature_filter() to get a list of pluginfeature that match certain criteria. %TRUE for a positive match, %FALSE otherwise the pluginfeature to check the user_data that has been passed on e.g. gst_registry_feature_filter() A function that can be used with e.g. gst_registry_plugin_filter() to get a list of plugins that match certain criteria. TRUE for a positive match, FALSE otherwise the plugin to check the user_data that has been passed on e.g. gst_registry_plugin_filter() The plugin loading state A plugin should provide a pointer to a function of either #GstPluginInitFunc or this type in the plugin_desc struct. The function will be called by the loader at startup. One would then register each #GstPluginFeature. This version allows user data to be passed to init function (useful for bindings). %TRUE if plugin initialised successfully The plugin object extra data A plugin should provide a pointer to a function of this type in the plugin_desc struct. This function will be called by the loader at startup. One would then register each #GstPluginFeature. %TRUE if plugin initialised successfully The plugin object A set of file/network descriptors. A file descriptor object. The opaque #GstPushSrc data structure. The #GstQuery structure. Standard predefined Query types A Query Type definition Element priority ranks. Defines the order in which the autoplugger (or similar rank-picking mechanisms, such as e.g. gst_element_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 #GstPluginFeature. Any value is valid, including values bigger than Opaque #GstRegistry structure. 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 search modes. Flags to be used with gst_element_seek() or gst_event_new_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 #GST_MESSAGE_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. The different types of seek events. When constructing a seek event with gst_event_new_seek(), a format, a seek method and optional flags are to be provided. The seek event is then inserted into the graph with gst_pad_send_event() or gst_element_send_event(). A helper structure that holds the configured region of interest in a media file. The possible states an element can be in. States can be changed using gst_element_set_state() and checked using gst_element_get_state(). These are the different state changes an element goes through. %GST_STATE_NULL &rArr; %GST_STATE_PLAYING is called an upwards state change and %GST_STATE_PLAYING &rArr; %GST_STATE_NULL a downwards state change. The possible return values from a state change function. Only Datastructure to initialize #GstCaps from a string description usually used in conjunction with GST_STATIC_CAPS() and gst_static_caps_get() to instantiate a #GstCaps. 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_MESSAGE_STREAM_STATUS. The stream status messages inform the application of new streaming threads and their status. The GstStructure object. Most fields are private. The type of a %GST_MESSAGE_STRUCTURE_CHANGE. A function that will be called in gst_structure_foreach(). The function may not modify @value. the foreach operation should stop with FALSE. TRUE if the foreach operation should continue, FALSE if the #GQuark of the field name the #GValue of the field user data A function that will be called in gst_structure_map_in_place(). The function may modify @value. the map operation should stop with FALSE. TRUE if the map operation should continue, FALSE if the #GQuark of the field name the #GValue of the field user data The default implementation of a #GstClock that uses the system time. Extra tag flags used when registering tags. A function that will be called in gst_tag_list_foreach(). The function may not modify the tag list. the #GstTagList a name of a tag in @list user data A function for merging multiple values of a tag used when registering tags. the destination #GValue the source #GValue The different tag merging modes are basically replace, overwrite and append, already in the element and (B) the ones that are supplied to the element ( e.g. via gst_tag_setter_merge_tags() / gst_tag_setter_add_tags() or a %GST_EVENT_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. <table frame="all" colsep="1" rowsep="1"> <title>merge mode</title> <tgroup cols='5' align='left'> <thead> <row> <entry>merge mode</entry> <entry>A + B</entry> <entry>A + !B</entry> <entry>!A + B</entry> <entry>!A + !B</entry> </row> </thead> <tbody> <row> <entry>REPLACE_ALL</entry> <entry>B</entry> <entry>-</entry> <entry>B</entry> <entry>-</entry> </row> <row> <entry>REPLACE</entry> <entry>B</entry> <entry>A</entry> <entry>B</entry> <entry>-</entry> </row> <row> <entry>APPEND</entry> <entry>A, B</entry> <entry>A</entry> <entry>B</entry> <entry>-</entry> </row> <row> <entry>PREPEND</entry> <entry>B, A</entry> <entry>A</entry> <entry>B</entry> <entry>-</entry> </row> <row> <entry>KEEP</entry> <entry>A</entry> <entry>A</entry> <entry>B</entry> <entry>-</entry> </row> <row> <entry>KEEP_ALL</entry> <entry>A</entry> <entry>A</entry> <entry>-</entry> <entry>-</entry> </row> </tbody> </tgroup> </table> Opaque #GstTagSetter data structure. #GstTagSetterIFace interface. The #GstTask object. A function that will repeatedly be called in the thread created by a #GstTask. user data passed to the function The #GstTaskPool object. The #GstTaskPoolClass object. Task function, see gst_task_pool_push(). user data for the task function The different states a task can be in Custom GstTask thread callback functions that can be installed. Opaque #GstTrace structure. Object that stores typefind callbacks. To use with #GstTypeFindFactory. Object that stores information about a typefind function. A function that will be called by typefinding. A #GstTypeFind structure optionnal data to pass to the function This function will be called by gst_type_find_helper_get_range() when typefinding functions request to peek at the data of a stream at certain offsets. If this function returns GST_FLOW_OK, the result buffer will be stored in @buffer. The contents of @buffer is invalid for any other return value. This function is supposed to behave exactly like a #GstPadGetRangeFunction. GST_FLOW_OK for success a #GstObject that will handle the getrange request the offset of the range the length of the range a memory location to hold the result buffer The probability of the typefind function. Higher values have more certainty in doing a reliable typefind. Structure used for filtering based on @name and @type. Opaque #GstURIHandler structure. Any #GstElement using this interface should implement these methods. The different types of URI direction. Used together with gst_value_compare() to compare #GValue items. or GST_VALUE_UNORDERED one of GST_VALUE_LESS_THAN, GST_VALUE_EQUAL, GST_VALUE_GREATER_THAN first value for comparison second value for comparison Used by gst_value_deserialize() to parse a non-binary form into the #GValue. %TRUE for success a #GValue a string Used by gst_value_intersect() to perform intersection for a specific #GValue type. If the intersection is non-empty, the result is placed in @dest and TRUE is returned. If the intersection is empty, @dest is unmodified and FALSE is returned. Register a new implementation with gst_value_register_intersect_func(). %TRUE if the values can intersect a #GValue for the result a #GValue operand a #GValue operand Used by gst_value_serialize() to obtain a non-binary form of the #GValue. the string representation of the value a #GValue Used by gst_value_subtract() to perform subtraction for a specific #GValue type. Register a new implementation with gst_value_register_subtract_func(). %TRUE if the subtraction is not empty a #GValue for the result a #GValue operand a #GValue operand VTable for the #GValue @type. Used by gst_value_union() to perform unification for a specific #GValue type. Register a new implementation with gst_value_register_union_func(). %TRUE if a union was successful a #GValue for the result a #GValue operand a #GValue operand XML parser object argument count arguments