* }
* ]|
*
- * For another example, a simple element inside GStreamer that uses GstAdapter
+ * For another example, a simple element inside GStreamer that uses #GstAdapter
* is the libvisual element.
*
- * An element using GstAdapter in its sink pad chain function should ensure that
+ * An element using #GstAdapter in its sink pad chain function should ensure that
* when the FLUSH_STOP event is received, that any queued data is cleared using
* gst_adapter_clear(). Data should also be cleared or processed on EOS and
- * when changing state from #GST_STATE_PAUSED to #GST_STATE_READY.
+ * when changing state from %GST_STATE_PAUSED to %GST_STATE_READY.
*
* Also check the GST_BUFFER_FLAG_DISCONT flag on the buffer. Some elements might
* need to clear the adapter after a discontinuity.
* gst_adapter_prev_pts_at_offset() can be used to determine the last
* seen timestamp at a particular offset in the adapter.
*
- * A last thing to note is that while GstAdapter is pretty optimized,
+ * A last thing to note is that while #GstAdapter is pretty optimized,
* merging buffers still might be an operation that requires a malloc() and
* memcpy() operation, and these operations are not the fastest. Because of
* this, some functions like gst_adapter_available_fast() are provided to help
* gst_adapter_copy() can be used to copy data into a (statically allocated)
* user provided buffer.
*
- * GstAdapter is not MT safe. All operations on an adapter must be serialized by
+ * #GstAdapter is not MT safe. All operations on an adapter must be serialized by
* the caller. This is not normally a problem, however, as the normal use case
- * of GstAdapter is inside one pad's chain function, in which case access is
+ * of #GstAdapter is inside one pad's chain function, in which case access is
* serialized via the pad's STREAM_LOCK.
*
* Note that gst_adapter_push() takes ownership of the buffer passed. Use
/* Internal method only. Tries to merge buffers at the head of the queue
* to form a single larger buffer of size 'size'.
*
- * Returns TRUE if it managed to merge anything.
+ * Returns %TRUE if it managed to merge anything.
*/
static gboolean
gst_adapter_try_to_merge_up (GstAdapter * adapter, gsize size)
* as #GstBuffer memory or the potentially more performant
* gst_adapter_take_buffer().
*
- * Returns #NULL if @size bytes are not available.
+ * Returns %NULL if @size bytes are not available.
*
* Returns: (transfer none) (array length=size) (element-type guint8):
- * a pointer to the first @size bytes of data, or NULL
+ * a pointer to the first @size bytes of data, or %NULL
*/
gconstpointer
gst_adapter_map (GstAdapter * adapter, gsize size)
* @size: the number of bytes to copy
*
* Copies @size bytes of data starting at @offset out of the buffers
- * contained in @GstAdapter into an array @dest provided by the caller.
+ * contained in #GstAdapter into an array @dest provided by the caller.
*
* The array @dest should be large enough to contain @size bytes.
* The user should check that the adapter has (@offset + @size) bytes
* Free-function: g_free
*
* Returns: (transfer full) (array length=nbytes) (element-type guint8):
- * oven-fresh hot data, or #NULL if @nbytes bytes are not available
+ * oven-fresh hot data, or %NULL if @nbytes bytes are not available
*/
gpointer
gst_adapter_take (GstAdapter * adapter, gsize nbytes)
* Free-function: gst_buffer_unref
*
* Returns: (transfer full): a #GstBuffer containing the first @nbytes of
- * the adapter, or #NULL if @nbytes bytes are not available.
+ * the adapter, or %NULL if @nbytes bytes are not available.
* gst_buffer_unref() when no longer needed.
*
* Since: 1.2
* Free-function: gst_buffer_unref
*
* Returns: (transfer full): a #GstBuffer containing the first @nbytes of
- * the adapter, or #NULL if @nbytes bytes are not available.
+ * the adapter, or %NULL if @nbytes bytes are not available.
* gst_buffer_unref() when no longer needed.
*/
GstBuffer *
* buffer in the list before freeing the list after usage.
*
* Returns: (element-type Gst.Buffer) (transfer full): a #GList of buffers
- * containing the first @nbytes of the adapter, or #NULL if @nbytes bytes
+ * containing the first @nbytes of the adapter, or %NULL if @nbytes bytes
* are not available
*/
GList *
*
* Gets the maximum amount of bytes available, that is it returns the maximum
* value that can be supplied to gst_adapter_map() without that function
- * returning NULL.
+ * returning %NULL.
*
* Returns: number of bytes available in @adapter
*/
/**
* gst_adapter_prev_pts:
* @adapter: a #GstAdapter
- * @distance: (out) (allow-none): pointer to location for distance, or NULL
+ * @distance: (out) (allow-none): pointer to location for distance, or %NULL
*
* Get the pts that was before the current byte in the adapter. When
* @distance is given, the amount of bytes between the pts and the current
/**
* gst_adapter_prev_dts:
* @adapter: a #GstAdapter
- * @distance: (out) (allow-none): pointer to location for distance, or NULL
+ * @distance: (out) (allow-none): pointer to location for distance, or %NULL
*
* Get the dts that was before the current byte in the adapter. When
* @distance is given, the amount of bytes between the dts and the current
* gst_adapter_prev_pts_at_offset:
* @adapter: a #GstAdapter
* @offset: the offset in the adapter at which to get timestamp
- * @distance: (out) (allow-none): pointer to location for distance, or NULL
+ * @distance: (out) (allow-none): pointer to location for distance, or %NULL
*
* Get the pts that was before the byte at offset @offset in the adapter. When
* @distance is given, the amount of bytes between the pts and the current
* gst_adapter_prev_dts_at_offset:
* @adapter: a #GstAdapter
* @offset: the offset in the adapter at which to get timestamp
- * @distance: (out) (allow-none): pointer to location for distance, or NULL
+ * @distance: (out) (allow-none): pointer to location for distance, or %NULL
*
* Get the dts that was before the byte at offset @offset in the adapter. When
* @distance is given, the amount of bytes between the dts and the current
* It is an error to call this function without making sure that there is
* enough data (offset+size bytes) in the adapter.
*
- * This function calls gst_adapter_masked_scan_uint32_peek() passing NULL
+ * This function calls gst_adapter_masked_scan_uint32_peek() passing %NULL
* for value.
*
* Returns: offset of the first match, or -1 if no match was found.
* <listitem>
* <itemizedlist><title>Set-up phase</title>
* <listitem><para>
- * GstBaseParse calls @start to inform subclass that data processing is
+ * #GstBaseParse calls @start to inform subclass that data processing is
* about to start now.
* </para></listitem>
* <listitem><para>
- * GstBaseParse class calls @set_sink_caps to inform the subclass about
+ * #GstBaseParse class calls @set_sink_caps to inform the subclass about
* incoming sinkpad caps. Subclass could already set the srcpad caps
* accordingly, but this might be delayed until calling
* gst_base_parse_finish_frame() with a non-queued frame.
* </para></listitem>
* <listitem><para>
- * At least at this point subclass needs to tell the GstBaseParse class
+ * At least at this point subclass needs to tell the #GstBaseParse class
* how big data chunks it wants to receive (min_frame_size). It can do
* this with gst_base_parse_set_min_frame_size().
* </para></listitem>
* <listitem><para>
- * GstBaseParse class sets up appropriate data passing mode (pull/push)
+ * #GstBaseParse class sets up appropriate data passing mode (pull/push)
* and starts to process the data.
* </para></listitem>
* </itemizedlist>
* <itemizedlist>
* <title>Parsing phase</title>
* <listitem><para>
- * GstBaseParse gathers at least min_frame_size bytes of data either
+ * #GstBaseParse gathers at least min_frame_size bytes of data either
* by pulling it from upstream or collecting buffers in an internal
* #GstAdapter.
* </para></listitem>
* </para><para>
* Subclass is also responsible for setting the buffer metadata
* (e.g. buffer timestamp and duration, or keyframe if applicable).
- * (although the latter can also be done by GstBaseParse if it is
+ * (although the latter can also be done by #GstBaseParse if it is
* appropriately configured, see below). Frame is provided with
* timestamp derived from upstream (as much as generally possible),
* duration obtained from configuration (see below), and offset
* events, or to perform custom (segment) filtering.
* </para></listitem>
* <listitem><para>
- * During the parsing process GstBaseParseClass will handle both srcpad
+ * During the parsing process #GstBaseParseClass will handle both srcpad
* and sinkpad events. They will be passed to subclass if @event or
* @src_event callbacks have been provided.
* </para></listitem>
* <listitem>
* <itemizedlist><title>Shutdown phase</title>
* <listitem><para>
- * GstBaseParse class calls @stop to inform the subclass that data
+ * #GstBaseParse class calls @stop to inform the subclass that data
* parsing will be stopped.
* </para></listitem>
* </itemizedlist>
* needs to set the fixed caps on srcpad, when the format is ensured (e.g.
* when base class calls subclass' @set_sink_caps function).
*
- * This base class uses #GST_FORMAT_DEFAULT as a meaning of frames. So,
+ * This base class uses %GST_FORMAT_DEFAULT as a meaning of frames. So,
* subclass conversion routine needs to know that conversion from
- * #GST_FORMAT_TIME to #GST_FORMAT_DEFAULT must return the
+ * %GST_FORMAT_TIME to %GST_FORMAT_DEFAULT must return the
* frame number that can be found from the given byte position.
*
- * GstBaseParse uses subclasses conversion methods also for seeking (or
+ * #GstBaseParse uses subclasses conversion methods also for seeking (or
* otherwise uses its own default one, see also below).
*
* Subclass @start and @stop functions will be called to inform the beginning
* <listitem><para>
* In particular, if subclass is unable to determine a duration, but
* parsing (or specs) yields a frames per seconds rate, then this can be
- * provided to GstBaseParse to enable it to cater for
+ * provided to #GstBaseParse to enable it to cater for
* buffer time metadata (which will be taken from upstream as much as
* possible). Internally keeping track of frame durations and respective
- * sizes that have been pushed provides GstBaseParse with an estimated
+ * sizes that have been pushed provides #GstBaseParse with an estimated
* bitrate. A default @convert (used if not overridden) will then use these
* rates to perform obvious conversions. These rates are also used to
* update (estimated) duration at regular frame intervals.
/**
* GstBaseParse:disable-passthrough:
*
- * If set to #TRUE, baseparse will unconditionally force parsing of the
+ * If set to %TRUE, baseparse will unconditionally force parsing of the
* incoming data. This can be required in the rare cases where the incoming
* side-data (caps, pts, dts, ...) is not trusted by the user and wants to
* force validation and parsing of the incoming data.
- * If set to #FALSE, decision of whether to parse the data or not is up to
+ * If set to %FALSE, decision of whether to parse the data or not is up to
* the implementation (standard behaviour).
*/
g_object_class_install_property (gobject_class, PROP_DISABLE_PASSTHROUGH,
*
* Converts using configured "convert" vmethod in #GstBaseParse class.
*
- * Returns: TRUE if conversion was successful.
+ * Returns: %TRUE if conversion was successful.
*/
static gboolean
gst_base_parse_convert (GstBaseParse * parse,
*
* Handler for sink pad events.
*
- * Returns: TRUE if the event was handled.
+ * Returns: %TRUE if the event was handled.
*/
static gboolean
gst_base_parse_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
*
* Handler for source pad events.
*
- * Returns: TRUE if the event was handled.
+ * Returns: %TRUE if the event was handled.
*/
static gboolean
gst_base_parse_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
*
* Default srcpad event handler.
*
- * Returns: TRUE if the event was handled and can be dropped.
+ * Returns: %TRUE if the event was handled and can be dropped.
*/
static gboolean
gst_base_parse_src_event_default (GstBaseParse * parse, GstEvent * event)
*
* Default implementation of "convert" vmethod in #GstBaseParse class.
*
- * Returns: TRUE if conversion was successful.
+ * Returns: %TRUE if conversion was successful.
*/
gboolean
gst_base_parse_convert_default (GstBaseParse * parse,
*
* This function should only be called from a @handle_frame implementation.
*
- * GstBaseParse creates initial timestamps for frames by using the last
+ * #GstBaseParse creates initial timestamps for frames by using the last
* timestamp seen in the stream before the frame starts. In certain
* cases, the correct timestamps will occur in the stream after the
* start of the frame, but before the start of the actual picture data.
* GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
*
* // sinktemplate should be a #GstStaticPadTemplate with direction
- * // #GST_PAD_SINK and name "sink"
+ * // %GST_PAD_SINK and name "sink"
* gst_element_class_add_pad_template (gstelement_class,
* gst_static_pad_template_get (&sinktemplate));
*
* ]|
*
* #GstBaseSink will handle the prerolling correctly. This means that it will
- * return #GST_STATE_CHANGE_ASYNC from a state change to PAUSED until the first
+ * return %GST_STATE_CHANGE_ASYNC from a state change to PAUSED until the first
* buffer arrives in this element. The base class will call the
* #GstBaseSinkClass.preroll() vmethod with this preroll buffer and will then
* commit the state change to the next asynchronously pending state.
*
* When the element is set to PLAYING, #GstBaseSink will synchronise on the
* clock using the times returned from #GstBaseSinkClass.get_times(). If this
- * function returns #GST_CLOCK_TIME_NONE for the start time, no synchronisation
+ * function returns %GST_CLOCK_TIME_NONE for the start time, no synchronisation
* will be done. Synchronisation can be disabled entirely by setting the object
* #GstBaseSink:sync property to %FALSE.
*
* element receives EOS in PAUSED, preroll completes, the event is queued and an
* EOS message is posted when going to PLAYING.
*
- * #GstBaseSink will internally use the #GST_EVENT_SEGMENT events to schedule
+ * #GstBaseSink will internally use the %GST_EVENT_SEGMENT events to schedule
* synchronisation and clipping of buffers. Buffers that fall completely outside
* of the current segment are dropped. Buffers that fall partially in the
* segment are rendered (and prerolled). Subclasses should do any subbuffer
* clipping themselves when needed.
*
* #GstBaseSink will by default report the current playback position in
- * #GST_FORMAT_TIME based on the current clock time and segment information.
+ * %GST_FORMAT_TIME based on the current clock time and segment information.
* If no clock has been set on the element, the query will be forwarded
* upstream.
*
/**
* GstBaseSink:async:
*
- * If set to #TRUE, the basesink will perform asynchronous state changes.
- * When set to #FALSE, the sink will not signal the parent when it prerolls.
+ * If set to %TRUE, the basesink will perform asynchronous state changes.
+ * When set to %FALSE, the sink will not signal the parent when it prerolls.
* Use this option when dealing with sparse streams or when synchronisation is
* not required.
*/
/**
* GstBaseSink:enable-last-sample:
*
- * Enable the last-sample property. If FALSE, basesink doesn't keep a
+ * Enable the last-sample property. If %FALSE, basesink doesn't keep a
* reference to the last buffer arrived and the last-sample property is always
- * set to NULL. This can be useful if you need buffers to be released as soon
+ * set to %NULL. This can be useful if you need buffers to be released as soon
* as possible, eg. if you're using a buffer pool.
*/
g_object_class_install_property (gobject_class, PROP_ENABLE_LAST_SAMPLE,
*
* The last buffer that arrived in the sink and was used for preroll or for
* rendering. This property can be used to generate thumbnails. This property
- * can be NULL when the sink has not yet received a buffer.
+ * can be %NULL when the sink has not yet received a buffer.
*/
g_object_class_install_property (gobject_class, PROP_LAST_SAMPLE,
g_param_spec_boxed ("last-sample", "Last Sample",
* @sync: the new sync value.
*
* Configures @sink to synchronize on the clock or not. When
- * @sync is FALSE, incoming samples will be played as fast as
- * possible. If @sync is TRUE, the timestamps of the incoming
+ * @sync is %FALSE, incoming samples will be played as fast as
+ * possible. If @sync is %TRUE, the timestamps of the incoming
* buffers will be used to schedule the exact render time of its
* contents.
*/
* Checks if @sink is currently configured to synchronize against the
* clock.
*
- * Returns: TRUE if the sink is configured to synchronize against the clock.
+ * Returns: %TRUE if the sink is configured to synchronize against the clock.
*/
gboolean
gst_base_sink_get_sync (GstBaseSink * sink)
* Checks if @sink is currently configured to send Quality-of-Service events
* upstream.
*
- * Returns: TRUE if the sink is configured to perform Quality-of-Service.
+ * Returns: %TRUE if the sink is configured to perform Quality-of-Service.
*/
gboolean
gst_base_sink_is_qos_enabled (GstBaseSink * sink)
* Checks if @sink is currently configured to perform asynchronous state
* changes to PAUSED.
*
- * Returns: TRUE if the sink is configured to perform asynchronous state
+ * Returns: %TRUE if the sink is configured to perform asynchronous state
* changes.
*/
gboolean
* Free-function: gst_sample_unref
*
* Returns: (transfer full): a #GstSample. gst_sample_unref() after usage.
- * This function returns NULL when no buffer has arrived in the sink yet
+ * This function returns %NULL when no buffer has arrived in the sink yet
* or when the sink is not in PAUSED or PLAYING.
*/
GstSample *
* Checks if @sink is currently configured to store the last received sample in
* the last-sample property.
*
- * Returns: TRUE if the sink is configured to store the last received sample.
+ * Returns: %TRUE if the sink is configured to store the last received sample.
*/
gboolean
gst_base_sink_is_last_sample_enabled (GstBaseSink * sink)
* @max_latency: (out) (allow-none): the max latency of the upstream elements
*
* Query the sink for the latency parameters. The latency will be queried from
- * the upstream elements. @live will be TRUE if @sink is configured to
- * synchronize against the clock. @upstream_live will be TRUE if an upstream
+ * the upstream elements. @live will be %TRUE if @sink is configured to
+ * synchronize against the clock. @upstream_live will be %TRUE if an upstream
* element is live.
*
- * If both @live and @upstream_live are TRUE, the sink will want to compensate
+ * If both @live and @upstream_live are %TRUE, the sink will want to compensate
* for the latency introduced by the upstream elements by setting the
* @min_latency to a strictly positive value.
*
* This function is mostly used by subclasses.
*
- * Returns: TRUE if the query succeeded.
+ * Returns: %TRUE if the query succeeded.
*/
gboolean
gst_base_sink_query_latency (GstBaseSink * sink, gboolean * live,
/* Depending on the state, set our vars. We get in this situation when the
* state change function got a change to update the state vars before the
* streaming thread did. This is fine but we need to make sure that we
- * update the need_preroll var since it was TRUE when we got here and might
- * become FALSE if we got to PLAYING. */
+ * update the need_preroll var since it was %TRUE when we got here and might
+ * become %FALSE if we got to PLAYING. */
GST_DEBUG_OBJECT (basesink, "nothing to commit, now in %s",
gst_element_state_get_name (current));
switch (current) {
/* with STREAM_LOCK, PREROLL_LOCK
*
- * Returns TRUE if the object needs synchronisation and takes therefore
+ * Returns %TRUE if the object needs synchronisation and takes therefore
* part in prerolling.
*
* rsstart/rsstop contain the start/stop in stream time.
out_of_segment:
{
/* we usually clip in the chain function already but stepping could cause
- * the segment to be updated later. we return FALSE so that we don't try
+ * the segment to be updated later. we return %FALSE so that we don't try
* to sync on it. */
GST_LOG_OBJECT (basesink, "buffer skipped, not in segment");
return FALSE;
* gst_base_sink_wait_clock:
* @sink: the sink
* @time: the running_time to be reached
- * @jitter: (out) (allow-none): the jitter to be filled with time diff, or NULL
+ * @jitter: (out) (allow-none): the jitter to be filled with time diff, or %NULL
*
* This function will block until @time is reached. It is usually called by
* subclasses that use their own internal synchronisation.
*
- * If @time is not valid, no synchronisation is done and #GST_CLOCK_BADTIME is
+ * If @time is not valid, no synchronisation is done and %GST_CLOCK_BADTIME is
* returned. Likewise, if synchronisation is disabled in the element or there
- * is no clock, no synchronisation is done and #GST_CLOCK_BADTIME is returned.
+ * is no clock, no synchronisation is done and %GST_CLOCK_BADTIME is returned.
*
* This function should only be called with the PREROLL_LOCK held, like when
* receiving an EOS event in the #GstBaseSinkClass.event() vmethod or when
* and call this method before continuing to render the remaining data.
*
* This function will block until a state change to PLAYING happens (in which
- * case this function returns #GST_FLOW_OK) or the processing must be stopped due
+ * case this function returns %GST_FLOW_OK) or the processing must be stopped due
* to a state change to READY or a FLUSH event (in which case this function
- * returns #GST_FLOW_FLUSHING).
+ * returns %GST_FLOW_FLUSHING).
*
* This function should only be called with the PREROLL_LOCK held, like in the
* render function.
*
- * Returns: #GST_FLOW_OK if the preroll completed and processing can
+ * Returns: %GST_FLOW_OK if the preroll completed and processing can
* continue. Any other return value should be returned from the render vmethod.
*/
GstFlowReturn
*
* This function should be called with the PREROLL_LOCK held.
*
- * Returns: #GST_FLOW_OK if the preroll completed and processing can
+ * Returns: %GST_FLOW_OK if the preroll completed and processing can
* continue. Any other return value should be returned from the render vmethod.
*/
GstFlowReturn
* gst_base_sink_wait:
* @sink: the sink
* @time: the running_time to be reached
- * @jitter: (out) (allow-none): the jitter to be filled with time diff, or NULL
+ * @jitter: (out) (allow-none): the jitter to be filled with time diff, or %NULL
*
* This function will wait for preroll to complete and will then block until @time
* is reached. It is usually called by subclasses that use their own internal
* immediately returns GST_FLOW_OK.
*
* for objects that arrive later than max-lateness to be synchronized to the
- * clock have the @late boolean set to TRUE.
+ * clock have the @late boolean set to %TRUE.
*
* This function keeps a running average of the jitter (the diff between the
* clock time and the requested sync time). The jitter is negative for
*
* status and jitter contain the return values from the clock wait.
*
- * returns TRUE if the buffer was too late.
+ * returns %TRUE if the buffer was too late.
*/
static gboolean
gst_base_sink_is_too_late (GstBaseSink * basesink, GstMiniObject * obj,
result = FALSE;
/* this returns the intersection between our caps and the peer caps. If there
- * is no peer, it returns NULL and we can't operate in pull mode so we can
+ * is no peer, it returns %NULL and we can't operate in pull mode so we can
* fail the negotiation. */
caps = gst_pad_get_allowed_caps (GST_BASE_SINK_PAD (basesink));
if (caps == NULL || gst_caps_is_empty (caps))
*
* The source can be configured to operate in any #GstFormat with the
* gst_base_src_set_format() method. The currently set format determines
- * the format of the internal #GstSegment and any #GST_EVENT_SEGMENT
- * events. The default format for #GstBaseSrc is #GST_FORMAT_BYTES.
+ * the format of the internal #GstSegment and any %GST_EVENT_SEGMENT
+ * events. The default format for #GstBaseSrc is %GST_FORMAT_BYTES.
*
* #GstBaseSrc always supports push mode scheduling. If the following
* conditions are met, it also supports pull mode scheduling:
* <itemizedlist>
- * <listitem><para>The format is set to #GST_FORMAT_BYTES (default).</para>
+ * <listitem><para>The format is set to %GST_FORMAT_BYTES (default).</para>
* </listitem>
* <listitem><para>#GstBaseSrcClass.is_seekable() returns %TRUE.</para>
* </listitem>
* If all the conditions are met for operating in pull mode, #GstBaseSrc is
* automatically seekable in push mode as well. The following conditions must
* be met to make the element seekable in push mode when the format is not
- * #GST_FORMAT_BYTES:
+ * %GST_FORMAT_BYTES:
* <itemizedlist>
* <listitem><para>
* #GstBaseSrcClass.is_seekable() returns %TRUE.
* #GstBaseSrcClass.create() method will not be called in PAUSED but only in
* PLAYING. To signal the pipeline that the element will not produce data, the
* return value from the READY to PAUSED state will be
- * #GST_STATE_CHANGE_NO_PREROLL.
+ * %GST_STATE_CHANGE_NO_PREROLL.
*
* A typical live source will timestamp the buffers it creates with the
* current running time of the pipeline. This is one reason why a live source
* {
* GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
* // srctemplate should be a #GstStaticPadTemplate with direction
- * // #GST_PAD_SRC and name "src"
+ * // %GST_PAD_SRC and name "src"
* gst_element_class_add_pad_template (gstelement_class,
* gst_static_pad_template_get (&srctemplate));
*
*
* An application may send an EOS event to a source element to make it
* perform the EOS logic (send EOS event downstream or post a
- * #GST_MESSAGE_SEGMENT_DONE on the bus). This can typically be done
+ * %GST_MESSAGE_SEGMENT_DONE on the bus). This can typically be done
* with the gst_element_send_event() function on the element or its parent bin.
*
* After the EOS has been sent to the element, the application should wait for
* and call this method before continuing to produce the remaining data.
*
* This function will block until a state change to PLAYING happens (in which
- * case this function returns #GST_FLOW_OK) or the processing must be stopped due
+ * case this function returns %GST_FLOW_OK) or the processing must be stopped due
* to a state change to READY or a FLUSH event (in which case this function
- * returns #GST_FLOW_FLUSHING).
+ * returns %GST_FLOW_FLUSHING).
*
- * Returns: #GST_FLOW_OK if @src is PLAYING and processing can
+ * Returns: %GST_FLOW_OK if @src is PLAYING and processing can
* continue. Any other return value should be returned from the create vmethod.
*/
GstFlowReturn
* for sending SEGMENT events and for performing seeks.
*
* If a format of GST_FORMAT_BYTES is set, the element will be able to
- * operate in pull mode if the #GstBaseSrcClass.is_seekable() returns TRUE.
+ * operate in pull mode if the #GstBaseSrcClass.is_seekable() returns %TRUE.
*
* This function must only be called in states < %GST_STATE_PAUSED.
*/
* @min_latency: (out) (allow-none): the min latency of the source
* @max_latency: (out) (allow-none): the max latency of the source
*
- * Query the source for the latency parameters. @live will be TRUE when @src is
+ * Query the source for the latency parameters. @live will be %TRUE when @src is
* configured as a live source. @min_latency will be set to the difference
* between the running time and the timestamp of the first buffer.
* @max_latency is always the undefined value of -1.
*
* This function is mostly used by subclasses.
*
- * Returns: TRUE if the query succeeded.
+ * Returns: %TRUE if the query succeeded.
*/
gboolean
gst_base_src_query_latency (GstBaseSrc * src, gboolean * live,
* these times.
* @get_size: Return the total size of the resource, in the configured format.
* @is_seekable: Check if the source can seek
- * @prepare_seek_segment: Prepare the GstSegment that will be passed to the
- * do_seek vmethod for executing a seek request. Sub-classes should override
- * this if they support seeking in formats other than the configured native
- * format. By default, it tries to convert the seek arguments to the
- * configured native format and prepare a segment in that format.
+ * @prepare_seek_segment: Prepare the #GstSegment that will be passed to the
+ * #GstBaseSrcClass.do_seek() vmethod for executing a seek
+ * request. Sub-classes should override this if they support seeking in
+ * formats other than the configured native format. By default, it tries to
+ * convert the seek arguments to the configured native format and prepare a
+ * segment in that format.
* @do_seek: Perform seeking on the resource to the indicated segment.
- * @unlock: Unlock any pending access to the resource. Subclasses should
- * unblock any blocked function ASAP. In particular, any create() function in
+ * @unlock: Unlock any pending access to the resource. Subclasses should unblock
+ * any blocked function ASAP. In particular, any create() function in
* progress should be unblocked and should return GST_FLOW_FLUSHING. Any
- * future @create<!-- -->() function call should also return GST_FLOW_FLUSHING
- * until the @unlock_stop<!-- -->() function has been called.
- * @unlock_stop: Clear the previous unlock request. Subclasses should clear
- * any state they set during unlock(), such as clearing command queues.
+ * future #GstBaseSrcClass.create() function call should also return
+ * GST_FLOW_FLUSHING until the #GstBaseSrcClass.unlock_stop() function has
+ * been called.
+ * @unlock_stop: Clear the previous unlock request. Subclasses should clear any
+ * state they set during #GstBaseSrcClass.unlock(), such as clearing command
+ * queues.
* @query: Handle a requested query.
* @event: Override this to implement custom event handling.
- * @create: Ask the subclass to create a buffer with offset and size.
- * When the subclass returns GST_FLOW_OK, it MUST return a buffer of the
- * requested size unless fewer bytes are available because an EOS condition
- * is near. No buffer should be returned when the return value is different
- * from GST_FLOW_OK. A return value of GST_FLOW_EOS signifies that the
- * end of stream is reached. The default implementation will call @alloc and
- * then call @fill.
+ * @create: Ask the subclass to create a buffer with offset and size. When the
+ * subclass returns GST_FLOW_OK, it MUST return a buffer of the requested size
+ * unless fewer bytes are available because an EOS condition is near. No
+ * buffer should be returned when the return value is different from
+ * GST_FLOW_OK. A return value of GST_FLOW_EOS signifies that the end of
+ * stream is reached. The default implementation will call
+ * #GstBaseSrcClass.alloc() and then call #GstBaseSrcClass.fill().
* @alloc: Ask the subclass to allocate a buffer with for offset and size. The
* default implementation will create a new buffer from the negotiated allocator.
* @fill: Ask the subclass to fill the buffer with data for offset and size. The
* intact.
* </para></listitem>
* <listitem><para>
- * On the GstBaseTransformClass is the passthrough_on_same_caps variable
- * which will automatically set/unset passthrough based on whether the
+ * The #GstBaseTransformClass.passthrough_on_same_caps variable
+ * will automatically set/unset passthrough based on whether the
* element negotiates the same caps on both pads.
* </para></listitem>
* <listitem><para>
- * passthrough_on_same_caps on an element that doesn't implement a
- * transform_caps function is useful for elements that only inspect data
- * (such as level)
+ * #GstBaseTransformClass.passthrough_on_same_caps on an element that
+ * doesn't implement a transform_caps function is useful for elements that
+ * only inspect data (such as level)
* </para></listitem>
* </itemizedlist>
* <itemizedlist>
* immediately. </para></listitem>
* <listitem><para>
* only implementing transform_ip and not transform implies always_in_place
- * = TRUE
+ * = %TRUE
* </para></listitem>
* </itemizedlist>
* <itemizedlist>
* <listitem><para>
* Elements wishing to operate in this mode should replace the
* prepare_output_buffer method to create subbuffers of the input buffer
- * and set always_in_place to TRUE
+ * and set always_in_place to %TRUE
* </para></listitem>
* </itemizedlist>
* <itemizedlist>
* to the transform_ip function.
* </para></listitem>
* <listitem><para>
- * Implied TRUE if no transform function is implemented.
+ * Implied %TRUE if no transform function is implemented.
* </para></listitem>
* <listitem><para>
- * Implied FALSE if ONLY transform function is implemented.
+ * Implied %FALSE if ONLY transform function is implemented.
* </para></listitem>
* </itemizedlist>
* </para></listitem>
}
/* we only copy metadata when the subclass implemented a transform_meta
- * function and when it returns TRUE */
+ * function and when it returns %TRUE */
if (do_copy) {
GstMetaTransformCopy copy_data = { FALSE, 0, -1 };
GST_DEBUG_OBJECT (trans, "copy metadata %s", g_type_name (info->api));
* We have two cache locations to store the size, one for the source caps
* and one for the sink caps.
*
- * this function returns FALSE if no size could be calculated.
+ * this function returns %FALSE if no size could be calculated.
*/
static gboolean
gst_base_transform_get_unit_size (GstBaseTransform * trans, GstCaps * caps,
* Set passthrough mode for this filter by default. This is mostly
* useful for filters that do not care about negotiation.
*
- * Always TRUE for filters which don't implement either a transform
+ * Always %TRUE for filters which don't implement either a transform
* or transform_ip method.
*
* MT safe.
*
* See if @trans is configured as a passthrough transform.
*
- * Returns: TRUE is the transform is configured in passthrough mode.
+ * Returns: %TRUE is the transform is configured in passthrough mode.
*
* MT safe.
*/
* Determines whether a non-writable buffer will be copied before passing
* to the transform_ip function.
* <itemizedlist>
- * <listitem>Always TRUE if no transform function is implemented.</listitem>
- * <listitem>Always FALSE if ONLY transform function is implemented.</listitem>
+ * <listitem>Always %TRUE if no transform function is implemented.</listitem>
+ * <listitem>Always %FALSE if ONLY transform function is implemented.</listitem>
* </itemizedlist>
*
* MT safe.
*
* See if @trans is configured as a in_place transform.
*
- * Returns: TRUE is the transform is configured in in_place mode.
+ * Returns: %TRUE is the transform is configured in in_place mode.
*
* MT safe.
*/
*
* Queries if the transform will handle QoS.
*
- * Returns: TRUE if QoS is enabled.
+ * Returns: %TRUE if QoS is enabled.
*
* MT safe.
*/
* If there is a @filter_meta method implementation, it will
* be called for all metadata API in the downstream query,
* otherwise the metadata API is removed.
- * @filter_meta: Return TRUE if the metadata API should be proposed in the
- * upstream allocation query. The default implementation is NULL
+ * @filter_meta: Return %TRUE if the metadata API should be proposed in the
+ * upstream allocation query. The default implementation is %NULL
* and will cause all metadata to be removed.
* @propose_allocation: Propose buffer allocation parameters for upstream elements.
* This function must be implemented if the element reads or
* writes the buffer content. The query that was passed to
- * the decide_allocation is passed in this method (or NULL
+ * the decide_allocation is passed in this method (or %NULL
* when the element is in passthrough mode). The default
* implementation will pass the query downstream when in
* passthrough mode and will copy all the filtered metadata
* The default implementation will copy the flags, timestamps and
* offsets of the buffer.
* @transform_meta: Optional. Transform the metadata on the input buffer to the
- * output buffer. By default this method is NULL and no
+ * output buffer. By default this method is %NULL and no
* metadata is copied. subclasses can implement this method and
- * return TRUE if the metadata is to be copied.
+ * return %TRUE if the metadata is to be copied.
* @before_transform: Optional.
* This method is called right before the base class will
* start processing. Dynamic properties or other delayed
* <listitem><para>
* Data can be dequeued from the pad with the gst_collect_pads_pop() method.
* One can peek at the data with the gst_collect_pads_peek() function.
- * These functions will return NULL if the pad received an EOS event. When all
- * pads return NULL from a gst_collect_pads_peek(), the element can emit an EOS
+ * These functions will return %NULL if the pad received an EOS event. When all
+ * pads return %NULL from a gst_collect_pads_peek(), the element can emit an EOS
* event itself.
* </para></listitem>
* <listitem><para>
*
* MT safe.
*
- * Returns: (transfer full): a new #GstCollectPads, or NULL in case of an error.
+ * Returns: (transfer full): a new #GstCollectPads, or %NULL in case of an error.
*/
GstCollectPads *
gst_collect_pads_new (void)
* @user_data: (closure): user data passed to the function
*
* Set the callback function and user data that will be called with
- * the oldest buffer when all pads have been collected, or NULL on EOS.
+ * the oldest buffer when all pads have been collected, or %NULL on EOS.
* If a buffer is passed, the callback owns a reference and must unref
* it.
*
*
* MT safe.
*
- * Returns: a new #GstCollectData to identify the new pad. Or NULL
+ * Returns: a new #GstCollectData to identify the new pad. Or %NULL
* if wrong parameters are supplied.
*/
GstCollectData *
*
* MT safe.
*
- * Returns: The buffer in @data or NULL if no buffer is queued.
+ * Returns: The buffer in @data or %NULL if no buffer is queued.
* should unref the buffer after usage.
*/
GstBuffer *
*
* MT safe.
*
- * Returns: (transfer full): The buffer in @data or NULL if no buffer was
+ * Returns: (transfer full): The buffer in @data or %NULL if no buffer was
* queued. You should unref the buffer after usage.
*/
GstBuffer *
* MT safe.
*
* Returns: (transfer full): A sub buffer. The size of the buffer can be less that requested.
- * A return of NULL signals that the pad is end-of-stream.
+ * A return of %NULL signals that the pad is end-of-stream.
* Unref the buffer after use.
*/
GstBuffer *
* MT safe.
*
* Returns: A sub buffer. The size of the buffer can be less that requested.
- * A return of NULL signals that the pad is end-of-stream.
+ * A return of %NULL signals that the pad is end-of-stream.
* Unref the buffer after use.
*/
GstBuffer *
*
* Must be called with STREAM_LOCK.
*
- * Returns TRUE if a pad was set to waiting
+ * Returns %TRUE if a pad was set to waiting
* (from non-waiting state).
*/
static gboolean
* @event: event being processed
* @discard: process but do not send event downstream
*
- * Default GstCollectPads event handling that elements should always
+ * Default #GstCollectPads event handling that elements should always
* chain up to to ensure proper operation. Element might however indicate
* event should not be forwarded downstream.
*/
* @pad: src #GstPad that received the event
* @event: event being processed
*
- * Default GstCollectPads event handling for the src pad of elements.
+ * Default #GstCollectPads event handling for the src pad of elements.
* Elements can chain up to this to let flushing seek event handling
* be done by GstCollectPads.
*
* @query: query being processed
* @discard: process but do not send event downstream
*
- * Default GstCollectPads query handling that elements should always
+ * Default #GstCollectPads query handling that elements should always
* chain up to to ensure proper operation. Element might however indicate
* query should not be forwarded downstream.
*/
*
* A function that will be called when all pads have received data.
*
- * Returns: #GST_FLOW_OK for success
+ * Returns: %GST_FLOW_OK for success
*/
typedef GstFlowReturn (*GstCollectPadsFunction) (GstCollectPads *pads, gpointer user_data);
* @user_data: user data passed to gst_collect_pads_set_buffer_function()
*
* A function that will be called when a (considered oldest) buffer can be muxed.
- * If all pads have reached EOS, this function is called with NULL @buffer
- * and NULL @data.
+ * If all pads have reached EOS, this function is called with %NULL @buffer
+ * and %NULL @data.
*
- * Returns: #GST_FLOW_OK for success
+ * Returns: %GST_FLOW_OK for success
*/
typedef GstFlowReturn (*GstCollectPadsBufferFunction) (GstCollectPads *pads, GstCollectData *data,
GstBuffer *buffer, gpointer user_data);
* Queries if there are any items in the @queue.
* MT safe.
*
- * Returns: #TRUE if @queue is empty.
+ * Returns: %TRUE if @queue is empty.
*
* Since: 1.2
*/
* #GstDataQueueCheckFullFunction registered with @queue.
* MT safe.
*
- * Returns: #TRUE if @queue is full.
+ * Returns: %TRUE if @queue is full.
*
* Since: 1.2
*/
* @queue: a #GstDataQueue.
* @flushing: a #gboolean stating if the queue will be flushing or not.
*
- * Sets the queue to flushing state if @flushing is #TRUE. If set to flushing
+ * Sets the queue to flushing state if @flushing is %TRUE. If set to flushing
* state, any incoming data on the @queue will be discarded. Any call currently
* blocking on #gst_data_queue_push or #gst_data_queue_pop will return straight
- * away with a return value of #FALSE. While the @queue is in flushing state,
- * all calls to those two functions will return #FALSE.
+ * away with a return value of %FALSE. While the @queue is in flushing state,
+ * all calls to those two functions will return %FALSE.
*
* MT Safe.
*
*
* Note that this function has slightly different semantics than gst_pad_push()
* and gst_pad_push_event(): this function only takes ownership of @item and
- * the #GstMiniObject contained in @item if the push was successful. If FALSE
+ * the #GstMiniObject contained in @item if the push was successful. If %FALSE
* is returned, the caller is responsible for freeing @item and its contents.
*
- * Returns: #TRUE if the @item was successfully pushed on the @queue.
+ * Returns: %TRUE if the @item was successfully pushed on the @queue.
*
* Since: 1.2
*/
*
* Note that this function has slightly different semantics than gst_pad_push()
* and gst_pad_push_event(): this function only takes ownership of @item and
- * the #GstMiniObject contained in @item if the push was successful. If FALSE
+ * the #GstMiniObject contained in @item if the push was successful. If %FALSE
* is returned, the caller is responsible for freeing @item and its contents.
*
- * Returns: #TRUE if the @item was successfully pushed on the @queue.
+ * Returns: %TRUE if the @item was successfully pushed on the @queue.
*
* Since: 1.2
*/
* @queue is set to the flushing state.
* MT safe.
*
- * Returns: #TRUE if an @item was successfully retrieved from the @queue.
+ * Returns: %TRUE if an @item was successfully retrieved from the @queue.
*
* Since: 1.2
*/
* one item is available, OR the @queue is set to the flushing state.
* MT safe.
*
- * Returns: #TRUE if an @item was successfully retrieved from the @queue.
+ * Returns: %TRUE if an @item was successfully retrieved from the @queue.
*
* Since: 1.2
*/
*
* Pop and unref the head-most #GstMiniObject with the given #GType.
*
- * Returns: TRUE if an element was removed.
+ * Returns: %TRUE if an element was removed.
*
* Since: 1.2
*/
* @object: the #GstMiniObject to queue.
* @size: the size in bytes of the miniobject.
* @duration: the duration in #GstClockTime of the miniobject. Can not be
- * #GST_CLOCK_TIME_NONE.
- * @visible: #TRUE if @object should be considered as a visible object.
+ * %GST_CLOCK_TIME_NONE.
+ * @visible: %TRUE if @object should be considered as a visible object.
* @destroy: The #GDestroyNotify function to use to free the #GstDataQueueItem.
* This function should also drop the reference to @object the owner of the
* #GstDataQueueItem is assumed to hold.
* The prototype of the function used to inform the queue that it should be
* considered as full.
*
- * Returns: #TRUE if the queue should be considered full.
+ * Returns: %TRUE if the queue should be considered full.
*/
typedef gboolean (*GstDataQueueCheckFullFunction) (GstDataQueue * queue,
guint visible, guint bytes, guint64 time, gpointer checkdata);
* @short_description: Generate indexes on objects
* @see_also: #GstIndexFactory
*
- * GstIndex is used to generate a stream index of one or more elements
+ * #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
*
* Set the current groupnumber to the given argument.
*
- * Returns: TRUE if the operation succeeded, FALSE if the group
+ * Returns: %TRUE if the operation succeeded, %FALSE if the group
* did not exist.
*/
gboolean
* @format: the format to add to the index
*
* Adds a format entry into the index. This function is
- * used to map dynamic GstFormat ids to their original
+ * used to map dynamic #GstFormat ids to their original
* format key.
*
* Free-function: gst_index_entry_free
/**
* gst_index_get_writer_id:
* @index: the index to get a unique write id for
- * @writer: the GstObject to allocate an id for
+ * @writer: the #GstObject to allocate an id for
* @id: a pointer to a gint to hold the id
*
* Before entries can be added to the index, a writer
* in the index.
*
* <note>
- * The caller must not hold @writer's #GST_OBJECT_LOCK, as the default
+ * The caller must not hold @writer's GST_OBJECT_LOCK(), as the default
* resolver may call functions that take the object lock as well, and
* the lock is not recursive.
* </note>
*
- * Returns: TRUE if the writer would be mapped to an id.
+ * Returns: %TRUE if the writer would be mapped to an id.
*/
gboolean
gst_index_get_writer_id (GstIndex * index, GstObject * writer, gint * id)
*
* Finds the given format/value in the index
*
- * Returns: the entry associated with the value or NULL if the
+ * Returns: the entry associated with the value or %NULL if the
* value was not found.
*/
GstIndexEntry *
* Finds the given format/value in the index with the given
* compare function and user_data.
*
- * Returns: the entry associated with the value or NULL if the
+ * Returns: the entry associated with the value or %NULL if the
* value was not found.
*/
GstIndexEntry *
*
* Gets alternative formats associated with the indexentry.
*
- * Returns: TRUE if there was a value associated with the given
+ * Returns: %TRUE if there was a value associated with the given
* format.
*/
gboolean
#endif
/* getrange might silently return shortened buffers at the end of a file,
- * we must, however, always return either the full requested data or NULL */
+ * we must, however, always return either the full requested data or %NULL */
buf_offset = GST_BUFFER_OFFSET (buffer);
buf_size = gst_buffer_get_size (buffer);
/**
* gst_type_find_helper_get_range:
* @obj: A #GstObject that will be passed as first argument to @func
- * @parent: (allow-none): the parent of @obj or NULL
+ * @parent: (allow-none): the parent of @obj or %NULL
* @func: (scope call): A generic #GstTypeFindHelperGetRangeFunction that will
* be used to access data at random offsets when doing the typefinding
* @size: The length in bytes
* @extension: extension of the media
* @prob: (out) (allow-none): location to store the probability of the found
- * caps, or #NULL
+ * caps, or %NULL
*
* Utility function to do pull-based typefinding. Unlike gst_type_find_helper()
* however, this function will use the specified function @func to obtain the
* callback can then call the upstream peer pad with offsets adjusted for the
* tag size, for example).
*
- * When @extension is not NULL, this function will first try the typefind
+ * When @extension is not %NULL, this function will first try the typefind
* functions for the given extension, which might speed up the typefinding
* in many cases.
*
* Free-function: gst_caps_unref
*
* Returns: (transfer full): the #GstCaps corresponding to the data stream.
- * Returns #NULL if no #GstCaps matches the data stream.
+ * Returns %NULL if no #GstCaps matches the data stream.
*/
GstCaps *
gst_type_find_helper_get_range (GstObject * obj, GstObject * parent,
* Free-function: gst_caps_unref
*
* Returns: (transfer full): the #GstCaps corresponding to the data stream.
- * Returns #NULL if no #GstCaps matches the data stream.
+ * Returns %NULL if no #GstCaps matches the data stream.
*/
GstCaps *
/**
* gst_type_find_helper_for_data:
- * @obj: (allow-none): object doing the typefinding, or NULL (used for logging)
+ * @obj: (allow-none): object doing the typefinding, or %NULL (used for logging)
* @data: (in) (transfer none): a pointer with data to typefind
* @size: (in) (transfer none): the size of @data
* @prob: (out) (allow-none): location to store the probability of the found
- * caps, or #NULL
+ * caps, or %NULL
*
* Tries to find what type of data is contained in the given @data, the
* assumption being that the data represents the beginning of the stream or
* file.
*
* All available typefinders will be called on the data in order of rank. If
- * a typefinding function returns a probability of #GST_TYPE_FIND_MAXIMUM,
+ * a typefinding function returns a probability of %GST_TYPE_FIND_MAXIMUM,
* typefinding is stopped immediately and the found caps will be returned
* right away. Otherwise, all available typefind functions will the tried,
- * and the caps with the highest probability will be returned, or #NULL if
+ * and the caps with the highest probability will be returned, or %NULL if
* the content of @data could not be identified.
*
* Free-function: gst_caps_unref
*
- * Returns: (transfer full): the #GstCaps corresponding to the data, or #NULL
+ * Returns: (transfer full): the #GstCaps corresponding to the data, or %NULL
* if no type could be found. The caller should free the caps returned
* with gst_caps_unref().
*/
/**
* gst_type_find_helper_for_buffer:
- * @obj: (allow-none): object doing the typefinding, or NULL (used for logging)
+ * @obj: (allow-none): object doing the typefinding, or %NULL (used for logging)
* @buf: (in) (transfer none): a #GstBuffer with data to typefind
* @prob: (out) (allow-none): location to store the probability of the found
- * caps, or #NULL
+ * caps, or %NULL
*
* Tries to find what type of data is contained in the given #GstBuffer, the
* assumption being that the buffer represents the beginning of the stream or
* file.
*
* All available typefinders will be called on the data in order of rank. If
- * a typefinding function returns a probability of #GST_TYPE_FIND_MAXIMUM,
+ * a typefinding function returns a probability of %GST_TYPE_FIND_MAXIMUM,
* typefinding is stopped immediately and the found caps will be returned
* right away. Otherwise, all available typefind functions will the tried,
- * and the caps with the highest probability will be returned, or #NULL if
+ * and the caps with the highest probability will be returned, or %NULL if
* the content of the buffer could not be identified.
*
* Free-function: gst_caps_unref
*
- * Returns: (transfer full): the #GstCaps corresponding to the data, or #NULL
+ * Returns: (transfer full): the #GstCaps corresponding to the data, or %NULL
* if no type could be found. The caller should free the caps returned
* with gst_caps_unref().
*/
/**
* gst_type_find_helper_for_extension:
- * @obj: (allow-none): object doing the typefinding, or NULL (used for logging)
+ * @obj: (allow-none): object doing the typefinding, or %NULL (used for logging)
* @extension: an extension
*
* Tries to find the best #GstCaps associated with @extension.
* Free-function: gst_caps_unref
*
* Returns: (transfer full): the #GstCaps corresponding to @extension, or
- * #NULL if no type could be found. The caller should free the caps
+ * %NULL if no type could be found. The caller should free the caps
* returned with gst_caps_unref().
*/
GstCaps *
/**
* GstTypeFindHelperGetRangeFunction:
* @obj: a #GstObject that will handle the getrange request
- * @parent: (allow-none): the parent of @obj or NULL
+ * @parent: (allow-none): the parent of @obj or %NULL
* @offset: the offset of the range
* @length: the length of the range
* @buffer: a memory location to hold the result buffer
projects / platform / upstream / gstreamer.git / commitdiff