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 ⇒ %GST_STATE_PLAYING is called an upwards state change
and %GST_STATE_PLAYING ⇒ %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