/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2000 Wim Taymans <wim.taymans@chello.be>

 *                    2005 Wim Taymans <wim@fluendo.com>

 *

 * gstquery.c: GstQueryType registration and Query parsing/creation

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstquery

 * @title: GstQuery

 * @short_description: Provide functions to create queries, and to set and parse

 *                     values in them.

 * @see_also: #GstPad, #GstElement

 *

 * Queries can be performed on pads (gst_pad_query()) and elements

 * (gst_element_query()). Please note that some queries might need a running

 * pipeline to work.

 *

 * Queries can be created using the gst_query_new_*() functions.

 * Query values can be set using gst_query_set_*(), and parsed using

 * gst_query_parse_*() helpers.

 *

 * The following example shows how to query the duration of a pipeline:

 * |[

 *   GstQuery *query;

 *   gboolean res;

 *   query = gst_query_new_duration (GST_FORMAT_TIME);

 *   res = gst_element_query (pipeline, query);

 *   if (res) {

 *     gint64 duration;

 *     gst_query_parse_duration (query, NULL, &duration);

 *     g_print ("duration = %"GST_TIME_FORMAT, GST_TIME_ARGS (duration));

 *   } else {

 *     g_print ("duration query failed...");

 *   }

 *   gst_query_unref (query);

 * ]|

 */

#include "gst_private.h"

#include "gstinfo.h"

#include "gstquery.h"

#include "gstvalue.h"

#include "gstenumtypes.h"

#include "gstquark.h"

#include "gsturi.h"

#include "gstbufferpool.h"

GST_DEBUG_CATEGORY_STATIC (gst_query_debug);

#define GST_CAT_DEFAULT gst_query_debug

GType _gst_query_type = 0;

typedef struct

{

  GstQuery query;

  GstStructure *structure;

} GstQueryImpl;

#define GST_QUERY_STRUCTURE(q)  (((GstQueryImpl *)(q))->structure)

typedef struct

{

  const gint type;

  const gchar *name;

  GQuark quark;

} GstQueryQuarks;

static GstQueryQuarks query_quarks[] = {

  {GST_QUERY_UNKNOWN, "unknown", 0},

  {GST_QUERY_POSITION, "position", 0},

  {GST_QUERY_DURATION, "duration", 0},

  {GST_QUERY_LATENCY, "latency", 0},

  {GST_QUERY_JITTER, "jitter", 0},

  {GST_QUERY_RATE, "rate", 0},

  {GST_QUERY_SEEKING, "seeking", 0},

  {GST_QUERY_SEGMENT, "segment", 0},

  {GST_QUERY_CONVERT, "convert", 0},

  {GST_QUERY_FORMATS, "formats", 0},

  {GST_QUERY_BUFFERING, "buffering", 0},

  {GST_QUERY_CUSTOM, "custom", 0},

  {GST_QUERY_URI, "uri", 0},

  {GST_QUERY_ALLOCATION, "allocation", 0},

  {GST_QUERY_SCHEDULING, "scheduling", 0},

  {GST_QUERY_ACCEPT_CAPS, "accept-caps", 0},

  {GST_QUERY_CAPS, "caps", 0},

  {GST_QUERY_DRAIN, "drain", 0},

  {GST_QUERY_CONTEXT, "context", 0},

  {0, NULL, 0}

};

GST_DEFINE_MINI_OBJECT_TYPE (GstQuery, gst_query);

void

_priv_gst_query_initialize (void)

{

  gint i;

  _gst_query_type = gst_query_get_type ();

  GST_DEBUG_CATEGORY_INIT (gst_query_debug, "query", 0, "query system");

  for (i = 0; query_quarks[i].name; i++) {

    query_quarks[i].quark = g_quark_from_static_string (query_quarks[i].name);

  }

}

/**

 * gst_query_type_get_name:

 * @type: the query type

 *

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

 *

 * Returns: a reference to the static name of the query.

 */

const gchar *

gst_query_type_get_name (GstQueryType type)

{

  gint i;

  for (i = 0; query_quarks[i].name; i++) {

    if (type == query_quarks[i].type)

      return query_quarks[i].name;

  }

  return "unknown";

}

/**

 * gst_query_type_to_quark:

 * @type: the query type

 *

 * Get the unique quark for the given query type.

 *

 * Returns: the quark associated with the query type

 */

GQuark

gst_query_type_to_quark (GstQueryType type)

{

  gint i;

  for (i = 0; query_quarks[i].name; i++) {

    if (type == query_quarks[i].type)

      return query_quarks[i].quark;

  }

  return 0;

}

/**

 * gst_query_type_get_flags:

 * @type: a #GstQueryType

 *

 * Gets the #GstQueryTypeFlags associated with @type.

 *

 * Returns: a #GstQueryTypeFlags.

 */

GstQueryTypeFlags

gst_query_type_get_flags (GstQueryType type)

{

  GstQueryTypeFlags ret;

  ret = type & ((1 << GST_QUERY_NUM_SHIFT) - 1);

  return ret;

}

static void

_gst_query_free (GstQuery * query)

{

  GstStructure *s;

  g_return_if_fail (query != NULL);

  s = GST_QUERY_STRUCTURE (query);

  if (s) {

    gst_structure_set_parent_refcount (s, NULL);

    gst_structure_free (s);

  }

  g_slice_free1 (sizeof (GstQueryImpl), query);

}

static GstQuery *

_gst_query_copy (GstQuery * query)

{

  GstQuery *copy;

  GstStructure *s;

  s = GST_QUERY_STRUCTURE (query);

  if (s) {

    s = gst_structure_copy (s);

  }

  copy = gst_query_new_custom (query->type, s);

  return copy;

}

/**

 * gst_query_new_position:

 * @format: the default #GstFormat for the new query

 *

 * 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()

 *

 * Returns: (transfer full): a new #GstQuery

 */

GstQuery *

gst_query_new_position (GstFormat format)

{

  GstQuery *query;

  GstStructure *structure;

  structure = gst_structure_new_id (GST_QUARK (QUERY_POSITION),

      GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,

      GST_QUARK (CURRENT), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);

  query = gst_query_new_custom (GST_QUERY_POSITION, structure);

  return query;

}

/**

 * gst_query_set_position:

 * @query: a #GstQuery with query type GST_QUERY_POSITION

 * @format: the requested #GstFormat

 * @cur: the position to set

 *

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

 */

void

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

{

  GstStructure *s;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_POSITION);

  s = GST_QUERY_STRUCTURE (query);

  g_return_if_fail (format == g_value_get_enum (gst_structure_id_get_value (s,

              GST_QUARK (FORMAT))));

  gst_structure_id_set (s,

      GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,

      GST_QUARK (CURRENT), G_TYPE_INT64, cur, NULL);

}

/**

 * gst_query_parse_position:

 * @query: a #GstQuery

 * @format: (out) (allow-none): the storage for the #GstFormat of the

 *     position values (may be %NULL)

 * @cur: (out) (allow-none): the storage for the current position (may be %NULL)

 *

 * Parse a position query, writing the format into @format, and the position

 * into @cur, if the respective parameters are non-%NULL.

 */

void

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

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_POSITION);

  structure = GST_QUERY_STRUCTURE (query);

  if (format)

    *format =

        (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,

            GST_QUARK (FORMAT)));

  if (cur)

    *cur = g_value_get_int64 (gst_structure_id_get_value (structure,

            GST_QUARK (CURRENT)));

}

/**

 * gst_query_new_duration:

 * @format: the #GstFormat for this duration query

 *

 * 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()

 *

 * Returns: (transfer full): a new #GstQuery

 */

GstQuery *

gst_query_new_duration (GstFormat format)

{

  GstQuery *query;

  GstStructure *structure;

  structure = gst_structure_new_id (GST_QUARK (QUERY_DURATION),

      GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,

      GST_QUARK (DURATION), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);

  query = gst_query_new_custom (GST_QUERY_DURATION, structure);

  return query;

}

/**

 * gst_query_set_duration:

 * @query: a #GstQuery

 * @format: the #GstFormat for the duration

 * @duration: the duration of the stream

 *

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

 */

void

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

{

  GstStructure *s;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_DURATION);

  s = GST_QUERY_STRUCTURE (query);

  g_return_if_fail (format == g_value_get_enum (gst_structure_id_get_value (s,

              GST_QUARK (FORMAT))));

  gst_structure_id_set (s, GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,

      GST_QUARK (DURATION), G_TYPE_INT64, duration, NULL);

}

/**

 * gst_query_parse_duration:

 * @query: a #GstQuery

 * @format: (out) (allow-none): the storage for the #GstFormat of the duration

 *     value, or %NULL.

 * @duration: (out) (allow-none): the storage for the total duration, or %NULL.

 *

 * 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.

 */

void

gst_query_parse_duration (GstQuery * query, GstFormat * format,

    gint64 * duration)

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_DURATION);

  structure = GST_QUERY_STRUCTURE (query);

  if (format)

    *format =

        (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,

            GST_QUARK (FORMAT)));

  if (duration)

    *duration = g_value_get_int64 (gst_structure_id_get_value (structure,

            GST_QUARK (DURATION)));

}

/**

 * gst_query_new_latency:

 *

 * 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()

 *

 * Returns: (transfer full): a #GstQuery

 */

GstQuery *

gst_query_new_latency (void)

{

  GstQuery *query;

  GstStructure *structure;

  structure = gst_structure_new_id (GST_QUARK (QUERY_LATENCY),

      GST_QUARK (LIVE), G_TYPE_BOOLEAN, FALSE,

      GST_QUARK (MIN_LATENCY), G_TYPE_UINT64, G_GUINT64_CONSTANT (0),

      GST_QUARK (MAX_LATENCY), G_TYPE_UINT64, GST_CLOCK_TIME_NONE, NULL);

  query = gst_query_new_custom (GST_QUERY_LATENCY, structure);

  return query;

}

/**

 * gst_query_set_latency:

 * @query: a #GstQuery

 * @live: if there is a live element upstream

 * @min_latency: the minimal latency of the upstream elements

 * @max_latency: the maximal latency of the upstream elements

 *

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

 */

void

gst_query_set_latency (GstQuery * query, gboolean live,

    GstClockTime min_latency, GstClockTime max_latency)

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_LATENCY);

  g_return_if_fail (GST_CLOCK_TIME_IS_VALID (min_latency));

  structure = GST_QUERY_STRUCTURE (query);

  gst_structure_id_set (structure,

      GST_QUARK (LIVE), G_TYPE_BOOLEAN, live,

      GST_QUARK (MIN_LATENCY), G_TYPE_UINT64, min_latency,

      GST_QUARK (MAX_LATENCY), G_TYPE_UINT64, max_latency, NULL);

}

/**

 * gst_query_parse_latency:

 * @query: a #GstQuery

 * @live: (out) (allow-none): storage for live or %NULL

 * @min_latency: (out) (allow-none): the storage for the min latency or %NULL

 * @max_latency: (out) (allow-none): the storage for the max latency or %NULL

 *

 * Parse a latency query answer.

 */

void

gst_query_parse_latency (GstQuery * query, gboolean * live,

    GstClockTime * min_latency, GstClockTime * max_latency)

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_LATENCY);

  structure = GST_QUERY_STRUCTURE (query);

  if (live)

    *live =

        g_value_get_boolean (gst_structure_id_get_value (structure,

            GST_QUARK (LIVE)));

  if (min_latency)

    *min_latency = g_value_get_uint64 (gst_structure_id_get_value (structure,

            GST_QUARK (MIN_LATENCY)));

  if (max_latency)

    *max_latency = g_value_get_uint64 (gst_structure_id_get_value (structure,

            GST_QUARK (MAX_LATENCY)));

}

/**

 * gst_query_new_convert:

 * @src_format: the source #GstFormat for the new query

 * @value: the value to convert

 * @dest_format: the target #GstFormat

 *

 * 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()

 *

 * Returns: (transfer full): a #GstQuery

 */

GstQuery *

gst_query_new_convert (GstFormat src_format, gint64 value,

    GstFormat dest_format)

{

  GstQuery *query;

  GstStructure *structure;

  structure = gst_structure_new_id (GST_QUARK (QUERY_CONVERT),

      GST_QUARK (SRC_FORMAT), GST_TYPE_FORMAT, src_format,

      GST_QUARK (SRC_VALUE), G_TYPE_INT64, value,

      GST_QUARK (DEST_FORMAT), GST_TYPE_FORMAT, dest_format,

      GST_QUARK (DEST_VALUE), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);

  query = gst_query_new_custom (GST_QUERY_CONVERT, structure);

  return query;

}

/**

 * gst_query_set_convert:

 * @query: a #GstQuery

 * @src_format: the source #GstFormat

 * @src_value: the source value

 * @dest_format: the destination #GstFormat

 * @dest_value: the destination value

 *

 * Answer a convert query by setting the requested values.

 */

void

gst_query_set_convert (GstQuery * query, GstFormat src_format, gint64 src_value,

    GstFormat dest_format, gint64 dest_value)

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONVERT);

  structure = GST_QUERY_STRUCTURE (query);

  gst_structure_id_set (structure,

      GST_QUARK (SRC_FORMAT), GST_TYPE_FORMAT, src_format,

      GST_QUARK (SRC_VALUE), G_TYPE_INT64, src_value,

      GST_QUARK (DEST_FORMAT), GST_TYPE_FORMAT, dest_format,

      GST_QUARK (DEST_VALUE), G_TYPE_INT64, dest_value, NULL);

}

/**

 * gst_query_parse_convert:

 * @query: a #GstQuery

 * @src_format: (out) (allow-none): the storage for the #GstFormat of the

 *     source value, or %NULL

 * @src_value: (out) (allow-none): the storage for the source value, or %NULL

 * @dest_format: (out) (allow-none): the storage for the #GstFormat of the

 *     destination value, or %NULL

 * @dest_value: (out) (allow-none): the storage for the destination value,

 *     or %NULL

 *

 * 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.

 */

void

gst_query_parse_convert (GstQuery * query, GstFormat * src_format,

    gint64 * src_value, GstFormat * dest_format, gint64 * dest_value)

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONVERT);

  structure = GST_QUERY_STRUCTURE (query);

  if (src_format)

    *src_format =

        (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,

            GST_QUARK (SRC_FORMAT)));

  if (src_value)

    *src_value = g_value_get_int64 (gst_structure_id_get_value (structure,

            GST_QUARK (SRC_VALUE)));

  if (dest_format)

    *dest_format =

        (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,

            GST_QUARK (DEST_FORMAT)));

  if (dest_value)

    *dest_value = g_value_get_int64 (gst_structure_id_get_value (structure,

            GST_QUARK (DEST_VALUE)));

}

/**

 * gst_query_new_segment:

 * @format: the #GstFormat for the new query

 *

 * 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()

 *

 * Returns: (transfer full): a new #GstQuery

 */

GstQuery *

gst_query_new_segment (GstFormat format)

{

  GstQuery *query;

  GstStructure *structure;

  structure = gst_structure_new_id (GST_QUARK (QUERY_SEGMENT),

      GST_QUARK (RATE), G_TYPE_DOUBLE, (gdouble) 0.0,

      GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,

      GST_QUARK (START_VALUE), G_TYPE_INT64, G_GINT64_CONSTANT (-1),

      GST_QUARK (STOP_VALUE), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);

  query = gst_query_new_custom (GST_QUERY_SEGMENT, structure);

  return query;

}

/**

 * gst_query_set_segment:

 * @query: a #GstQuery

 * @rate: the rate of the segment

 * @format: the #GstFormat of the segment values (@start_value and @stop_value)

 * @start_value: the start value

 * @stop_value: the 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.

 */

void

gst_query_set_segment (GstQuery * query, gdouble rate, GstFormat format,

    gint64 start_value, gint64 stop_value)

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SEGMENT);

  structure = GST_QUERY_STRUCTURE (query);

  gst_structure_id_set (structure,

      GST_QUARK (RATE), G_TYPE_DOUBLE, rate,

      GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,

      GST_QUARK (START_VALUE), G_TYPE_INT64, start_value,

      GST_QUARK (STOP_VALUE), G_TYPE_INT64, stop_value, NULL);

}

/**

 * gst_query_parse_segment:

 * @query: a #GstQuery

 * @rate: (out) (allow-none): the storage for the rate of the segment, or %NULL

 * @format: (out) (allow-none): the storage for the #GstFormat of the values,

 *     or %NULL

 * @start_value: (out) (allow-none): the storage for the start value, or %NULL

 * @stop_value: (out) (allow-none): the storage for the stop value, or %NULL

 *

 * 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.

 */

void

gst_query_parse_segment (GstQuery * query, gdouble * rate, GstFormat * format,

    gint64 * start_value, gint64 * stop_value)

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SEGMENT);

  structure = GST_QUERY_STRUCTURE (query);

  if (rate)

    *rate = g_value_get_double (gst_structure_id_get_value (structure,

            GST_QUARK (RATE)));

  if (format)

    *format =

        (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,

            GST_QUARK (FORMAT)));

  if (start_value)

    *start_value = g_value_get_int64 (gst_structure_id_get_value (structure,

            GST_QUARK (START_VALUE)));

  if (stop_value)

    *stop_value = g_value_get_int64 (gst_structure_id_get_value (structure,

            GST_QUARK (STOP_VALUE)));

}

/**

 * gst_query_new_custom:

 * @type: the query type

 * @structure: (allow-none) (transfer full): a structure for the query

 *

 * Constructs a new custom query object. Use gst_query_unref()

 * when done with it.

 *

 * Free-function: gst_query_unref()

 *

 * Returns: (transfer full) (nullable): a new #GstQuery

 */

GstQuery *

gst_query_new_custom (GstQueryType type, GstStructure * structure)

{

  GstQueryImpl *query;

  query = g_slice_new0 (GstQueryImpl);

  GST_DEBUG ("creating new query %p %s", query, gst_query_type_get_name (type));

  if (structure) {

    /* structure must not have a parent */

    if (!gst_structure_set_parent_refcount (structure,

            &query->query.mini_object.refcount))

      goto had_parent;

  }

  gst_mini_object_init (GST_MINI_OBJECT_CAST (query), 0, _gst_query_type,

      (GstMiniObjectCopyFunction) _gst_query_copy, NULL,

      (GstMiniObjectFreeFunction) _gst_query_free);

  GST_QUERY_TYPE (query) = type;

  GST_QUERY_STRUCTURE (query) = structure;

  return GST_QUERY_CAST (query);

  /* ERRORS */

had_parent:

  {

    g_slice_free1 (sizeof (GstQueryImpl), query);

    g_warning ("structure is already owned by another object");

    return NULL;

  }

}

/**

 * gst_query_get_structure:

 * @query: a #GstQuery

 *

 * Get the structure of a query.

 *

 * Returns: (transfer none) (nullable): the #GstStructure of the query. The

 *     structure is still owned by the query and will therefore be freed when the

 *     query is unreffed.

 */

const GstStructure *

gst_query_get_structure (GstQuery * query)

{

  g_return_val_if_fail (GST_IS_QUERY (query), NULL);

  return GST_QUERY_STRUCTURE (query);

}

/**

 * gst_query_writable_structure:

 * @query: a #GstQuery

 *

 * Get the structure of a query. This method should be called with a writable

 * @query so that the returned structure is guaranteed to be writable.

 *

 * Returns: (transfer none): the #GstStructure of the query. The structure is

 *     still owned by the query and will therefore be freed when the query

 *     is unreffed.

 */

GstStructure *

gst_query_writable_structure (GstQuery * query)

{

  GstStructure *structure;

  g_return_val_if_fail (GST_IS_QUERY (query), NULL);

  g_return_val_if_fail (gst_query_is_writable (query), NULL);

  structure = GST_QUERY_STRUCTURE (query);

  if (structure == NULL) {

    structure =

        gst_structure_new_id_empty (gst_query_type_to_quark (GST_QUERY_TYPE

            (query)));

    gst_structure_set_parent_refcount (structure, &query->mini_object.refcount);

    GST_QUERY_STRUCTURE (query) = structure;

  }

  return structure;

}

/**

 * gst_query_new_seeking:

 * @format: the default #GstFormat for the new query

 *

 * Constructs a new query object for querying seeking properties of

 * the stream.

 *

 * Free-function: gst_query_unref()

 *

 * Returns: (transfer full): a new #GstQuery

 */

GstQuery *

gst_query_new_seeking (GstFormat format)

{

  GstQuery *query;

  GstStructure *structure;

  structure = gst_structure_new_id (GST_QUARK (QUERY_SEEKING),

      GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,

      GST_QUARK (SEEKABLE), G_TYPE_BOOLEAN, FALSE,

      GST_QUARK (SEGMENT_START), G_TYPE_INT64, G_GINT64_CONSTANT (-1),

      GST_QUARK (SEGMENT_END), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);

  query = gst_query_new_custom (GST_QUERY_SEEKING, structure);

  return query;

}

/**

 * gst_query_set_seeking:

 * @query: a #GstQuery

 * @format: the format to set for the @segment_start and @segment_end values

 * @seekable: the seekable flag to set

 * @segment_start: the segment_start to set

 * @segment_end: the segment_end to set

 *

 * Set the seeking query result fields in @query.

 */

void

gst_query_set_seeking (GstQuery * query, GstFormat format,

    gboolean seekable, gint64 segment_start, gint64 segment_end)

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SEEKING);

  g_return_if_fail (gst_query_is_writable (query));

  structure = GST_QUERY_STRUCTURE (query);

  gst_structure_id_set (structure,

      GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,

      GST_QUARK (SEEKABLE), G_TYPE_BOOLEAN, seekable,

      GST_QUARK (SEGMENT_START), G_TYPE_INT64, segment_start,

      GST_QUARK (SEGMENT_END), G_TYPE_INT64, segment_end, NULL);

}

/**

 * gst_query_parse_seeking:

 * @query: a GST_QUERY_SEEKING type query #GstQuery

 * @format: (out) (allow-none): the format to set for the @segment_start

 *     and @segment_end values, or %NULL

 * @seekable: (out) (allow-none): the seekable flag to set, or %NULL

 * @segment_start: (out) (allow-none): the segment_start to set, or %NULL

 * @segment_end: (out) (allow-none): the segment_end to set, or %NULL

 *

 * Parse a seeking query, writing the format into @format, and

 * other results into the passed parameters, if the respective parameters

 * are non-%NULL

 */

void

gst_query_parse_seeking (GstQuery * query, GstFormat * format,

    gboolean * seekable, gint64 * segment_start, gint64 * segment_end)

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SEEKING);

  structure = GST_QUERY_STRUCTURE (query);

  if (format)

    *format =

        (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,

            GST_QUARK (FORMAT)));

  if (seekable)

    *seekable = g_value_get_boolean (gst_structure_id_get_value (structure,

            GST_QUARK (SEEKABLE)));

  if (segment_start)

    *segment_start = g_value_get_int64 (gst_structure_id_get_value (structure,

            GST_QUARK (SEGMENT_START)));

  if (segment_end)

    *segment_end = g_value_get_int64 (gst_structure_id_get_value (structure,

            GST_QUARK (SEGMENT_END)));

}

static GArray *

ensure_array (GstStructure * s, GQuark quark, gsize element_size,

    GDestroyNotify clear_func)

{

  GArray *array;

  const GValue *value;

  value = gst_structure_id_get_value (s, quark);

  if (value) {

    array = (GArray *) g_value_get_boxed (value);

  } else {

    GValue new_array_val = { 0, };

    array = g_array_new (FALSE, TRUE, element_size);

    if (clear_func)

      g_array_set_clear_func (array, clear_func);

    g_value_init (&new_array_val, G_TYPE_ARRAY);

    g_value_take_boxed (&new_array_val, array);

    gst_structure_id_take_value (s, quark, &new_array_val);

  }

  return array;

}

/**

 * gst_query_new_formats:

 *

 * Constructs a new query object for querying formats of

 * the stream.

 *

 * Free-function: gst_query_unref()

 *

 * Returns: (transfer full): a new #GstQuery

 */

GstQuery *

gst_query_new_formats (void)

{