struct GstQuery

struct GstQuery {
  GstMiniObject mini_object;

  GstQueryType type;
};

The GstQuery structure.

enum GstQueryTypeFlags

typedef enum {
  GST_QUERY_TYPE_UPSTREAM       = 1 << 0,
  GST_QUERY_TYPE_DOWNSTREAM     = 1 << 1,
  GST_QUERY_TYPE_SERIALIZED     = 1 << 2
} GstQueryTypeFlags;

GstQueryTypeFlags indicate the aspects of the different GstQueryType values. You can get the type flags of a GstQueryType with the gst_query_type_get_flags() function.

GST_QUERY_TYPE_BOTH

#define             GST_QUERY_TYPE_BOTH

The same thing as GST_QUERY_TYPE_UPSTREAM | GST_QUERY_TYPE_DOWNSTREAM.

GST_QUERY_MAKE_TYPE()

#define             GST_QUERY_MAKE_TYPE(num,flags)

when making custom query types, use this macro with the num and the given flags

enum GstQueryType

typedef enum {
  GST_QUERY_UNKNOWN      = GST_QUERY_MAKE_TYPE (0, 0),
  GST_QUERY_POSITION     = GST_QUERY_MAKE_TYPE (10, FLAG(BOTH)),
  GST_QUERY_DURATION     = GST_QUERY_MAKE_TYPE (20, FLAG(BOTH)),
  GST_QUERY_LATENCY      = GST_QUERY_MAKE_TYPE (30, FLAG(BOTH)),
  GST_QUERY_JITTER       = GST_QUERY_MAKE_TYPE (40, FLAG(BOTH)),
  GST_QUERY_RATE         = GST_QUERY_MAKE_TYPE (50, FLAG(BOTH)),
  GST_QUERY_SEEKING      = GST_QUERY_MAKE_TYPE (60, FLAG(BOTH)),
  GST_QUERY_SEGMENT      = GST_QUERY_MAKE_TYPE (70, FLAG(BOTH)),
  GST_QUERY_CONVERT      = GST_QUERY_MAKE_TYPE (80, FLAG(BOTH)),
  GST_QUERY_FORMATS      = GST_QUERY_MAKE_TYPE (90, FLAG(BOTH)),
  GST_QUERY_BUFFERING    = GST_QUERY_MAKE_TYPE (110, FLAG(BOTH)),
  GST_QUERY_CUSTOM       = GST_QUERY_MAKE_TYPE (120, FLAG(BOTH)),
  GST_QUERY_URI          = GST_QUERY_MAKE_TYPE (130, FLAG(BOTH)),
  GST_QUERY_ALLOCATION   = GST_QUERY_MAKE_TYPE (140, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)),
  GST_QUERY_SCHEDULING   = GST_QUERY_MAKE_TYPE (150, FLAG(UPSTREAM)),
  GST_QUERY_ACCEPT_CAPS  = GST_QUERY_MAKE_TYPE (160, FLAG(BOTH)),
  GST_QUERY_CAPS         = GST_QUERY_MAKE_TYPE (170, FLAG(BOTH)),
  GST_QUERY_DRAIN        = GST_QUERY_MAKE_TYPE (180, FLAG(DOWNSTREAM) | FLAG(SERIALIZED)),
  GST_QUERY_CONTEXT      = GST_QUERY_MAKE_TYPE (190, FLAG(DOWNSTREAM))
} GstQueryType;

Standard predefined Query types

GST_QUERY_TYPE()

#define GST_QUERY_TYPE(query)  (((GstQuery*)(query))->type)

Get the GstQueryType of the query.

GST_QUERY_TYPE_NAME()

#define GST_QUERY_TYPE_NAME(query) (gst_query_type_get_name(GST_QUERY_TYPE(query)))

Get a constant string representation of the GstQueryType of the query.

GST_QUERY_IS_UPSTREAM()

#define GST_QUERY_IS_UPSTREAM(ev)       !!(GST_QUERY_TYPE (ev) & GST_QUERY_TYPE_UPSTREAM)

Check if an query can travel upstream.

GST_QUERY_IS_DOWNSTREAM()

#define GST_QUERY_IS_DOWNSTREAM(ev)     !!(GST_QUERY_TYPE (ev) & GST_QUERY_TYPE_DOWNSTREAM)

Check if an query can travel downstream.

GST_QUERY_IS_SERIALIZED()

#define GST_QUERY_IS_SERIALIZED(ev)     !!(GST_QUERY_TYPE (ev) & GST_QUERY_TYPE_SERIALIZED)

Check if an query is serialized with the data stream.

gst_query_type_get_flags ()

GstQueryTypeFlags   gst_query_type_get_flags            (GstQueryType type);

Gets the GstQueryTypeFlags associated with type.

gst_query_type_get_name ()

const gchar *       gst_query_type_get_name             (GstQueryType type);

Get a printable name for the given query type. Do not modify or free.

gst_query_type_to_quark ()

GQuark              gst_query_type_to_quark             (GstQueryType type);

Get the unique quark for the given query type.

gst_query_ref ()

GstQuery *          gst_query_ref                       (GstQuery *q);

Increases the refcount of the given query by one.

gst_query_unref ()

void                gst_query_unref                     (GstQuery *q);

Decreases the refcount of the query. If the refcount reaches 0, the query will be freed.

gst_query_copy ()

GstQuery *          gst_query_copy                      (const GstQuery *q);

Copies the given query using the copy function of the parent GstStructure.

Free-function: gst_query_unref

gst_query_make_writable()

#define         gst_query_make_writable(q)      GST_QUERY_CAST (gst_mini_object_make_writable (GST_MINI_OBJECT_CAST (q)))

Makes a writable query from the given query.

gst_query_is_writable()

#define         gst_query_is_writable(q)     gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (q))

Tests if you can safely write data into a query's structure.

gst_query_replace ()

gboolean            gst_query_replace                   (GstQuery **old_query,
                                                         GstQuery *new_query);

Modifies a pointer to a GstQuery to point to a different GstQuery. The modification is done atomically (so this is useful for ensuring thread safety in some cases), and the reference counts are updated appropriately (the old query is unreffed, the new one is reffed).

Either new_query or the GstQuery pointed to by old_query may be NULL.

gst_query_writable_structure ()

GstStructure *      gst_query_writable_structure        (GstQuery *query);

Get the structure of a query. This method should be called with a writable query so that the returned structure is guranteed to be writable.

gst_query_new_custom ()

GstQuery *          gst_query_new_custom                (GstQueryType type,
                                                         GstStructure *structure);

Constructs a new custom query object. Use gst_query_unref() when done with it.

Free-function: gst_query_unref

gst_query_get_structure ()

const GstStructure * gst_query_get_structure            (GstQuery *query);

Get the structure of a query.

gst_query_new_convert ()

GstQuery *          gst_query_new_convert               (GstFormat src_format,
                                                         gint64 value,
                                                         GstFormat dest_format);

Constructs a new convert query object. Use gst_query_unref() when done with it. A convert query is used to ask for a conversion between one format and another.

Free-function: gst_query_unref

gst_query_set_convert ()

void                gst_query_set_convert               (GstQuery *query,
                                                         GstFormat src_format,
                                                         gint64 src_value,
                                                         GstFormat dest_format,
                                                         gint64 dest_value);

Answer a convert query by setting the requested values.

gst_query_parse_convert ()

void                gst_query_parse_convert             (GstQuery *query,
                                                         GstFormat *src_format,
                                                         gint64 *src_value,
                                                         GstFormat *dest_format,
                                                         gint64 *dest_value);

Parse a convert query answer. Any of src_format, src_value, dest_format, and dest_value may be NULL, in which case that value is omitted.

gst_query_new_position ()

GstQuery *          gst_query_new_position              (GstFormat format);

Constructs a new query stream position query object. Use gst_query_unref() when done with it. A position query is used to query the current position of playback in the streams, in some format.

Free-function: gst_query_unref

gst_query_set_position ()

void                gst_query_set_position              (GstQuery *query,
                                                         GstFormat format,
                                                         gint64 cur);

Answer a position query by setting the requested value in the given format.

gst_query_parse_position ()

void                gst_query_parse_position            (GstQuery *query,
                                                         GstFormat *format,
                                                         gint64 *cur);

Parse a position query, writing the format into format, and the position into cur, if the respective parameters are non-NULL.

gst_query_new_duration ()

GstQuery *          gst_query_new_duration              (GstFormat format);

Constructs a new stream duration query object to query in the given format. Use gst_query_unref() when done with it. A duration query will give the total length of the stream.

Free-function: gst_query_unref

gst_query_set_duration ()

void                gst_query_set_duration              (GstQuery *query,
                                                         GstFormat format,
                                                         gint64 duration);

Answer a duration query by setting the requested value in the given format.

gst_query_parse_duration ()

void                gst_query_parse_duration            (GstQuery *query,
                                                         GstFormat *format,
                                                         gint64 *duration);

Parse a duration query answer. Write the format of the duration into format, and the value into duration, if the respective variables are non-NULL.

gst_query_new_latency ()

GstQuery *          gst_query_new_latency               (void);

Constructs a new latency query object. Use gst_query_unref() when done with it. A latency query is usually performed by sinks to compensate for additional latency introduced by elements in the pipeline.

Free-function: gst_query_unref

gst_query_parse_latency ()

void                gst_query_parse_latency             (GstQuery *query,
                                                         gboolean *live,
                                                         GstClockTime *min_latency,
                                                         GstClockTime *max_latency);

Parse a latency query answer.

gst_query_set_latency ()

void                gst_query_set_latency               (GstQuery *query,
                                                         gboolean live,
                                                         GstClockTime min_latency,
                                                         GstClockTime max_latency);

Answer a latency query by setting the requested values in the given format.

gst_query_new_seeking ()

GstQuery *          gst_query_new_seeking               (GstFormat format);

Constructs a new query object for querying seeking properties of the stream.

Free-function: gst_query_unref

gst_query_set_seeking ()

void                gst_query_set_seeking               (GstQuery *query,
                                                         GstFormat format,
                                                         gboolean seekable,
                                                         gint64 segment_start,
                                                         gint64 segment_end);

Set the seeking query result fields in query.

gst_query_parse_seeking ()

void                gst_query_parse_seeking             (GstQuery *query,
                                                         GstFormat *format,
                                                         gboolean *seekable,
                                                         gint64 *segment_start,
                                                         gint64 *segment_end);

Parse a seeking query, writing the format into format, and other results into the passed parameters, if the respective parameters are non-NULL

gst_query_new_formats ()

GstQuery *          gst_query_new_formats               (void);

Constructs a new query object for querying formats of the stream.

Free-function: gst_query_unref

gst_query_set_formats ()

void                gst_query_set_formats               (GstQuery *query,
                                                         gint n_formats,
                                                         ...);

Set the formats query result fields in query. The number of formats passed must be equal to n_formats.

gst_query_set_formatsv ()

void                gst_query_set_formatsv              (GstQuery *query,
                                                         gint n_formats,
                                                         const GstFormat *formats);

Set the formats query result fields in query. The number of formats passed in the formats array must be equal to n_formats.

gst_query_parse_n_formats ()

void                gst_query_parse_n_formats           (GstQuery *query,
                                                         guint *n_formats);

Parse the number of formats in the formats query.

gst_query_parse_nth_format ()

void                gst_query_parse_nth_format          (GstQuery *query,
                                                         guint nth,
                                                         GstFormat *format);

Parse the format query and retrieve the nth format from it into format. If the list contains less elements than nth, format will be set to GST_FORMAT_UNDEFINED.

gst_query_new_segment ()

GstQuery *          gst_query_new_segment               (GstFormat format);

Constructs a new segment query object. Use gst_query_unref() when done with it. A segment query is used to discover information about the currently configured segment for playback.

Free-function: gst_query_unref

gst_query_set_segment ()

void                gst_query_set_segment               (GstQuery *query,
                                                         gdouble rate,
                                                         GstFormat format,
                                                         gint64 start_value,
                                                         gint64 stop_value);

Answer a segment query by setting the requested values. The normal playback segment of a pipeline is 0 to duration at the default rate of 1.0. If a seek was performed on the pipeline to play a different segment, this query will return the range specified in the last seek.

start_value and stop_value will respectively contain the configured playback range start and stop values expressed in format. The values are always between 0 and the duration of the media and start_value <= stop_value. rate will contain the playback rate. For negative rates, playback will actually happen from stop_value to start_value.

gst_query_parse_segment ()

void                gst_query_parse_segment             (GstQuery *query,
                                                         gdouble *rate,
                                                         GstFormat *format,
                                                         gint64 *start_value,
                                                         gint64 *stop_value);

Parse a segment query answer. Any of rate, format, start_value, and stop_value may be NULL, which will cause this value to be omitted.

See gst_query_set_segment() for an explanation of the function arguments.

gst_query_new_caps ()

GstQuery *          gst_query_new_caps                  (GstCaps *filter);

Constructs a new query object for querying the caps.

The CAPS query should return the allowable caps for a pad in the context of the element's state, its link to other elements, and the devices or files it has opened. These caps must be a subset of the pad template caps. In the NULL state with no links, the CAPS query should ideally return the same caps as the pad template. In rare circumstances, an object property can affect the caps returned by the CAPS query, but this is discouraged.

For most filters, the caps returned by CAPS query is directly affected by the allowed caps on other pads. For demuxers and decoders, the caps returned by the srcpad's getcaps function is directly related to the stream data. Again, the CAPS query should return the most specific caps it reasonably can, since this helps with autoplugging.

The filter is used to restrict the result caps, only the caps matching filter should be returned from the CAPS query. Specifying a filter might greatly reduce the amount of processing an element needs to do.

Free-function: gst_query_unref

gst_query_parse_caps ()

void                gst_query_parse_caps                (GstQuery *query,
                                                         GstCaps **filter);

Get the filter from the caps query. The caps remains valid as long as query remains valid.

gst_query_set_caps_result ()

void                gst_query_set_caps_result           (GstQuery *query,
                                                         GstCaps *caps);

Set the caps result in query.

gst_query_parse_caps_result ()

void                gst_query_parse_caps_result         (GstQuery *query,
                                                         GstCaps **caps);

Get the caps result from query. The caps remains valid as long as query remains valid.

gst_query_new_accept_caps ()

GstQuery *          gst_query_new_accept_caps           (GstCaps *caps);

Constructs a new query object for querying if caps are accepted.

Free-function: gst_query_unref

gst_query_parse_accept_caps ()

void                gst_query_parse_accept_caps         (GstQuery *query,
                                                         GstCaps **caps);

Get the caps from query. The caps remains valid as long as query remains valid.

gst_query_set_accept_caps_result ()

void                gst_query_set_accept_caps_result    (GstQuery *query,
                                                         gboolean result);

Set result as the result for the query.

gst_query_parse_accept_caps_result ()

void                gst_query_parse_accept_caps_result  (GstQuery *query,
                                                         gboolean *result);

Parse the result from query and store in result.

enum GstBufferingMode

typedef enum {
  GST_BUFFERING_STREAM,
  GST_BUFFERING_DOWNLOAD,
  GST_BUFFERING_TIMESHIFT,
  GST_BUFFERING_LIVE
} GstBufferingMode;

The different types of buffering methods.

gst_query_new_buffering ()

GstQuery *          gst_query_new_buffering             (GstFormat format);

Constructs a new query object for querying the buffering status of a stream.

Free-function: gst_query_unref

gst_query_set_buffering_percent ()

void                gst_query_set_buffering_percent     (GstQuery *query,
                                                         gboolean busy,
                                                         gint percent);

Set the percentage of buffered data. This is a value between 0 and 100. The busy indicator is TRUE when the buffering is in progress.

gst_query_parse_buffering_percent ()

void                gst_query_parse_buffering_percent   (GstQuery *query,
                                                         gboolean *busy,
                                                         gint *percent);

Get the percentage of buffered data. This is a value between 0 and 100. The busy indicator is TRUE when the buffering is in progress.

gst_query_set_buffering_stats ()

void                gst_query_set_buffering_stats       (GstQuery *query,
                                                         GstBufferingMode mode,
                                                         gint avg_in,
                                                         gint avg_out,
                                                         gint64 buffering_left);

Configures the buffering stats values in query.

gst_query_parse_buffering_stats ()

void                gst_query_parse_buffering_stats     (GstQuery *query,
                                                         GstBufferingMode *mode,
                                                         gint *avg_in,
                                                         gint *avg_out,
                                                         gint64 *buffering_left);

Extracts the buffering stats values from query.

gst_query_set_buffering_range ()

void                gst_query_set_buffering_range       (GstQuery *query,
                                                         GstFormat format,
                                                         gint64 start,
                                                         gint64 stop,
                                                         gint64 estimated_total);

Set the available query result fields in query.

gst_query_parse_buffering_range ()

void                gst_query_parse_buffering_range     (GstQuery *query,
                                                         GstFormat *format,
                                                         gint64 *start,
                                                         gint64 *stop,
                                                         gint64 *estimated_total);

Parse an available query, writing the format into format, and other results into the passed parameters, if the respective parameters are non-NULL

gst_query_add_buffering_range ()

gboolean            gst_query_add_buffering_range       (GstQuery *query,
                                                         gint64 start,
                                                         gint64 stop);

Set the buffering-ranges array field in query. The current last start position of the array should be inferior to start.

gst_query_get_n_buffering_ranges ()

guint               gst_query_get_n_buffering_ranges    (GstQuery *query);

Retrieve the number of values currently stored in the buffered-ranges array of the query's structure.

gst_query_parse_nth_buffering_range ()

gboolean            gst_query_parse_nth_buffering_range (GstQuery *query,
                                                         guint index,
                                                         gint64 *start,
                                                         gint64 *stop);

Parse an available query and get the start and stop values stored at the index of the buffered ranges array.

gst_query_new_uri ()

GstQuery *          gst_query_new_uri                   (void);

Constructs a new query URI query object. Use gst_query_unref() when done with it. An URI query is used to query the current URI that is used by the source or sink.

Free-function: gst_query_unref

gst_query_parse_uri ()

void                gst_query_parse_uri                 (GstQuery *query,
                                                         gchar **uri);

Parse an URI query, writing the URI into uri as a newly allocated string, if the respective parameters are non-NULL. Free the string with g_free() after usage.

gst_query_set_uri ()

void                gst_query_set_uri                   (GstQuery *query,
                                                         const gchar *uri);

Answer a URI query by setting the requested URI.

gst_query_new_allocation ()

GstQuery *          gst_query_new_allocation            (GstCaps *caps,
                                                         gboolean need_pool);

Constructs a new query object for querying the allocation properties.

Free-function: gst_query_unref

gst_query_parse_allocation ()

void                gst_query_parse_allocation          (GstQuery *query,
                                                         GstCaps **caps,
                                                         gboolean *need_pool);

Parse an allocation query, writing the requested caps in caps and whether a pool is needed in need_pool, if the respective parameters are non-NULL.

gst_query_add_allocation_pool ()

void                gst_query_add_allocation_pool       (GstQuery *query,
                                                         GstBufferPool *pool,
                                                         guint size,
                                                         guint min_buffers,
                                                         guint max_buffers);

Set the pool parameters in query.

gst_query_get_n_allocation_pools ()

guint               gst_query_get_n_allocation_pools    (GstQuery *query);

Retrieve the number of values currently stored in the pool array of the query's structure.

gst_query_parse_nth_allocation_pool ()

void                gst_query_parse_nth_allocation_pool (GstQuery *query,
                                                         guint index,
                                                         GstBufferPool **pool,
                                                         guint *size,
                                                         guint *min_buffers,
                                                         guint *max_buffers);

Get the pool parameters in query.

Unref pool with gst_object_unref() when it's not needed any more.

gst_query_set_nth_allocation_pool ()

void                gst_query_set_nth_allocation_pool   (GstQuery *query,
                                                         guint index,
                                                         GstBufferPool *pool,
                                                         guint size,
                                                         guint min_buffers,
                                                         guint max_buffers);

Set the pool parameters in query.

gst_query_remove_nth_allocation_pool ()

void                gst_query_remove_nth_allocation_pool
                                                        (GstQuery *query,
                                                         guint index);

Remove the allocation pool at index of the allocation pool array.

Since 1.2

gst_query_add_allocation_param ()

void                gst_query_add_allocation_param      (GstQuery *query,
                                                         GstAllocator *allocator,
                                                         const GstAllocationParams *params);

Add allocator and its params as a supported memory allocator.

gst_query_get_n_allocation_params ()

guint               gst_query_get_n_allocation_params   (GstQuery *query);

Retrieve the number of values currently stored in the allocator params array of the query's structure.

If no memory allocator is specified, the downstream element can handle the default memory allocator. The first memory allocator in the query should be generic and allow mapping to system memory, all following allocators should be ordered by preference with the preferred one first.

gst_query_parse_nth_allocation_param ()

void                gst_query_parse_nth_allocation_param
                                                        (GstQuery *query,
                                                         guint index,
                                                         GstAllocator **allocator,
                                                         GstAllocationParams *params);

Parse an available query and get the alloctor and its params at index of the allocator array.

gst_query_set_nth_allocation_param ()

void                gst_query_set_nth_allocation_param  (GstQuery *query,
                                                         guint index,
                                                         GstAllocator *allocator,
                                                         const GstAllocationParams *params);

Parse an available query and get the alloctor and its params at index of the allocator array.

gst_query_remove_nth_allocation_param ()

void                gst_query_remove_nth_allocation_param
                                                        (GstQuery *query,
                                                         guint index);

Remove the allocation param at index of the allocation param array.

Since 1.2

gst_query_add_allocation_meta ()

void                gst_query_add_allocation_meta       (GstQuery *query,
                                                         GType api,
                                                         const GstStructure *params);

Add api with params as one of the supported metadata API to query.

gst_query_get_n_allocation_metas ()

guint               gst_query_get_n_allocation_metas    (GstQuery *query);

Retrieve the number of values currently stored in the meta API array of the query's structure.

gst_query_parse_nth_allocation_meta ()

GType               gst_query_parse_nth_allocation_meta (GstQuery *query,
                                                         guint index,
                                                         const GstStructure **params);

Parse an available query and get the metadata API at index of the metadata API array.

gst_query_remove_nth_allocation_meta ()

void                gst_query_remove_nth_allocation_meta
                                                        (GstQuery *query,
                                                         guint index);

Remove the metadata API at index of the metadata API array.

gst_query_find_allocation_meta ()

gboolean            gst_query_find_allocation_meta      (GstQuery *query,
                                                         GType api,
                                                         guint *index);

Check if query has metadata api set. When this function returns TRUE, index will contain the index where the requested API and the flags can be found.

enum GstSchedulingFlags

typedef enum {
  GST_SCHEDULING_FLAG_SEEKABLE          = (1 << 0),
  GST_SCHEDULING_FLAG_SEQUENTIAL        = (1 << 1),
  GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED = (1 << 2)
} GstSchedulingFlags;

The different scheduling flags.

gst_query_new_scheduling ()

GstQuery *          gst_query_new_scheduling            (void);

Constructs a new query object for querying the scheduling properties.

Free-function: gst_query_unref

gst_query_parse_scheduling ()

void                gst_query_parse_scheduling          (GstQuery *query,
                                                         GstSchedulingFlags *flags,
                                                         gint *minsize,
                                                         gint *maxsize,
                                                         gint *align);

Set the scheduling properties.

gst_query_set_scheduling ()

void                gst_query_set_scheduling            (GstQuery *query,
                                                         GstSchedulingFlags flags,
                                                         gint minsize,
                                                         gint maxsize,
                                                         gint align);

Set the scheduling properties.

gst_query_add_scheduling_mode ()

void                gst_query_add_scheduling_mode       (GstQuery *query,
                                                         GstPadMode mode);

Add mode as aone of the supported scheduling modes to query.

gst_query_get_n_scheduling_modes ()

guint               gst_query_get_n_scheduling_modes    (GstQuery *query);

Retrieve the number of values currently stored in the scheduling mode array of the query's structure.

gst_query_parse_nth_scheduling_mode ()

GstPadMode          gst_query_parse_nth_scheduling_mode (GstQuery *query,
                                                         guint index);

Parse an available query and get the scheduling mode at index of the scheduling modes array.

gst_query_has_scheduling_mode ()

gboolean            gst_query_has_scheduling_mode       (GstQuery *query,
                                                         GstPadMode mode);

Check if query has scheduling mode set.

gst_query_has_scheduling_mode_with_flags ()

gboolean            gst_query_has_scheduling_mode_with_flags
                                                        (GstQuery *query,
                                                         GstPadMode mode,
                                                         GstSchedulingFlags flags);

Check if query has scheduling mode set and flags is set in query scheduling flags.

gst_query_new_drain ()

GstQuery *          gst_query_new_drain                 (void);

Constructs a new query object for querying the drain state.

Free-function: gst_query_unref

gst_query_new_context ()

GstQuery *          gst_query_new_context               (void);

Constructs a new query object for querying the pipeline-local context.

Free-function: gst_query_unref

Since 1.2

gst_query_set_context ()

void                gst_query_set_context               (GstQuery *query,
                                                         GstContext *context);

Answer a context query by setting the requested context.

Since 1.2

gst_query_parse_context ()

void                gst_query_parse_context             (GstQuery *query,
                                                         GstContext **context);

Get the context from the context query. The context remains valid as long as query remains valid.

Since 1.2

gst_query_add_context_type ()

void                gst_query_add_context_type          (GstQuery *query,
                                                         const gchar *context_type);

Add a new context type to query.

Since 1.2

gst_query_get_n_context_types ()

guint               gst_query_get_n_context_types       (GstQuery *query);

Retrieve the number of values currently stored in the context-types array of the query's structure.

Since 1.2

gst_query_parse_nth_context_type ()

gboolean            gst_query_parse_nth_context_type    (GstQuery *query,
                                                         guint i,
                                                         const gchar **context_type);

Parse a context type from an existing GST_QUERY_CONTEXT query from index.

Since 1.2

gst_query_has_context_type ()

gboolean            gst_query_has_context_type          (GstQuery *query,
                                                         const gchar *context_type);

Check if query is asking for context_type.

Since 1.2