gst/gstquery.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wim.taymans@chello.be>
   4  *                    2005 Wim Taymans <wim@fluendo.com>
   5  *
   6  * gstquery.c: GstQueryType registration and Query parsing/creation
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 /**
  25  * SECTION:gstquery
  26  * @short_description: Provide functions to create queries, and to set and parse
  27  *                     values in them.
  28  * @see_also: #GstPad, #GstElement
  29  *
  30  * Queries can be performed on pads (gst_pad_query()) and elements
  31  * (gst_element_query()). Please note that some queries might need a running
  32  * pipeline to work.
  33  *
  34  * Queries can be created using the gst_query_new_*() functions.
  35  * Query values can be set using gst_query_set_*(), and parsed using
  36  * gst_query_parse_*() helpers.
  37  *
  38  * The following example shows how to query the duration of a pipeline:
  39  * |[<!-- language="C" -->
  40  *   GstQuery *query;
  41  *   gboolean res;
  42  *   query = gst_query_new_duration (GST_FORMAT_TIME);
  43  *   res = gst_element_query (pipeline, query);
  44  *   if (res) {
  45  *     gint64 duration;
  46  *     gst_query_parse_duration (query, NULL, &amp;duration);
  47  *     g_print ("duration = %"GST_TIME_FORMAT, GST_TIME_ARGS (duration));
  48  *   } else {
  49  *     g_print ("duration query failed...");
  50  *   }
  51  *   gst_query_unref (query);
  52  * ]|
  53  */
  54
  55
  56 #include "gst_private.h"
  57 #include "gstinfo.h"
  58 #include "gstquery.h"
  59 #include "gstvalue.h"
  60 #include "gstenumtypes.h"
  61 #include "gstquark.h"
  62 #include "gsturi.h"
  63 #include "gstbufferpool.h"
  64
  65 GST_DEBUG_CATEGORY_STATIC (gst_query_debug);
  66 #define GST_CAT_DEFAULT gst_query_debug
  67
  68 GType _gst_query_type = 0;
  69
  70 typedef struct
  71 {
  72   GstQuery query;
  73
  74   GstStructure *structure;
  75 } GstQueryImpl;
  76
  77 #define GST_QUERY_STRUCTURE(q)  (((GstQueryImpl *)(q))->structure)
  78
  79
  80 typedef struct
  81 {
  82   const gint type;
  83   const gchar *name;
  84   GQuark quark;
  85 } GstQueryQuarks;
  86
  87 static GstQueryQuarks query_quarks[] = {
  88   {GST_QUERY_UNKNOWN, "unknown", 0},
  89   {GST_QUERY_POSITION, "position", 0},
  90   {GST_QUERY_DURATION, "duration", 0},
  91   {GST_QUERY_LATENCY, "latency", 0},
  92   {GST_QUERY_JITTER, "jitter", 0},
  93   {GST_QUERY_RATE, "rate", 0},
  94   {GST_QUERY_SEEKING, "seeking", 0},
  95   {GST_QUERY_SEGMENT, "segment", 0},
  96   {GST_QUERY_CONVERT, "convert", 0},
  97   {GST_QUERY_FORMATS, "formats", 0},
  98   {GST_QUERY_BUFFERING, "buffering", 0},
  99   {GST_QUERY_CUSTOM, "custom", 0},
 100   {GST_QUERY_URI, "uri", 0},
 101   {GST_QUERY_ALLOCATION, "allocation", 0},
 102   {GST_QUERY_SCHEDULING, "scheduling", 0},
 103   {GST_QUERY_ACCEPT_CAPS, "accept-caps", 0},
 104   {GST_QUERY_CAPS, "caps", 0},
 105   {GST_QUERY_DRAIN, "drain", 0},
 106   {GST_QUERY_CONTEXT, "context", 0},
 107
 108   {0, NULL, 0}
 109 };
 110
 111 GST_DEFINE_MINI_OBJECT_TYPE (GstQuery, gst_query);
 112
 113 void
 114 _priv_gst_query_initialize (void)
 115 {
 116   gint i;
 117
 118   _gst_query_type = gst_query_get_type ();
 119
 120   GST_DEBUG_CATEGORY_INIT (gst_query_debug, "query", 0, "query system");
 121
 122   for (i = 0; query_quarks[i].name; i++) {
 123     query_quarks[i].quark = g_quark_from_static_string (query_quarks[i].name);
 124   }
 125 }
 126
 127 /**
 128  * gst_query_type_get_name:
 129  * @type: the query type
 130  *
 131  * Get a printable name for the given query type. Do not modify or free.
 132  *
 133  * Returns: a reference to the static name of the query.
 134  */
 135 const gchar *
 136 gst_query_type_get_name (GstQueryType type)
 137 {
 138   gint i;
 139
 140   for (i = 0; query_quarks[i].name; i++) {
 141     if (type == query_quarks[i].type)
 142       return query_quarks[i].name;
 143   }
 144   return "unknown";
 145 }
 146
 147 /**
 148  * gst_query_type_to_quark:
 149  * @type: the query type
 150  *
 151  * Get the unique quark for the given query type.
 152  *
 153  * Returns: the quark associated with the query type
 154  */
 155 GQuark
 156 gst_query_type_to_quark (GstQueryType type)
 157 {
 158   gint i;
 159
 160   for (i = 0; query_quarks[i].name; i++) {
 161     if (type == query_quarks[i].type)
 162       return query_quarks[i].quark;
 163   }
 164   return 0;
 165 }
 166
 167 /**
 168  * gst_query_type_get_flags:
 169  * @type: a #GstQueryType
 170  *
 171  * Gets the #GstQueryTypeFlags associated with @type.
 172  *
 173  * Returns: a #GstQueryTypeFlags.
 174  */
 175 GstQueryTypeFlags
 176 gst_query_type_get_flags (GstQueryType type)
 177 {
 178   GstQueryTypeFlags ret;
 179
 180   ret = type & ((1 << GST_QUERY_NUM_SHIFT) - 1);
 181
 182   return ret;
 183 }
 184
 185 static void
 186 _gst_query_free (GstQuery * query)
 187 {
 188   GstStructure *s;
 189
 190   g_return_if_fail (query != NULL);
 191
 192   s = GST_QUERY_STRUCTURE (query);
 193   if (s) {
 194     gst_structure_set_parent_refcount (s, NULL);
 195     gst_structure_free (s);
 196   }
 197
 198   g_slice_free1 (sizeof (GstQueryImpl), query);
 199 }
 200
 201 static GstQuery *
 202 _gst_query_copy (GstQuery * query)
 203 {
 204   GstQuery *copy;
 205   GstStructure *s;
 206
 207   s = GST_QUERY_STRUCTURE (query);
 208   if (s) {
 209     s = gst_structure_copy (s);
 210   }
 211   copy = gst_query_new_custom (query->type, s);
 212
 213   return copy;
 214 }
 215
 216 /**
 217  * gst_query_new_position:
 218  * @format: the default #GstFormat for the new query
 219  *
 220  * Constructs a new query stream position query object. Use gst_query_unref()
 221  * when done with it. A position query is used to query the current position
 222  * of playback in the streams, in some format.
 223  *
 224  * Free-function: gst_query_unref()
 225  *
 226  * Returns: (transfer full): a new #GstQuery
 227  */
 228 GstQuery *
 229 gst_query_new_position (GstFormat format)
 230 {
 231   GstQuery *query;
 232   GstStructure *structure;
 233
 234   structure = gst_structure_new_id (GST_QUARK (QUERY_POSITION),
 235       GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
 236       GST_QUARK (CURRENT), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);
 237
 238   query = gst_query_new_custom (GST_QUERY_POSITION, structure);
 239
 240   return query;
 241 }
 242
 243 /**
 244  * gst_query_set_position:
 245  * @query: a #GstQuery with query type GST_QUERY_POSITION
 246  * @format: the requested #GstFormat
 247  * @cur: the position to set
 248  *
 249  * Answer a position query by setting the requested value in the given format.
 250  */
 251 void
 252 gst_query_set_position (GstQuery * query, GstFormat format, gint64 cur)
 253 {
 254   GstStructure *s;
 255
 256   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_POSITION);
 257
 258   s = GST_QUERY_STRUCTURE (query);
 259   g_return_if_fail (format == g_value_get_enum (gst_structure_id_get_value (s,
 260               GST_QUARK (FORMAT))));
 261
 262   gst_structure_id_set (s,
 263       GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
 264       GST_QUARK (CURRENT), G_TYPE_INT64, cur, NULL);
 265 }
 266
 267 /**
 268  * gst_query_parse_position:
 269  * @query: a #GstQuery
 270  * @format: (out) (allow-none): the storage for the #GstFormat of the
 271  *     position values (may be %NULL)
 272  * @cur: (out) (allow-none): the storage for the current position (may be %NULL)
 273  *
 274  * Parse a position query, writing the format into @format, and the position
 275  * into @cur, if the respective parameters are non-%NULL.
 276  */
 277 void
 278 gst_query_parse_position (GstQuery * query, GstFormat * format, gint64 * cur)
 279 {
 280   GstStructure *structure;
 281
 282   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_POSITION);
 283
 284   structure = GST_QUERY_STRUCTURE (query);
 285   if (format)
 286     *format =
 287         (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,
 288             GST_QUARK (FORMAT)));
 289   if (cur)
 290     *cur = g_value_get_int64 (gst_structure_id_get_value (structure,
 291             GST_QUARK (CURRENT)));
 292 }
 293
 294
 295 /**
 296  * gst_query_new_duration:
 297  * @format: the #GstFormat for this duration query
 298  *
 299  * Constructs a new stream duration query object to query in the given format.
 300  * Use gst_query_unref() when done with it. A duration query will give the
 301  * total length of the stream.
 302  *
 303  * Free-function: gst_query_unref()
 304  *
 305  * Returns: (transfer full): a new #GstQuery
 306  */
 307 GstQuery *
 308 gst_query_new_duration (GstFormat format)
 309 {
 310   GstQuery *query;
 311   GstStructure *structure;
 312
 313   structure = gst_structure_new_id (GST_QUARK (QUERY_DURATION),
 314       GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
 315       GST_QUARK (DURATION), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);
 316
 317   query = gst_query_new_custom (GST_QUERY_DURATION, structure);
 318
 319   return query;
 320 }
 321
 322 /**
 323  * gst_query_set_duration:
 324  * @query: a #GstQuery
 325  * @format: the #GstFormat for the duration
 326  * @duration: the duration of the stream
 327  *
 328  * Answer a duration query by setting the requested value in the given format.
 329  */
 330 void
 331 gst_query_set_duration (GstQuery * query, GstFormat format, gint64 duration)
 332 {
 333   GstStructure *s;
 334
 335   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_DURATION);
 336
 337   s = GST_QUERY_STRUCTURE (query);
 338   g_return_if_fail (format == g_value_get_enum (gst_structure_id_get_value (s,
 339               GST_QUARK (FORMAT))));
 340   gst_structure_id_set (s, GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
 341       GST_QUARK (DURATION), G_TYPE_INT64, duration, NULL);
 342 }
 343
 344 /**
 345  * gst_query_parse_duration:
 346  * @query: a #GstQuery
 347  * @format: (out) (allow-none): the storage for the #GstFormat of the duration
 348  *     value, or %NULL.
 349  * @duration: (out) (allow-none): the storage for the total duration, or %NULL.
 350  *
 351  * Parse a duration query answer. Write the format of the duration into @format,
 352  * and the value into @duration, if the respective variables are non-%NULL.
 353  */
 354 void
 355 gst_query_parse_duration (GstQuery * query, GstFormat * format,
 356     gint64 * duration)
 357 {
 358   GstStructure *structure;
 359
 360   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_DURATION);
 361
 362   structure = GST_QUERY_STRUCTURE (query);
 363   if (format)
 364     *format =
 365         (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,
 366             GST_QUARK (FORMAT)));
 367   if (duration)
 368     *duration = g_value_get_int64 (gst_structure_id_get_value (structure,
 369             GST_QUARK (DURATION)));
 370 }
 371
 372 /**
 373  * gst_query_new_latency:
 374  *
 375  * Constructs a new latency query object.
 376  * Use gst_query_unref() when done with it. A latency query is usually performed
 377  * by sinks to compensate for additional latency introduced by elements in the
 378  * pipeline.
 379  *
 380  * Free-function: gst_query_unref()
 381  *
 382  * Returns: (transfer full): a #GstQuery
 383  */
 384 GstQuery *
 385 gst_query_new_latency (void)
 386 {
 387   GstQuery *query;
 388   GstStructure *structure;
 389
 390   structure = gst_structure_new_id (GST_QUARK (QUERY_LATENCY),
 391       GST_QUARK (LIVE), G_TYPE_BOOLEAN, FALSE,
 392       GST_QUARK (MIN_LATENCY), G_TYPE_UINT64, G_GUINT64_CONSTANT (0),
 393       GST_QUARK (MAX_LATENCY), G_TYPE_UINT64, GST_CLOCK_TIME_NONE, NULL);
 394
 395   query = gst_query_new_custom (GST_QUERY_LATENCY, structure);
 396
 397   return query;
 398 }
 399
 400 /**
 401  * gst_query_set_latency:
 402  * @query: a #GstQuery
 403  * @live: if there is a live element upstream
 404  * @min_latency: the minimal latency of the upstream elements
 405  * @max_latency: the maximal latency of the upstream elements
 406  *
 407  * Answer a latency query by setting the requested values in the given format.
 408  */
 409 void
 410 gst_query_set_latency (GstQuery * query, gboolean live,
 411     GstClockTime min_latency, GstClockTime max_latency)
 412 {
 413   GstStructure *structure;
 414
 415   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_LATENCY);
 416   g_return_if_fail (GST_CLOCK_TIME_IS_VALID (min_latency));
 417
 418   structure = GST_QUERY_STRUCTURE (query);
 419   gst_structure_id_set (structure,
 420       GST_QUARK (LIVE), G_TYPE_BOOLEAN, live,
 421       GST_QUARK (MIN_LATENCY), G_TYPE_UINT64, min_latency,
 422       GST_QUARK (MAX_LATENCY), G_TYPE_UINT64, max_latency, NULL);
 423 }
 424
 425 /**
 426  * gst_query_parse_latency:
 427  * @query: a #GstQuery
 428  * @live: (out) (allow-none): storage for live or %NULL
 429  * @min_latency: (out) (allow-none): the storage for the min latency or %NULL
 430  * @max_latency: (out) (allow-none): the storage for the max latency or %NULL
 431  *
 432  * Parse a latency query answer.
 433  */
 434 void
 435 gst_query_parse_latency (GstQuery * query, gboolean * live,
 436     GstClockTime * min_latency, GstClockTime * max_latency)
 437 {
 438   GstStructure *structure;
 439
 440   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_LATENCY);
 441
 442   structure = GST_QUERY_STRUCTURE (query);
 443   if (live)
 444     *live =
 445         g_value_get_boolean (gst_structure_id_get_value (structure,
 446             GST_QUARK (LIVE)));
 447   if (min_latency)
 448     *min_latency = g_value_get_uint64 (gst_structure_id_get_value (structure,
 449             GST_QUARK (MIN_LATENCY)));
 450   if (max_latency)
 451     *max_latency = g_value_get_uint64 (gst_structure_id_get_value (structure,
 452             GST_QUARK (MAX_LATENCY)));
 453 }
 454
 455 /**
 456  * gst_query_new_convert:
 457  * @src_format: the source #GstFormat for the new query
 458  * @value: the value to convert
 459  * @dest_format: the target #GstFormat
 460  *
 461  * Constructs a new convert query object. Use gst_query_unref()
 462  * when done with it. A convert query is used to ask for a conversion between
 463  * one format and another.
 464  *
 465  * Free-function: gst_query_unref()
 466  *
 467  * Returns: (transfer full): a #GstQuery
 468  */
 469 GstQuery *
 470 gst_query_new_convert (GstFormat src_format, gint64 value,
 471     GstFormat dest_format)
 472 {
 473   GstQuery *query;
 474   GstStructure *structure;
 475
 476   structure = gst_structure_new_id (GST_QUARK (QUERY_CONVERT),
 477       GST_QUARK (SRC_FORMAT), GST_TYPE_FORMAT, src_format,
 478       GST_QUARK (SRC_VALUE), G_TYPE_INT64, value,
 479       GST_QUARK (DEST_FORMAT), GST_TYPE_FORMAT, dest_format,
 480       GST_QUARK (DEST_VALUE), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);
 481
 482   query = gst_query_new_custom (GST_QUERY_CONVERT, structure);
 483
 484   return query;
 485 }
 486
 487 /**
 488  * gst_query_set_convert:
 489  * @query: a #GstQuery
 490  * @src_format: the source #GstFormat
 491  * @src_value: the source value
 492  * @dest_format: the destination #GstFormat
 493  * @dest_value: the destination value
 494  *
 495  * Answer a convert query by setting the requested values.
 496  */
 497 void
 498 gst_query_set_convert (GstQuery * query, GstFormat src_format, gint64 src_value,
 499     GstFormat dest_format, gint64 dest_value)
 500 {
 501   GstStructure *structure;
 502
 503   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONVERT);
 504
 505   structure = GST_QUERY_STRUCTURE (query);
 506   gst_structure_id_set (structure,
 507       GST_QUARK (SRC_FORMAT), GST_TYPE_FORMAT, src_format,
 508       GST_QUARK (SRC_VALUE), G_TYPE_INT64, src_value,
 509       GST_QUARK (DEST_FORMAT), GST_TYPE_FORMAT, dest_format,
 510       GST_QUARK (DEST_VALUE), G_TYPE_INT64, dest_value, NULL);
 511 }
 512
 513 /**
 514  * gst_query_parse_convert:
 515  * @query: a #GstQuery
 516  * @src_format: (out) (allow-none): the storage for the #GstFormat of the
 517  *     source value, or %NULL
 518  * @src_value: (out) (allow-none): the storage for the source value, or %NULL
 519  * @dest_format: (out) (allow-none): the storage for the #GstFormat of the
 520  *     destination value, or %NULL
 521  * @dest_value: (out) (allow-none): the storage for the destination value,
 522  *     or %NULL
 523  *
 524  * Parse a convert query answer. Any of @src_format, @src_value, @dest_format,
 525  * and @dest_value may be %NULL, in which case that value is omitted.
 526  */
 527 void
 528 gst_query_parse_convert (GstQuery * query, GstFormat * src_format,
 529     gint64 * src_value, GstFormat * dest_format, gint64 * dest_value)
 530 {
 531   GstStructure *structure;
 532
 533   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONVERT);
 534
 535   structure = GST_QUERY_STRUCTURE (query);
 536   if (src_format)
 537     *src_format =
 538         (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,
 539             GST_QUARK (SRC_FORMAT)));
 540   if (src_value)
 541     *src_value = g_value_get_int64 (gst_structure_id_get_value (structure,
 542             GST_QUARK (SRC_VALUE)));
 543   if (dest_format)
 544     *dest_format =
 545         (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,
 546             GST_QUARK (DEST_FORMAT)));
 547   if (dest_value)
 548     *dest_value = g_value_get_int64 (gst_structure_id_get_value (structure,
 549             GST_QUARK (DEST_VALUE)));
 550 }
 551
 552 /**
 553  * gst_query_new_segment:
 554  * @format: the #GstFormat for the new query
 555  *
 556  * Constructs a new segment query object. Use gst_query_unref()
 557  * when done with it. A segment query is used to discover information about the
 558  * currently configured segment for playback.
 559  *
 560  * Free-function: gst_query_unref()
 561  *
 562  * Returns: (transfer full): a new #GstQuery
 563  */
 564 GstQuery *
 565 gst_query_new_segment (GstFormat format)
 566 {
 567   GstQuery *query;
 568   GstStructure *structure;
 569
 570   structure = gst_structure_new_id (GST_QUARK (QUERY_SEGMENT),
 571       GST_QUARK (RATE), G_TYPE_DOUBLE, (gdouble) 0.0,
 572       GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
 573       GST_QUARK (START_VALUE), G_TYPE_INT64, G_GINT64_CONSTANT (-1),
 574       GST_QUARK (STOP_VALUE), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);
 575
 576   query = gst_query_new_custom (GST_QUERY_SEGMENT, structure);
 577
 578   return query;
 579 }
 580
 581 /**
 582  * gst_query_set_segment:
 583  * @query: a #GstQuery
 584  * @rate: the rate of the segment
 585  * @format: the #GstFormat of the segment values (@start_value and @stop_value)
 586  * @start_value: the start value
 587  * @stop_value: the stop value
 588  *
 589  * Answer a segment query by setting the requested values. The normal
 590  * playback segment of a pipeline is 0 to duration at the default rate of
 591  * 1.0. If a seek was performed on the pipeline to play a different
 592  * segment, this query will return the range specified in the last seek.
 593  *
 594  * @start_value and @stop_value will respectively contain the configured
 595  * playback range start and stop values expressed in @format.
 596  * The values are always between 0 and the duration of the media and
 597  * @start_value <= @stop_value. @rate will contain the playback rate. For
 598  * negative rates, playback will actually happen from @stop_value to
 599  * @start_value.
 600  */
 601 void
 602 gst_query_set_segment (GstQuery * query, gdouble rate, GstFormat format,
 603     gint64 start_value, gint64 stop_value)
 604 {
 605   GstStructure *structure;
 606
 607   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SEGMENT);
 608
 609   structure = GST_QUERY_STRUCTURE (query);
 610   gst_structure_id_set (structure,
 611       GST_QUARK (RATE), G_TYPE_DOUBLE, rate,
 612       GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
 613       GST_QUARK (START_VALUE), G_TYPE_INT64, start_value,
 614       GST_QUARK (STOP_VALUE), G_TYPE_INT64, stop_value, NULL);
 615 }
 616
 617 /**
 618  * gst_query_parse_segment:
 619  * @query: a #GstQuery
 620  * @rate: (out) (allow-none): the storage for the rate of the segment, or %NULL
 621  * @format: (out) (allow-none): the storage for the #GstFormat of the values,
 622  *     or %NULL
 623  * @start_value: (out) (allow-none): the storage for the start value, or %NULL
 624  * @stop_value: (out) (allow-none): the storage for the stop value, or %NULL
 625  *
 626  * Parse a segment query answer. Any of @rate, @format, @start_value, and
 627  * @stop_value may be %NULL, which will cause this value to be omitted.
 628  *
 629  * See gst_query_set_segment() for an explanation of the function arguments.
 630  */
 631 void
 632 gst_query_parse_segment (GstQuery * query, gdouble * rate, GstFormat * format,
 633     gint64 * start_value, gint64 * stop_value)
 634 {
 635   GstStructure *structure;
 636
 637   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SEGMENT);
 638
 639   structure = GST_QUERY_STRUCTURE (query);
 640   if (rate)
 641     *rate = g_value_get_double (gst_structure_id_get_value (structure,
 642             GST_QUARK (RATE)));
 643   if (format)
 644     *format =
 645         (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,
 646             GST_QUARK (FORMAT)));
 647   if (start_value)
 648     *start_value = g_value_get_int64 (gst_structure_id_get_value (structure,
 649             GST_QUARK (START_VALUE)));
 650   if (stop_value)
 651     *stop_value = g_value_get_int64 (gst_structure_id_get_value (structure,
 652             GST_QUARK (STOP_VALUE)));
 653 }
 654
 655 /**
 656  * gst_query_new_custom:
 657  * @type: the query type
 658  * @structure: (allow-none) (transfer full): a structure for the query
 659  *
 660  * Constructs a new custom query object. Use gst_query_unref()
 661  * when done with it.
 662  *
 663  * Free-function: gst_query_unref()
 664  *
 665  * Returns: (transfer full): a new #GstQuery
 666  */
 667 GstQuery *
 668 gst_query_new_custom (GstQueryType type, GstStructure * structure)
 669 {
 670   GstQueryImpl *query;
 671
 672   query = g_slice_new0 (GstQueryImpl);
 673
 674   GST_DEBUG ("creating new query %p %s", query, gst_query_type_get_name (type));
 675
 676   if (structure) {
 677     /* structure must not have a parent */
 678     if (!gst_structure_set_parent_refcount (structure,
 679             &query->query.mini_object.refcount))
 680       goto had_parent;
 681   }
 682
 683   gst_mini_object_init (GST_MINI_OBJECT_CAST (query), 0, _gst_query_type,
 684       (GstMiniObjectCopyFunction) _gst_query_copy, NULL,
 685       (GstMiniObjectFreeFunction) _gst_query_free);
 686
 687   GST_QUERY_TYPE (query) = type;
 688   GST_QUERY_STRUCTURE (query) = structure;
 689
 690   return GST_QUERY_CAST (query);
 691
 692   /* ERRORS */
 693 had_parent:
 694   {
 695     g_slice_free1 (sizeof (GstQueryImpl), query);
 696     g_warning ("structure is already owned by another object");
 697     return NULL;
 698   }
 699 }
 700
 701 /**
 702  * gst_query_get_structure:
 703  * @query: a #GstQuery
 704  *
 705  * Get the structure of a query.
 706  *
 707  * Returns: (transfer none): the #GstStructure of the query. The structure is
 708  *     still owned by the query and will therefore be freed when the query
 709  *     is unreffed.
 710  */
 711 const GstStructure *
 712 gst_query_get_structure (GstQuery * query)
 713 {
 714   g_return_val_if_fail (GST_IS_QUERY (query), NULL);
 715
 716   return GST_QUERY_STRUCTURE (query);
 717 }
 718
 719 /**
 720  * gst_query_writable_structure:
 721  * @query: a #GstQuery
 722  *
 723  * Get the structure of a query. This method should be called with a writable
 724  * @query so that the returned structure is guaranteed to be writable.
 725  *
 726  * Returns: (transfer none): the #GstStructure of the query. The structure is
 727  *     still owned by the query and will therefore be freed when the query
 728  *     is unreffed.
 729  */
 730 GstStructure *
 731 gst_query_writable_structure (GstQuery * query)
 732 {
 733   g_return_val_if_fail (GST_IS_QUERY (query), NULL);
 734   g_return_val_if_fail (gst_query_is_writable (query), NULL);
 735
 736   return GST_QUERY_STRUCTURE (query);
 737 }
 738
 739 /**
 740  * gst_query_new_seeking:
 741  * @format: the default #GstFormat for the new query
 742  *
 743  * Constructs a new query object for querying seeking properties of
 744  * the stream.
 745  *
 746  * Free-function: gst_query_unref()
 747  *
 748  * Returns: (transfer full): a new #GstQuery
 749  */
 750 GstQuery *
 751 gst_query_new_seeking (GstFormat format)
 752 {
 753   GstQuery *query;
 754   GstStructure *structure;
 755
 756   structure = gst_structure_new_id (GST_QUARK (QUERY_SEEKING),
 757       GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
 758       GST_QUARK (SEEKABLE), G_TYPE_BOOLEAN, FALSE,
 759       GST_QUARK (SEGMENT_START), G_TYPE_INT64, G_GINT64_CONSTANT (-1),
 760       GST_QUARK (SEGMENT_END), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);
 761
 762   query = gst_query_new_custom (GST_QUERY_SEEKING, structure);
 763
 764   return query;
 765 }
 766
 767 /**
 768  * gst_query_set_seeking:
 769  * @query: a #GstQuery
 770  * @format: the format to set for the @segment_start and @segment_end values
 771  * @seekable: the seekable flag to set
 772  * @segment_start: the segment_start to set
 773  * @segment_end: the segment_end to set
 774  *
 775  * Set the seeking query result fields in @query.
 776  */
 777 void
 778 gst_query_set_seeking (GstQuery * query, GstFormat format,
 779     gboolean seekable, gint64 segment_start, gint64 segment_end)
 780 {
 781   GstStructure *structure;
 782
 783   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SEEKING);
 784   g_return_if_fail (gst_query_is_writable (query));
 785
 786   structure = GST_QUERY_STRUCTURE (query);
 787   gst_structure_id_set (structure,
 788       GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
 789       GST_QUARK (SEEKABLE), G_TYPE_BOOLEAN, seekable,
 790       GST_QUARK (SEGMENT_START), G_TYPE_INT64, segment_start,
 791       GST_QUARK (SEGMENT_END), G_TYPE_INT64, segment_end, NULL);
 792 }
 793
 794 /**
 795  * gst_query_parse_seeking:
 796  * @query: a GST_QUERY_SEEKING type query #GstQuery
 797  * @format: (out) (allow-none): the format to set for the @segment_start
 798  *     and @segment_end values, or %NULL
 799  * @seekable: (out) (allow-none): the seekable flag to set, or %NULL
 800  * @segment_start: (out) (allow-none): the segment_start to set, or %NULL
 801  * @segment_end: (out) (allow-none): the segment_end to set, or %NULL
 802  *
 803  * Parse a seeking query, writing the format into @format, and
 804  * other results into the passed parameters, if the respective parameters
 805  * are non-%NULL
 806  */
 807 void
 808 gst_query_parse_seeking (GstQuery * query, GstFormat * format,
 809     gboolean * seekable, gint64 * segment_start, gint64 * segment_end)
 810 {
 811   GstStructure *structure;
 812
 813   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SEEKING);
 814
 815   structure = GST_QUERY_STRUCTURE (query);
 816   if (format)
 817     *format =
 818         (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,
 819             GST_QUARK (FORMAT)));
 820   if (seekable)
 821     *seekable = g_value_get_boolean (gst_structure_id_get_value (structure,
 822             GST_QUARK (SEEKABLE)));
 823   if (segment_start)
 824     *segment_start = g_value_get_int64 (gst_structure_id_get_value (structure,
 825             GST_QUARK (SEGMENT_START)));
 826   if (segment_end)
 827     *segment_end = g_value_get_int64 (gst_structure_id_get_value (structure,
 828             GST_QUARK (SEGMENT_END)));
 829 }
 830
 831 static GArray *
 832 ensure_array (GstStructure * s, GQuark quark, gsize element_size,
 833     GDestroyNotify clear_func)
 834 {
 835   GArray *array;
 836   const GValue *value;
 837
 838   value = gst_structure_id_get_value (s, quark);
 839   if (value) {
 840     array = (GArray *) g_value_get_boxed (value);
 841   } else {
 842     GValue new_array_val = { 0, };
 843
 844     array = g_array_new (FALSE, TRUE, element_size);
 845     if (clear_func)
 846       g_array_set_clear_func (array, clear_func);
 847
 848     g_value_init (&new_array_val, G_TYPE_ARRAY);
 849     g_value_take_boxed (&new_array_val, array);
 850
 851     gst_structure_id_take_value (s, quark, &new_array_val);
 852   }
 853   return array;
 854 }
 855
 856 /**
 857  * gst_query_new_formats:
 858  *
 859  * Constructs a new query object for querying formats of
 860  * the stream.
 861  *
 862  * Free-function: gst_query_unref()
 863  *
 864  * Returns: (transfer full): a new #GstQuery
 865  */
 866 GstQuery *
 867 gst_query_new_formats (void)
 868 {
 869   GstQuery *query;
 870   GstStructure *structure;
 871
 872   structure = gst_structure_new_id_empty (GST_QUARK (QUERY_FORMATS));
 873   query = gst_query_new_custom (GST_QUERY_FORMATS, structure);
 874
 875   return query;
 876 }
 877
 878 static void
 879 gst_query_list_add_format (GValue * list, GstFormat format)
 880 {
 881   GValue item = { 0, };
 882
 883   g_value_init (&item, GST_TYPE_FORMAT);
 884   g_value_set_enum (&item, format);
 885   gst_value_list_append_value (list, &item);
 886   g_value_unset (&item);
 887 }
 888
 889 /**
 890  * gst_query_set_formats:
 891  * @query: a #GstQuery
 892  * @n_formats: the number of formats to set.
 893  * @...: A number of @GstFormats equal to @n_formats.
 894  *
 895  * Set the formats query result fields in @query. The number of formats passed
 896  * must be equal to @n_formats.
 897  */
 898 void
 899 gst_query_set_formats (GstQuery * query, gint n_formats, ...)
 900 {
 901   va_list ap;
 902   GValue list = { 0, };
 903   gint i;
 904   GstStructure *structure;
 905
 906   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_FORMATS);
 907   g_return_if_fail (gst_query_is_writable (query));
 908
 909   g_value_init (&list, GST_TYPE_LIST);
 910
 911   va_start (ap, n_formats);
 912   for (i = 0; i < n_formats; i++) {
 913     gst_query_list_add_format (&list, va_arg (ap, GstFormat));
 914   }
 915   va_end (ap);
 916
 917   structure = GST_QUERY_STRUCTURE (query);
 918   gst_structure_set_value (structure, "formats", &list);
 919
 920   g_value_unset (&list);
 921
 922 }
 923
 924 /**
 925  * gst_query_set_formatsv:
 926  * @query: a #GstQuery
 927  * @n_formats: the number of formats to set.
 928  * @formats: (in) (array length=n_formats): an array containing @n_formats
 929  *     @GstFormat values.
 930  *
 931  * Set the formats query result fields in @query. The number of formats passed
 932  * in the @formats array must be equal to @n_formats.
 933  */
 934 void
 935 gst_query_set_formatsv (GstQuery * query, gint n_formats,
 936     const GstFormat * formats)
 937 {
 938   GValue list = { 0, };
 939   gint i;
 940   GstStructure *structure;
 941
 942   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_FORMATS);
 943   g_return_if_fail (gst_query_is_writable (query));
 944
 945   g_value_init (&list, GST_TYPE_LIST);
 946   for (i = 0; i < n_formats; i++) {
 947     gst_query_list_add_format (&list, formats[i]);
 948   }
 949   structure = GST_QUERY_STRUCTURE (query);
 950   gst_structure_set_value (structure, "formats", &list);
 951
 952   g_value_unset (&list);
 953 }
 954
 955 /**
 956  * gst_query_parse_n_formats:
 957  * @query: a #GstQuery
 958  * @n_formats: (out) (allow-none): the number of formats in this query.
 959  *
 960  * Parse the number of formats in the formats @query.
 961  */
 962 void
 963 gst_query_parse_n_formats (GstQuery * query, guint * n_formats)
 964 {
 965   GstStructure *structure;
 966
 967   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_FORMATS);
 968
 969   if (n_formats) {
 970     const GValue *list;
 971
 972     structure = GST_QUERY_STRUCTURE (query);
 973     list = gst_structure_get_value (structure, "formats");
 974     if (list == NULL)
 975       *n_formats = 0;
 976     else
 977       *n_formats = gst_value_list_get_size (list);
 978   }
 979 }
 980
 981 /**
 982  * gst_query_parse_nth_format:
 983  * @query: a #GstQuery
 984  * @nth: (out): the nth format to retrieve.
 985  * @format: (out) (allow-none): a pointer to store the nth format
 986  *
 987  * Parse the format query and retrieve the @nth format from it into
 988  * @format. If the list contains less elements than @nth, @format will be
 989  * set to GST_FORMAT_UNDEFINED.
 990  */
 991 void
 992 gst_query_parse_nth_format (GstQuery * query, guint nth, GstFormat * format)
 993 {
 994   GstStructure *structure;
 995
 996   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_FORMATS);
 997
 998   if (format) {
 999     const GValue *list;
1000
1001     structure = GST_QUERY_STRUCTURE (query);
1002     list = gst_structure_get_value (structure, "formats");
1003     if (list == NULL) {
1004       *format = GST_FORMAT_UNDEFINED;
1005     } else {
1006       if (nth < gst_value_list_get_size (list)) {
1007         *format =
1008             (GstFormat) g_value_get_enum (gst_value_list_get_value (list, nth));
1009       } else
1010         *format = GST_FORMAT_UNDEFINED;
1011     }
1012   }
1013 }
1014
1015 /**
1016  * gst_query_new_buffering:
1017  * @format: the default #GstFormat for the new query
1018  *
1019  * Constructs a new query object for querying the buffering status of
1020  * a stream.
1021  *
1022  * Free-function: gst_query_unref()
1023  *
1024  * Returns: (transfer full): a new #GstQuery
1025  */
1026 GstQuery *
1027 gst_query_new_buffering (GstFormat format)
1028 {
1029   GstQuery *query;
1030   GstStructure *structure;
1031
1032   /* by default, we configure the answer as no buffering with a 100% buffering
1033    * progress */
1034   structure = gst_structure_new_id (GST_QUARK (QUERY_BUFFERING),
1035       GST_QUARK (BUSY), G_TYPE_BOOLEAN, FALSE,
1036       GST_QUARK (BUFFER_PERCENT), G_TYPE_INT, 100,
1037       GST_QUARK (BUFFERING_MODE), GST_TYPE_BUFFERING_MODE, GST_BUFFERING_STREAM,
1038       GST_QUARK (AVG_IN_RATE), G_TYPE_INT, -1,
1039       GST_QUARK (AVG_OUT_RATE), G_TYPE_INT, -1,
1040       GST_QUARK (BUFFERING_LEFT), G_TYPE_INT64, G_GINT64_CONSTANT (0),
1041       GST_QUARK (ESTIMATED_TOTAL), G_TYPE_INT64, G_GINT64_CONSTANT (-1),
1042       GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
1043       GST_QUARK (START_VALUE), G_TYPE_INT64, G_GINT64_CONSTANT (-1),
1044       GST_QUARK (STOP_VALUE), G_TYPE_INT64, G_GINT64_CONSTANT (-1), NULL);
1045
1046   query = gst_query_new_custom (GST_QUERY_BUFFERING, structure);
1047
1048   return query;
1049 }
1050
1051 /**
1052  * gst_query_set_buffering_percent:
1053  * @query: A valid #GstQuery of type GST_QUERY_BUFFERING.
1054  * @busy: if buffering is busy
1055  * @percent: a buffering percent
1056  *
1057  * Set the percentage of buffered data. This is a value between 0 and 100.
1058  * The @busy indicator is %TRUE when the buffering is in progress.
1059  */
1060 void
1061 gst_query_set_buffering_percent (GstQuery * query, gboolean busy, gint percent)
1062 {
1063   GstStructure *structure;
1064
1065   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING);
1066   g_return_if_fail (gst_query_is_writable (query));
1067   g_return_if_fail (percent >= 0 && percent <= 100);
1068
1069   structure = GST_QUERY_STRUCTURE (query);
1070   gst_structure_id_set (structure,
1071       GST_QUARK (BUSY), G_TYPE_BOOLEAN, busy,
1072       GST_QUARK (BUFFER_PERCENT), G_TYPE_INT, percent, NULL);
1073 }
1074
1075 /**
1076  * gst_query_parse_buffering_percent:
1077  * @query: A valid #GstQuery of type GST_QUERY_BUFFERING.
1078  * @busy: (out) (allow-none): if buffering is busy, or %NULL
1079  * @percent: (out) (allow-none): a buffering percent, or %NULL
1080  *
1081  * Get the percentage of buffered data. This is a value between 0 and 100.
1082  * The @busy indicator is %TRUE when the buffering is in progress.
1083  */
1084 void
1085 gst_query_parse_buffering_percent (GstQuery * query, gboolean * busy,
1086     gint * percent)
1087 {
1088   GstStructure *structure;
1089
1090   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING);
1091
1092   structure = GST_QUERY_STRUCTURE (query);
1093   if (busy)
1094     *busy = g_value_get_boolean (gst_structure_id_get_value (structure,
1095             GST_QUARK (BUSY)));
1096   if (percent)
1097     *percent = g_value_get_int (gst_structure_id_get_value (structure,
1098             GST_QUARK (BUFFER_PERCENT)));
1099 }
1100
1101 /**
1102  * gst_query_set_buffering_stats:
1103  * @query: A valid #GstQuery of type GST_QUERY_BUFFERING.
1104  * @mode: a buffering mode
1105  * @avg_in: the average input rate
1106  * @avg_out: the average output rate
1107  * @buffering_left: amount of buffering time left in milliseconds
1108  *
1109  * Configures the buffering stats values in @query.
1110  */
1111 void
1112 gst_query_set_buffering_stats (GstQuery * query, GstBufferingMode mode,
1113     gint avg_in, gint avg_out, gint64 buffering_left)
1114 {
1115   GstStructure *structure;
1116
1117   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING);
1118   g_return_if_fail (gst_query_is_writable (query));
1119
1120   structure = GST_QUERY_STRUCTURE (query);
1121   gst_structure_id_set (structure,
1122       GST_QUARK (BUFFERING_MODE), GST_TYPE_BUFFERING_MODE, mode,
1123       GST_QUARK (AVG_IN_RATE), G_TYPE_INT, avg_in,
1124       GST_QUARK (AVG_OUT_RATE), G_TYPE_INT, avg_out,
1125       GST_QUARK (BUFFERING_LEFT), G_TYPE_INT64, buffering_left, NULL);
1126 }
1127
1128 /**
1129  * gst_query_parse_buffering_stats:
1130  * @query: A valid #GstQuery of type GST_QUERY_BUFFERING.
1131  * @mode: (out) (allow-none): a buffering mode, or %NULL
1132  * @avg_in: (out) (allow-none): the average input rate, or %NULL
1133  * @avg_out: (out) (allow-none): the average output rat, or %NULL
1134  * @buffering_left: (out) (allow-none): amount of buffering time left in
1135  *     milliseconds, or %NULL
1136  *
1137  * Extracts the buffering stats values from @query.
1138  */
1139 void
1140 gst_query_parse_buffering_stats (GstQuery * query,
1141     GstBufferingMode * mode, gint * avg_in, gint * avg_out,
1142     gint64 * buffering_left)
1143 {
1144   GstStructure *structure;
1145
1146   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING);
1147
1148   structure = GST_QUERY_STRUCTURE (query);
1149   if (mode)
1150     *mode = (GstBufferingMode)
1151         g_value_get_enum (gst_structure_id_get_value (structure,
1152             GST_QUARK (BUFFERING_MODE)));
1153   if (avg_in)
1154     *avg_in = g_value_get_int (gst_structure_id_get_value (structure,
1155             GST_QUARK (AVG_IN_RATE)));
1156   if (avg_out)
1157     *avg_out = g_value_get_int (gst_structure_id_get_value (structure,
1158             GST_QUARK (AVG_OUT_RATE)));
1159   if (buffering_left)
1160     *buffering_left =
1161         g_value_get_int64 (gst_structure_id_get_value (structure,
1162             GST_QUARK (BUFFERING_LEFT)));
1163 }
1164
1165 /**
1166  * gst_query_set_buffering_range:
1167  * @query: a #GstQuery
1168  * @format: the format to set for the @start and @stop values
1169  * @start: the start to set
1170  * @stop: the stop to set
1171  * @estimated_total: estimated total amount of download time remaining in
1172  *     milliseconds
1173  *
1174  * Set the available query result fields in @query.
1175  */
1176 void
1177 gst_query_set_buffering_range (GstQuery * query, GstFormat format,
1178     gint64 start, gint64 stop, gint64 estimated_total)
1179 {
1180   GstStructure *structure;
1181
1182   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING);
1183   g_return_if_fail (gst_query_is_writable (query));
1184
1185   structure = GST_QUERY_STRUCTURE (query);
1186   gst_structure_id_set (structure,
1187       GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,
1188       GST_QUARK (START_VALUE), G_TYPE_INT64, start,
1189       GST_QUARK (STOP_VALUE), G_TYPE_INT64, stop,
1190       GST_QUARK (ESTIMATED_TOTAL), G_TYPE_INT64, estimated_total, NULL);
1191 }
1192
1193 /**
1194  * gst_query_parse_buffering_range:
1195  * @query: a GST_QUERY_BUFFERING type query #GstQuery
1196  * @format: (out) (allow-none): the format to set for the @segment_start
1197  *     and @segment_end values, or %NULL
1198  * @start: (out) (allow-none): the start to set, or %NULL
1199  * @stop: (out) (allow-none): the stop to set, or %NULL
1200  * @estimated_total: (out) (allow-none): estimated total amount of download
1201  *     time remaining in milliseconds, or %NULL
1202  *
1203  * Parse an available query, writing the format into @format, and
1204  * other results into the passed parameters, if the respective parameters
1205  * are non-%NULL
1206  */
1207 void
1208 gst_query_parse_buffering_range (GstQuery * query, GstFormat * format,
1209     gint64 * start, gint64 * stop, gint64 * estimated_total)
1210 {
1211   GstStructure *structure;
1212
1213   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING);
1214
1215   structure = GST_QUERY_STRUCTURE (query);
1216   if (format)
1217     *format =
1218         (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,
1219             GST_QUARK (FORMAT)));
1220   if (start)
1221     *start = g_value_get_int64 (gst_structure_id_get_value (structure,
1222             GST_QUARK (START_VALUE)));
1223   if (stop)
1224     *stop = g_value_get_int64 (gst_structure_id_get_value (structure,
1225             GST_QUARK (STOP_VALUE)));
1226   if (estimated_total)
1227     *estimated_total =
1228         g_value_get_int64 (gst_structure_id_get_value (structure,
1229             GST_QUARK (ESTIMATED_TOTAL)));
1230 }
1231
1232 /* GstQueryBufferingRange: internal struct for GArray */
1233 typedef struct
1234 {
1235   gint64 start;
1236   gint64 stop;
1237 } GstQueryBufferingRange;
1238
1239 /**
1240  * gst_query_add_buffering_range:
1241  * @query: a GST_QUERY_BUFFERING type query #GstQuery
1242  * @start: start position of the range
1243  * @stop: stop position of the range
1244  *
1245  * Set the buffering-ranges array field in @query. The current last
1246  * start position of the array should be inferior to @start.
1247  *
1248  * Returns: a #gboolean indicating if the range was added or not.
1249  */
1250 gboolean
1251 gst_query_add_buffering_range (GstQuery * query, gint64 start, gint64 stop)
1252 {
1253   GstQueryBufferingRange range;
1254   GstStructure *structure;
1255   GArray *array;
1256
1257   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING, FALSE);
1258   g_return_val_if_fail (gst_query_is_writable (query), FALSE);
1259
1260   if (G_UNLIKELY (start >= stop))
1261     return FALSE;
1262
1263   structure = GST_QUERY_STRUCTURE (query);
1264   array = ensure_array (structure, GST_QUARK (BUFFERING_RANGES),
1265       sizeof (GstQueryBufferingRange), NULL);
1266
1267   if (array->len > 1) {
1268     GstQueryBufferingRange *last;
1269
1270     last = &g_array_index (array, GstQueryBufferingRange, array->len - 1);
1271
1272     if (G_UNLIKELY (start <= last->start))
1273       return FALSE;
1274   }
1275
1276   range.start = start;
1277   range.stop = stop;
1278   g_array_append_val (array, range);
1279
1280   return TRUE;
1281 }
1282
1283 /**
1284  * gst_query_get_n_buffering_ranges:
1285  * @query: a GST_QUERY_BUFFERING type query #GstQuery
1286  *
1287  * Retrieve the number of values currently stored in the
1288  * buffered-ranges array of the query's structure.
1289  *
1290  * Returns: the range array size as a #guint.
1291  */
1292 guint
1293 gst_query_get_n_buffering_ranges (GstQuery * query)
1294 {
1295   GstStructure *structure;
1296   GArray *array;
1297
1298   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING, 0);
1299
1300   structure = GST_QUERY_STRUCTURE (query);
1301   array = ensure_array (structure, GST_QUARK (BUFFERING_RANGES),
1302       sizeof (GstQueryBufferingRange), NULL);
1303
1304   return array->len;
1305 }
1306
1307
1308 /**
1309  * gst_query_parse_nth_buffering_range:
1310  * @query: a GST_QUERY_BUFFERING type query #GstQuery
1311  * @index: position in the buffered-ranges array to read
1312  * @start: (out) (allow-none): the start position to set, or %NULL
1313  * @stop: (out) (allow-none): the stop position to set, or %NULL
1314  *
1315  * Parse an available query and get the start and stop values stored
1316  * at the @index of the buffered ranges array.
1317  *
1318  * Returns: a #gboolean indicating if the parsing succeeded.
1319  */
1320 gboolean
1321 gst_query_parse_nth_buffering_range (GstQuery * query, guint index,
1322     gint64 * start, gint64 * stop)
1323 {
1324   GstQueryBufferingRange *range;
1325   GstStructure *structure;
1326   GArray *array;
1327
1328   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_BUFFERING, FALSE);
1329
1330   structure = GST_QUERY_STRUCTURE (query);
1331
1332   array = ensure_array (structure, GST_QUARK (BUFFERING_RANGES),
1333       sizeof (GstQueryBufferingRange), NULL);
1334   g_return_val_if_fail (index < array->len, FALSE);
1335
1336   range = &g_array_index (array, GstQueryBufferingRange, index);
1337
1338   if (start)
1339     *start = range->start;
1340   if (stop)
1341     *stop = range->stop;
1342
1343   return TRUE;
1344 }
1345
1346
1347 /**
1348  * gst_query_new_uri:
1349  *
1350  * Constructs a new query URI query object. Use gst_query_unref()
1351  * when done with it. An URI query is used to query the current URI
1352  * that is used by the source or sink.
1353  *
1354  * Free-function: gst_query_unref()
1355  *
1356  * Returns: (transfer full): a new #GstQuery
1357  */
1358 GstQuery *
1359 gst_query_new_uri (void)
1360 {
1361   GstQuery *query;
1362   GstStructure *structure;
1363
1364   structure = gst_structure_new_id (GST_QUARK (QUERY_URI),
1365       GST_QUARK (URI), G_TYPE_STRING, NULL, NULL);
1366
1367   query = gst_query_new_custom (GST_QUERY_URI, structure);
1368
1369   return query;
1370 }
1371
1372 /**
1373  * gst_query_set_uri:
1374  * @query: a #GstQuery with query type GST_QUERY_URI
1375  * @uri: the URI to set
1376  *
1377  * Answer a URI query by setting the requested URI.
1378  */
1379 void
1380 gst_query_set_uri (GstQuery * query, const gchar * uri)
1381 {
1382   GstStructure *structure;
1383
1384   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_URI);
1385   g_return_if_fail (gst_query_is_writable (query));
1386   g_return_if_fail (gst_uri_is_valid (uri));
1387
1388   structure = GST_QUERY_STRUCTURE (query);
1389   gst_structure_id_set (structure, GST_QUARK (URI), G_TYPE_STRING, uri, NULL);
1390 }
1391
1392 /**
1393  * gst_query_parse_uri:
1394  * @query: a #GstQuery
1395  * @uri: (out) (transfer full) (allow-none): the storage for the current URI
1396  *     (may be %NULL)
1397  *
1398  * Parse an URI query, writing the URI into @uri as a newly
1399  * allocated string, if the respective parameters are non-%NULL.
1400  * Free the string with g_free() after usage.
1401  */
1402 void
1403 gst_query_parse_uri (GstQuery * query, gchar ** uri)
1404 {
1405   GstStructure *structure;
1406
1407   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_URI);
1408
1409   structure = GST_QUERY_STRUCTURE (query);
1410   if (uri)
1411     *uri = g_value_dup_string (gst_structure_id_get_value (structure,
1412             GST_QUARK (URI)));
1413 }
1414
1415 /**
1416  * gst_query_set_uri_redirection:
1417  * @query: a #GstQuery with query type GST_QUERY_URI
1418  * @uri: the URI to set
1419  *
1420  * Answer a URI query by setting the requested URI redirection.
1421  *
1422  * Since: 1.2
1423  */
1424 void
1425 gst_query_set_uri_redirection (GstQuery * query, const gchar * uri)
1426 {
1427   GstStructure *structure;
1428
1429   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_URI);
1430   g_return_if_fail (gst_query_is_writable (query));
1431   g_return_if_fail (gst_uri_is_valid (uri));
1432
1433   structure = GST_QUERY_STRUCTURE (query);
1434   gst_structure_id_set (structure, GST_QUARK (URI_REDIRECTION),
1435       G_TYPE_STRING, uri, NULL);
1436 }
1437
1438 /**
1439  * gst_query_parse_uri_redirection:
1440  * @query: a #GstQuery
1441  * @uri: (out) (transfer full) (allow-none): the storage for the redirect URI
1442  *     (may be %NULL)
1443  *
1444  * Parse an URI query, writing the URI into @uri as a newly
1445  * allocated string, if the respective parameters are non-%NULL.
1446  * Free the string with g_free() after usage.
1447  *
1448  * Since: 1.2
1449  */
1450 void
1451 gst_query_parse_uri_redirection (GstQuery * query, gchar ** uri)
1452 {
1453   GstStructure *structure;
1454
1455   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_URI);
1456
1457   structure = GST_QUERY_STRUCTURE (query);
1458   if (uri) {
1459     if (!gst_structure_id_get (structure, GST_QUARK (URI_REDIRECTION),
1460             G_TYPE_STRING, uri, NULL))
1461       *uri = NULL;
1462   }
1463 }
1464
1465 /**
1466  * gst_query_set_uri_redirection_permanent:
1467  * @query: a #GstQuery with query type %GST_QUERY_URI
1468  * @permanent: whether the redirect is permanent or not
1469  *
1470  * Answer a URI query by setting the requested URI redirection
1471  * to permanent or not.
1472  *
1473  * Since: 1.4
1474  */
1475 void
1476 gst_query_set_uri_redirection_permanent (GstQuery * query, gboolean permanent)
1477 {
1478   GstStructure *structure;
1479
1480   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_URI);
1481   g_return_if_fail (gst_query_is_writable (query));
1482
1483   structure = GST_QUERY_STRUCTURE (query);
1484   gst_structure_id_set (structure, GST_QUARK (URI_REDIRECTION_PERMANENT),
1485       G_TYPE_BOOLEAN, permanent, NULL);
1486 }
1487
1488 /**
1489  * gst_query_parse_uri_redirection_permanent:
1490  * @query: a #GstQuery
1491  * @permanent: (out) (allow-none): if the URI redirection is permanent
1492  *     (may be %NULL)
1493  *
1494  * Parse an URI query, and set @permanent to %TRUE if there is a redirection
1495  * and it should be considered permanent. If a redirection is permanent,
1496  * applications should update their internal storage of the URI, otherwise
1497  * they should make all future requests to the original URI.
1498  *
1499  * Since: 1.4
1500  */
1501 void
1502 gst_query_parse_uri_redirection_permanent (GstQuery * query,
1503     gboolean * permanent)
1504 {
1505   GstStructure *structure;
1506
1507   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_URI);
1508
1509   structure = GST_QUERY_STRUCTURE (query);
1510   if (permanent) {
1511     if (!gst_structure_id_get (structure, GST_QUARK (URI_REDIRECTION_PERMANENT),
1512             G_TYPE_BOOLEAN, permanent, NULL))
1513       *permanent = FALSE;
1514   }
1515 }
1516
1517 /**
1518  * gst_query_new_allocation:
1519  * @caps: the negotiated caps
1520  * @need_pool: return a pool
1521  *
1522  * Constructs a new query object for querying the allocation properties.
1523  *
1524  * Free-function: gst_query_unref()
1525  *
1526  * Returns: (transfer full): a new #GstQuery
1527  */
1528 GstQuery *
1529 gst_query_new_allocation (GstCaps * caps, gboolean need_pool)
1530 {
1531   GstQuery *query;
1532   GstStructure *structure;
1533
1534   structure = gst_structure_new_id (GST_QUARK (QUERY_ALLOCATION),
1535       GST_QUARK (CAPS), GST_TYPE_CAPS, caps,
1536       GST_QUARK (NEED_POOL), G_TYPE_BOOLEAN, need_pool, NULL);
1537
1538   query = gst_query_new_custom (GST_QUERY_ALLOCATION, structure);
1539
1540   return query;
1541 }
1542
1543 /**
1544  * gst_query_parse_allocation:
1545  * @query: a #GstQuery
1546  * @caps: (out) (transfer none) (allow-none): The #GstCaps
1547  * @need_pool: (out) (allow-none): Whether a #GstBufferPool is needed
1548  *
1549  * Parse an allocation query, writing the requested caps in @caps and
1550  * whether a pool is needed in @need_pool, if the respective parameters
1551  * are non-%NULL.
1552  *
1553  * Pool details can be retrieved using gst_query_get_n_allocation_pools() and
1554  * gst_query_parse_nth_allocation_pool().
1555  */
1556 void
1557 gst_query_parse_allocation (GstQuery * query, GstCaps ** caps,
1558     gboolean * need_pool)
1559 {
1560   GstStructure *structure;
1561
1562   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
1563
1564   structure = GST_QUERY_STRUCTURE (query);
1565   if (caps) {
1566     *caps = g_value_get_boxed (gst_structure_id_get_value (structure,
1567             GST_QUARK (CAPS)));
1568   }
1569   gst_structure_id_get (structure,
1570       GST_QUARK (NEED_POOL), G_TYPE_BOOLEAN, need_pool, NULL);
1571 }
1572
1573 typedef struct
1574 {
1575   GstBufferPool *pool;
1576   guint size;
1577   guint min_buffers;
1578   guint max_buffers;
1579 } AllocationPool;
1580
1581 static void
1582 allocation_pool_free (AllocationPool * ap)
1583 {
1584   if (ap->pool)
1585     gst_object_unref (ap->pool);
1586 }
1587
1588 /**
1589  * gst_query_add_allocation_pool:
1590  * @query: A valid #GstQuery of type GST_QUERY_ALLOCATION.
1591  * @pool: (transfer none) (allow-none): the #GstBufferPool
1592  * @size: the buffer size
1593  * @min_buffers: the min buffers
1594  * @max_buffers: the max buffers
1595  *
1596  * Set the pool parameters in @query.
1597  */
1598 void
1599 gst_query_add_allocation_pool (GstQuery * query, GstBufferPool * pool,
1600     guint size, guint min_buffers, guint max_buffers)
1601 {
1602   GArray *array;
1603   GstStructure *structure;
1604   AllocationPool ap;
1605
1606   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
1607   g_return_if_fail (gst_query_is_writable (query));
1608
1609   structure = GST_QUERY_STRUCTURE (query);
1610   array = ensure_array (structure, GST_QUARK (POOL),
1611       sizeof (AllocationPool), (GDestroyNotify) allocation_pool_free);
1612
1613   if ((ap.pool = pool))
1614     gst_object_ref (pool);
1615   ap.size = size;
1616   ap.min_buffers = min_buffers;
1617   ap.max_buffers = max_buffers;
1618
1619   g_array_append_val (array, ap);
1620 }
1621
1622 /**
1623  * gst_query_get_n_allocation_pools:
1624  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
1625  *
1626  * Retrieve the number of values currently stored in the
1627  * pool array of the query's structure.
1628  *
1629  * Returns: the pool array size as a #guint.
1630  */
1631 guint
1632 gst_query_get_n_allocation_pools (GstQuery * query)
1633 {
1634   GArray *array;
1635   GstStructure *structure;
1636
1637   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, 0);
1638
1639   structure = GST_QUERY_STRUCTURE (query);
1640   array = ensure_array (structure, GST_QUARK (POOL),
1641       sizeof (AllocationPool), (GDestroyNotify) allocation_pool_free);
1642
1643   return array->len;
1644 }
1645
1646 /**
1647  * gst_query_parse_nth_allocation_pool:
1648  * @query: A valid #GstQuery of type GST_QUERY_ALLOCATION.
1649  * @index: index to parse
1650  * @pool: (out) (allow-none) (transfer full): the #GstBufferPool
1651  * @size: (out) (allow-none): the buffer size
1652  * @min_buffers: (out) (allow-none): the min buffers
1653  * @max_buffers: (out) (allow-none): the max buffers
1654  *
1655  * Get the pool parameters in @query.
1656  *
1657  * Unref @pool with gst_object_unref() when it's not needed any more.
1658  */
1659 void
1660 gst_query_parse_nth_allocation_pool (GstQuery * query, guint index,
1661     GstBufferPool ** pool, guint * size, guint * min_buffers,
1662     guint * max_buffers)
1663 {
1664   GArray *array;
1665   GstStructure *structure;
1666   AllocationPool *ap;
1667
1668   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
1669
1670   structure = GST_QUERY_STRUCTURE (query);
1671   array = ensure_array (structure, GST_QUARK (POOL),
1672       sizeof (AllocationPool), (GDestroyNotify) allocation_pool_free);
1673   g_return_if_fail (index < array->len);
1674
1675   ap = &g_array_index (array, AllocationPool, index);
1676
1677   if (pool)
1678     if ((*pool = ap->pool))
1679       gst_object_ref (*pool);
1680   if (size)
1681     *size = ap->size;
1682   if (min_buffers)
1683     *min_buffers = ap->min_buffers;
1684   if (max_buffers)
1685     *max_buffers = ap->max_buffers;
1686 }
1687
1688 /**
1689  * gst_query_set_nth_allocation_pool:
1690  * @index: index to modify
1691  * @query: A valid #GstQuery of type GST_QUERY_ALLOCATION.
1692  * @pool: (transfer none) (allow-none): the #GstBufferPool
1693  * @size: the size
1694  * @min_buffers: the min buffers
1695  * @max_buffers: the max buffers
1696  *
1697  * Set the pool parameters in @query.
1698  */
1699 void
1700 gst_query_set_nth_allocation_pool (GstQuery * query, guint index,
1701     GstBufferPool * pool, guint size, guint min_buffers, guint max_buffers)
1702 {
1703   GArray *array;
1704   GstStructure *structure;
1705   AllocationPool *oldap, ap;
1706
1707   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
1708
1709   structure = GST_QUERY_STRUCTURE (query);
1710   array = ensure_array (structure, GST_QUARK (POOL),
1711       sizeof (AllocationPool), (GDestroyNotify) allocation_pool_free);
1712   g_return_if_fail (index < array->len);
1713
1714   oldap = &g_array_index (array, AllocationPool, index);
1715   allocation_pool_free (oldap);
1716
1717   if ((ap.pool = pool))
1718     gst_object_ref (pool);
1719   ap.size = size;
1720   ap.min_buffers = min_buffers;
1721   ap.max_buffers = max_buffers;
1722   g_array_index (array, AllocationPool, index) = ap;
1723 }
1724
1725 /**
1726  * gst_query_remove_nth_allocation_pool:
1727  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
1728  * @index: position in the allocation pool array to remove
1729  *
1730  * Remove the allocation pool at @index of the allocation pool array.
1731  *
1732  * Since: 1.2
1733  */
1734 void
1735 gst_query_remove_nth_allocation_pool (GstQuery * query, guint index)
1736 {
1737   GArray *array;
1738   GstStructure *structure;
1739
1740   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
1741   g_return_if_fail (gst_query_is_writable (query));
1742
1743   structure = GST_QUERY_STRUCTURE (query);
1744   array =
1745       ensure_array (structure, GST_QUARK (POOL), sizeof (AllocationPool),
1746       (GDestroyNotify) allocation_pool_free);
1747   g_return_if_fail (index < array->len);
1748
1749   g_array_remove_index (array, index);
1750 }
1751
1752 typedef struct
1753 {
1754   GType api;
1755   GstStructure *params;
1756 } AllocationMeta;
1757
1758 static void
1759 allocation_meta_free (AllocationMeta * am)
1760 {
1761   if (am->params)
1762     gst_structure_free (am->params);
1763 }
1764
1765 /**
1766  * gst_query_add_allocation_meta:
1767  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
1768  * @api: the metadata API
1769  * @params: (transfer none) (allow-none): API specific parameters
1770  *
1771  * Add @api with @params as one of the supported metadata API to @query.
1772  */
1773 void
1774 gst_query_add_allocation_meta (GstQuery * query, GType api,
1775     const GstStructure * params)
1776 {
1777   GArray *array;
1778   GstStructure *structure;
1779   AllocationMeta am;
1780
1781   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
1782   g_return_if_fail (api != 0);
1783   g_return_if_fail (gst_query_is_writable (query));
1784
1785   structure = GST_QUERY_STRUCTURE (query);
1786   array =
1787       ensure_array (structure, GST_QUARK (META), sizeof (AllocationMeta),
1788       (GDestroyNotify) allocation_meta_free);
1789
1790   am.api = api;
1791   am.params = (params ? gst_structure_copy (params) : NULL);
1792
1793   g_array_append_val (array, am);
1794 }
1795
1796 /**
1797  * gst_query_get_n_allocation_metas:
1798  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
1799  *
1800  * Retrieve the number of values currently stored in the
1801  * meta API array of the query's structure.
1802  *
1803  * Returns: the metadata API array size as a #guint.
1804  */
1805 guint
1806 gst_query_get_n_allocation_metas (GstQuery * query)
1807 {
1808   GArray *array;
1809   GstStructure *structure;
1810
1811   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, 0);
1812
1813   structure = GST_QUERY_STRUCTURE (query);
1814   array =
1815       ensure_array (structure, GST_QUARK (META), sizeof (AllocationMeta),
1816       (GDestroyNotify) allocation_meta_free);
1817
1818   return array->len;
1819 }
1820
1821 /**
1822  * gst_query_parse_nth_allocation_meta:
1823  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
1824  * @index: position in the metadata API array to read
1825  * @params: (out) (transfer none) (allow-none): API specific parameters
1826  *
1827  * Parse an available query and get the metadata API
1828  * at @index of the metadata API array.
1829  *
1830  * Returns: a #GType of the metadata API at @index.
1831  */
1832 GType
1833 gst_query_parse_nth_allocation_meta (GstQuery * query, guint index,
1834     const GstStructure ** params)
1835 {
1836   GArray *array;
1837   GstStructure *structure;
1838   AllocationMeta *am;
1839
1840   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, 0);
1841
1842   structure = GST_QUERY_STRUCTURE (query);
1843   array =
1844       ensure_array (structure, GST_QUARK (META), sizeof (AllocationMeta),
1845       (GDestroyNotify) allocation_meta_free);
1846
1847   g_return_val_if_fail (index < array->len, 0);
1848
1849   am = &g_array_index (array, AllocationMeta, index);
1850
1851   if (params)
1852     *params = am->params;
1853
1854   return am->api;
1855 }
1856
1857 /**
1858  * gst_query_remove_nth_allocation_meta:
1859  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
1860  * @index: position in the metadata API array to remove
1861  *
1862  * Remove the metadata API at @index of the metadata API array.
1863  */
1864 void
1865 gst_query_remove_nth_allocation_meta (GstQuery * query, guint index)
1866 {
1867   GArray *array;
1868   GstStructure *structure;
1869
1870   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
1871   g_return_if_fail (gst_query_is_writable (query));
1872
1873   structure = GST_QUERY_STRUCTURE (query);
1874   array =
1875       ensure_array (structure, GST_QUARK (META), sizeof (AllocationMeta),
1876       (GDestroyNotify) allocation_meta_free);
1877   g_return_if_fail (index < array->len);
1878
1879   g_array_remove_index (array, index);
1880 }
1881
1882 /**
1883  * gst_query_find_allocation_meta:
1884  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
1885  * @api: the metadata API
1886  * @index: (out) (transfer none) (allow-none): the index
1887  *
1888  * Check if @query has metadata @api set. When this function returns %TRUE,
1889  * @index will contain the index where the requested API and the parameters
1890  * can be found.
1891  *
1892  * Returns: %TRUE when @api is in the list of metadata.
1893  */
1894 gboolean
1895 gst_query_find_allocation_meta (GstQuery * query, GType api, guint * index)
1896 {
1897   GArray *array;
1898   GstStructure *structure;
1899   guint i, len;
1900
1901   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, FALSE);
1902   g_return_val_if_fail (api != 0, FALSE);
1903
1904   structure = GST_QUERY_STRUCTURE (query);
1905   array =
1906       ensure_array (structure, GST_QUARK (META), sizeof (AllocationMeta),
1907       (GDestroyNotify) allocation_meta_free);
1908
1909   len = array->len;
1910   for (i = 0; i < len; i++) {
1911     AllocationMeta *am = &g_array_index (array, AllocationMeta, i);
1912     if (am->api == api) {
1913       if (index)
1914         *index = i;
1915       return TRUE;
1916     }
1917   }
1918   return FALSE;
1919 }
1920
1921 typedef struct
1922 {
1923   GstAllocator *allocator;
1924   GstAllocationParams params;
1925 } AllocationParam;
1926
1927 static void
1928 allocation_param_free (AllocationParam * ap)
1929 {
1930   if (ap->allocator)
1931     gst_object_unref (ap->allocator);
1932 }
1933
1934 /**
1935  * gst_query_add_allocation_param:
1936  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
1937  * @allocator: (transfer none) (allow-none): the memory allocator
1938  * @params: (transfer none) (allow-none): a #GstAllocationParams
1939  *
1940  * Add @allocator and its @params as a supported memory allocator.
1941  */
1942 void
1943 gst_query_add_allocation_param (GstQuery * query, GstAllocator * allocator,
1944     const GstAllocationParams * params)
1945 {
1946   GArray *array;
1947   GstStructure *structure;
1948   AllocationParam ap;
1949
1950   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
1951   g_return_if_fail (gst_query_is_writable (query));
1952   g_return_if_fail (allocator != NULL || params != NULL);
1953
1954   structure = GST_QUERY_STRUCTURE (query);
1955   array = ensure_array (structure, GST_QUARK (ALLOCATOR),
1956       sizeof (AllocationParam), (GDestroyNotify) allocation_param_free);
1957
1958   if ((ap.allocator = allocator))
1959     gst_object_ref (allocator);
1960   if (params)
1961     ap.params = *params;
1962   else
1963     gst_allocation_params_init (&ap.params);
1964
1965   g_array_append_val (array, ap);
1966 }
1967
1968 /**
1969  * gst_query_get_n_allocation_params:
1970  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
1971  *
1972  * Retrieve the number of values currently stored in the
1973  * allocator params array of the query's structure.
1974  *
1975  * If no memory allocator is specified, the downstream element can handle
1976  * the default memory allocator. The first memory allocator in the query
1977  * should be generic and allow mapping to system memory, all following
1978  * allocators should be ordered by preference with the preferred one first.
1979  *
1980  * Returns: the allocator array size as a #guint.
1981  */
1982 guint
1983 gst_query_get_n_allocation_params (GstQuery * query)
1984 {
1985   GArray *array;
1986   GstStructure *structure;
1987
1988   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION, 0);
1989
1990   structure = GST_QUERY_STRUCTURE (query);
1991   array = ensure_array (structure, GST_QUARK (ALLOCATOR),
1992       sizeof (AllocationParam), (GDestroyNotify) allocation_param_free);
1993
1994   return array->len;
1995 }
1996
1997 /**
1998  * gst_query_parse_nth_allocation_param:
1999  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
2000  * @index: position in the allocator array to read
2001  * @allocator: (out) (transfer full) (allow-none): variable to hold the result
2002  * @params: (out) (allow-none): parameters for the allocator
2003  *
2004  * Parse an available query and get the allocator and its params
2005  * at @index of the allocator array.
2006  */
2007 void
2008 gst_query_parse_nth_allocation_param (GstQuery * query, guint index,
2009     GstAllocator ** allocator, GstAllocationParams * params)
2010 {
2011   GArray *array;
2012   GstStructure *structure;
2013   AllocationParam *ap;
2014
2015   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
2016
2017   structure = GST_QUERY_STRUCTURE (query);
2018   array = ensure_array (structure, GST_QUARK (ALLOCATOR),
2019       sizeof (AllocationParam), (GDestroyNotify) allocation_param_free);
2020   g_return_if_fail (index < array->len);
2021
2022   ap = &g_array_index (array, AllocationParam, index);
2023
2024   if (allocator)
2025     if ((*allocator = ap->allocator))
2026       gst_object_ref (*allocator);
2027   if (params)
2028     *params = ap->params;
2029 }
2030
2031 /**
2032  * gst_query_set_nth_allocation_param:
2033  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
2034  * @index: position in the allocator array to set
2035  * @allocator: (transfer none) (allow-none): new allocator to set
2036  * @params: (transfer none) (allow-none): parameters for the allocator
2037  *
2038  * Parse an available query and get the allocator and its params
2039  * at @index of the allocator array.
2040  */
2041 void
2042 gst_query_set_nth_allocation_param (GstQuery * query, guint index,
2043     GstAllocator * allocator, const GstAllocationParams * params)
2044 {
2045   GArray *array;
2046   GstStructure *structure;
2047   AllocationParam *old, ap;
2048
2049   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
2050
2051   structure = GST_QUERY_STRUCTURE (query);
2052   array = ensure_array (structure, GST_QUARK (ALLOCATOR),
2053       sizeof (AllocationParam), (GDestroyNotify) allocation_param_free);
2054   g_return_if_fail (index < array->len);
2055
2056   old = &g_array_index (array, AllocationParam, index);
2057   allocation_param_free (old);
2058
2059   if ((ap.allocator = allocator))
2060     gst_object_ref (allocator);
2061   if (params)
2062     ap.params = *params;
2063   else
2064     gst_allocation_params_init (&ap.params);
2065
2066   g_array_index (array, AllocationParam, index) = ap;
2067 }
2068
2069 /**
2070  * gst_query_remove_nth_allocation_param:
2071  * @query: a GST_QUERY_ALLOCATION type query #GstQuery
2072  * @index: position in the allocation param array to remove
2073  *
2074  * Remove the allocation param at @index of the allocation param array.
2075  *
2076  * Since: 1.2
2077  */
2078 void
2079 gst_query_remove_nth_allocation_param (GstQuery * query, guint index)
2080 {
2081   GArray *array;
2082   GstStructure *structure;
2083
2084   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ALLOCATION);
2085   g_return_if_fail (gst_query_is_writable (query));
2086
2087   structure = GST_QUERY_STRUCTURE (query);
2088   array =
2089       ensure_array (structure, GST_QUARK (ALLOCATOR), sizeof (AllocationParam),
2090       (GDestroyNotify) allocation_param_free);
2091   g_return_if_fail (index < array->len);
2092
2093   g_array_remove_index (array, index);
2094 }
2095
2096 /**
2097  * gst_query_new_scheduling:
2098  *
2099  * Constructs a new query object for querying the scheduling properties.
2100  *
2101  * Free-function: gst_query_unref()
2102  *
2103  * Returns: (transfer full): a new #GstQuery
2104  */
2105 GstQuery *
2106 gst_query_new_scheduling (void)
2107 {
2108   GstQuery *query;
2109   GstStructure *structure;
2110
2111   structure = gst_structure_new_id (GST_QUARK (QUERY_SCHEDULING),
2112       GST_QUARK (FLAGS), GST_TYPE_SCHEDULING_FLAGS, 0,
2113       GST_QUARK (MINSIZE), G_TYPE_INT, 1,
2114       GST_QUARK (MAXSIZE), G_TYPE_INT, -1,
2115       GST_QUARK (ALIGN), G_TYPE_INT, 0, NULL);
2116   query = gst_query_new_custom (GST_QUERY_SCHEDULING, structure);
2117
2118   return query;
2119 }
2120
2121 /**
2122  * gst_query_set_scheduling:
2123  * @query: A valid #GstQuery of type GST_QUERY_SCHEDULING.
2124  * @flags: #GstSchedulingFlags
2125  * @minsize: the suggested minimum size of pull requests
2126  * @maxsize: the suggested maximum size of pull requests
2127  * @align: the suggested alignment of pull requests
2128  *
2129  * Set the scheduling properties.
2130  */
2131 void
2132 gst_query_set_scheduling (GstQuery * query, GstSchedulingFlags flags,
2133     gint minsize, gint maxsize, gint align)
2134 {
2135   GstStructure *structure;
2136
2137   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING);
2138   g_return_if_fail (gst_query_is_writable (query));
2139
2140   structure = GST_QUERY_STRUCTURE (query);
2141   gst_structure_id_set (structure,
2142       GST_QUARK (FLAGS), GST_TYPE_SCHEDULING_FLAGS, flags,
2143       GST_QUARK (MINSIZE), G_TYPE_INT, minsize,
2144       GST_QUARK (MAXSIZE), G_TYPE_INT, maxsize,
2145       GST_QUARK (ALIGN), G_TYPE_INT, align, NULL);
2146 }
2147
2148 /**
2149  * gst_query_parse_scheduling:
2150  * @query: A valid #GstQuery of type GST_QUERY_SCHEDULING.
2151  * @flags: (out) (allow-none): #GstSchedulingFlags
2152  * @minsize: (out) (allow-none): the suggested minimum size of pull requests
2153  * @maxsize: (out) (allow-none): the suggested maximum size of pull requests:
2154  * @align: (out) (allow-none): the suggested alignment of pull requests
2155  *
2156  * Set the scheduling properties.
2157  */
2158 void
2159 gst_query_parse_scheduling (GstQuery * query, GstSchedulingFlags * flags,
2160     gint * minsize, gint * maxsize, gint * align)
2161 {
2162   GstStructure *structure;
2163
2164   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING);
2165
2166   structure = GST_QUERY_STRUCTURE (query);
2167   gst_structure_id_get (structure,
2168       GST_QUARK (FLAGS), GST_TYPE_SCHEDULING_FLAGS, flags,
2169       GST_QUARK (MINSIZE), G_TYPE_INT, minsize,
2170       GST_QUARK (MAXSIZE), G_TYPE_INT, maxsize,
2171       GST_QUARK (ALIGN), G_TYPE_INT, align, NULL);
2172 }
2173
2174 /**
2175  * gst_query_add_scheduling_mode:
2176  * @query: a GST_QUERY_SCHEDULING type query #GstQuery
2177  * @mode: a #GstPadMode
2178  *
2179  * Add @mode as one of the supported scheduling modes to @query.
2180  */
2181 void
2182 gst_query_add_scheduling_mode (GstQuery * query, GstPadMode mode)
2183 {
2184   GstStructure *structure;
2185   GArray *array;
2186
2187   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING);
2188   g_return_if_fail (gst_query_is_writable (query));
2189
2190   structure = GST_QUERY_STRUCTURE (query);
2191   array =
2192       ensure_array (structure, GST_QUARK (MODES), sizeof (GstPadMode), NULL);
2193
2194   g_array_append_val (array, mode);
2195 }
2196
2197 /**
2198  * gst_query_get_n_scheduling_modes:
2199  * @query: a GST_QUERY_SCHEDULING type query #GstQuery
2200  *
2201  * Retrieve the number of values currently stored in the
2202  * scheduling mode array of the query's structure.
2203  *
2204  * Returns: the scheduling mode array size as a #guint.
2205  */
2206 guint
2207 gst_query_get_n_scheduling_modes (GstQuery * query)
2208 {
2209   GArray *array;
2210   GstStructure *structure;
2211
2212   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING, 0);
2213
2214   structure = GST_QUERY_STRUCTURE (query);
2215   array =
2216       ensure_array (structure, GST_QUARK (MODES), sizeof (GstPadMode), NULL);
2217
2218   return array->len;
2219 }
2220
2221 /**
2222  * gst_query_parse_nth_scheduling_mode:
2223  * @query: a GST_QUERY_SCHEDULING type query #GstQuery
2224  * @index: position in the scheduling modes array to read
2225  *
2226  * Parse an available query and get the scheduling mode
2227  * at @index of the scheduling modes array.
2228  *
2229  * Returns: a #GstPadMode of the scheduling mode at @index.
2230  */
2231 GstPadMode
2232 gst_query_parse_nth_scheduling_mode (GstQuery * query, guint index)
2233 {
2234   GstStructure *structure;
2235   GArray *array;
2236
2237   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING,
2238       GST_PAD_MODE_NONE);
2239
2240   structure = GST_QUERY_STRUCTURE (query);
2241   array =
2242       ensure_array (structure, GST_QUARK (MODES), sizeof (GstPadMode), NULL);
2243   g_return_val_if_fail (index < array->len, GST_PAD_MODE_NONE);
2244
2245   return g_array_index (array, GstPadMode, index);
2246 }
2247
2248 /**
2249  * gst_query_has_scheduling_mode:
2250  * @query: a GST_QUERY_SCHEDULING type query #GstQuery
2251  * @mode: the scheduling mode
2252  *
2253  * Check if @query has scheduling mode set.
2254  *
2255  * <note>
2256  *   <para>
2257  *     When checking if upstream supports pull mode, it is usually not
2258  *     enough to just check for GST_PAD_MODE_PULL with this function, you
2259  *     also want to check whether the scheduling flags returned by
2260  *     gst_query_parse_scheduling() have the seeking flag set (meaning
2261  *     random access is supported, not only sequential pulls).
2262  *   </para>
2263  * </note>
2264  *
2265  * Returns: %TRUE when @mode is in the list of scheduling modes.
2266  */
2267 gboolean
2268 gst_query_has_scheduling_mode (GstQuery * query, GstPadMode mode)
2269 {
2270   GstStructure *structure;
2271   GArray *array;
2272   guint i, len;
2273
2274   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING, FALSE);
2275
2276   structure = GST_QUERY_STRUCTURE (query);
2277   array =
2278       ensure_array (structure, GST_QUARK (MODES), sizeof (GstPadMode), NULL);
2279
2280   len = array->len;
2281   for (i = 0; i < len; i++) {
2282     if (mode == g_array_index (array, GstPadMode, i))
2283       return TRUE;
2284   }
2285   return FALSE;
2286 }
2287
2288 /**
2289  * gst_query_has_scheduling_mode_with_flags:
2290  * @query: a GST_QUERY_SCHEDULING type query #GstQuery
2291  * @mode: the scheduling mode
2292  * @flags: #GstSchedulingFlags
2293  *
2294  * Check if @query has scheduling mode set and @flags is set in
2295  * query scheduling flags.
2296  *
2297  * Returns: %TRUE when @mode is in the list of scheduling modes
2298  *    and @flags are compatible with query flags.
2299  */
2300 gboolean
2301 gst_query_has_scheduling_mode_with_flags (GstQuery * query, GstPadMode mode,
2302     GstSchedulingFlags flags)
2303 {
2304   GstSchedulingFlags sched_flags;
2305
2306   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_SCHEDULING, FALSE);
2307
2308   gst_query_parse_scheduling (query, &sched_flags, NULL, NULL, NULL);
2309
2310   return ((flags & sched_flags) == flags) &&
2311       gst_query_has_scheduling_mode (query, mode);
2312 }
2313
2314 /**
2315  * gst_query_new_accept_caps:
2316  * @caps: a fixed #GstCaps
2317  *
2318  * Constructs a new query object for querying if @caps are accepted.
2319  *
2320  * Free-function: gst_query_unref()
2321  *
2322  * Returns: (transfer full): a new #GstQuery
2323  */
2324 GstQuery *
2325 gst_query_new_accept_caps (GstCaps * caps)
2326 {
2327   GstQuery *query;
2328   GstStructure *structure;
2329
2330   g_return_val_if_fail (gst_caps_is_fixed (caps), NULL);
2331
2332   structure = gst_structure_new_id (GST_QUARK (QUERY_ACCEPT_CAPS),
2333       GST_QUARK (CAPS), GST_TYPE_CAPS, caps,
2334       GST_QUARK (RESULT), G_TYPE_BOOLEAN, FALSE, NULL);
2335   query = gst_query_new_custom (GST_QUERY_ACCEPT_CAPS, structure);
2336
2337   return query;
2338 }
2339
2340 /**
2341  * gst_query_parse_accept_caps:
2342  * @query: The query to parse
2343  * @caps: (out) (transfer none): A pointer to the caps
2344  *
2345  * Get the caps from @query. The caps remains valid as long as @query remains
2346  * valid.
2347  */
2348 void
2349 gst_query_parse_accept_caps (GstQuery * query, GstCaps ** caps)
2350 {
2351   GstStructure *structure;
2352
2353   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ACCEPT_CAPS);
2354   g_return_if_fail (caps != NULL);
2355
2356   structure = GST_QUERY_STRUCTURE (query);
2357   *caps = g_value_get_boxed (gst_structure_id_get_value (structure,
2358           GST_QUARK (CAPS)));
2359 }
2360
2361 /**
2362  * gst_query_set_accept_caps_result:
2363  * @query: a GST_QUERY_ACCEPT_CAPS type query #GstQuery
2364  * @result: the result to set
2365  *
2366  * Set @result as the result for the @query.
2367  */
2368 void
2369 gst_query_set_accept_caps_result (GstQuery * query, gboolean result)
2370 {
2371   GstStructure *structure;
2372
2373   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ACCEPT_CAPS);
2374   g_return_if_fail (gst_query_is_writable (query));
2375
2376   structure = GST_QUERY_STRUCTURE (query);
2377   gst_structure_id_set (structure,
2378       GST_QUARK (RESULT), G_TYPE_BOOLEAN, result, NULL);
2379 }
2380
2381 /**
2382  * gst_query_parse_accept_caps_result:
2383  * @query: a GST_QUERY_ACCEPT_CAPS type query #GstQuery
2384  * @result: location for the result
2385  *
2386  * Parse the result from @query and store in @result.
2387  */
2388 void
2389 gst_query_parse_accept_caps_result (GstQuery * query, gboolean * result)
2390 {
2391   GstStructure *structure;
2392
2393   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_ACCEPT_CAPS);
2394
2395   structure = GST_QUERY_STRUCTURE (query);
2396   gst_structure_id_get (structure,
2397       GST_QUARK (RESULT), G_TYPE_BOOLEAN, result, NULL);
2398 }
2399
2400 /**
2401  * gst_query_new_caps:
2402  * @filter: a filter
2403  *
2404  * Constructs a new query object for querying the caps.
2405  *
2406  * The CAPS query should return the allowable caps for a pad in the context
2407  * of the element's state, its link to other elements, and the devices or files
2408  * it has opened. These caps must be a subset of the pad template caps. In the
2409  * NULL state with no links, the CAPS query should ideally return the same caps
2410  * as the pad template. In rare circumstances, an object property can affect
2411  * the caps returned by the CAPS query, but this is discouraged.
2412  *
2413  * For most filters, the caps returned by CAPS query is directly affected by the
2414  * allowed caps on other pads. For demuxers and decoders, the caps returned by
2415  * the srcpad's getcaps function is directly related to the stream data. Again,
2416  * the CAPS query should return the most specific caps it reasonably can, since this
2417  * helps with autoplugging.
2418  *
2419  * The @filter is used to restrict the result caps, only the caps matching
2420  * @filter should be returned from the CAPS query. Specifying a filter might
2421  * greatly reduce the amount of processing an element needs to do.
2422  *
2423  * Free-function: gst_query_unref()
2424  *
2425  * Returns: (transfer full): a new #GstQuery
2426  */
2427 GstQuery *
2428 gst_query_new_caps (GstCaps * filter)
2429 {
2430   GstQuery *query;
2431   GstStructure *structure;
2432
2433   structure = gst_structure_new_id (GST_QUARK (QUERY_CAPS),
2434       GST_QUARK (FILTER), GST_TYPE_CAPS, filter,
2435       GST_QUARK (CAPS), GST_TYPE_CAPS, NULL, NULL);
2436   query = gst_query_new_custom (GST_QUERY_CAPS, structure);
2437
2438   return query;
2439 }
2440
2441 /**
2442  * gst_query_parse_caps:
2443  * @query: The query to parse
2444  * @filter: (out) (transfer none): A pointer to the caps filter
2445  *
2446  * Get the filter from the caps @query. The caps remains valid as long as
2447  * @query remains valid.
2448  */
2449 void
2450 gst_query_parse_caps (GstQuery * query, GstCaps ** filter)
2451 {
2452   GstStructure *structure;
2453
2454   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CAPS);
2455   g_return_if_fail (filter != NULL);
2456
2457   structure = GST_QUERY_STRUCTURE (query);
2458   *filter = g_value_get_boxed (gst_structure_id_get_value (structure,
2459           GST_QUARK (FILTER)));
2460 }
2461
2462 /**
2463  * gst_query_set_caps_result:
2464  * @query: The query to use
2465  * @caps: (in): A pointer to the caps
2466  *
2467  * Set the @caps result in @query.
2468  */
2469 void
2470 gst_query_set_caps_result (GstQuery * query, GstCaps * caps)
2471 {
2472   GstStructure *structure;
2473
2474   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CAPS);
2475   g_return_if_fail (gst_query_is_writable (query));
2476
2477   structure = GST_QUERY_STRUCTURE (query);
2478   gst_structure_id_set (structure, GST_QUARK (CAPS), GST_TYPE_CAPS, caps, NULL);
2479 }
2480
2481 /**
2482  * gst_query_parse_caps_result:
2483  * @query: The query to parse
2484  * @caps: (out) (transfer none): A pointer to the caps
2485  *
2486  * Get the caps result from @query. The caps remains valid as long as
2487  * @query remains valid.
2488  */
2489 void
2490 gst_query_parse_caps_result (GstQuery * query, GstCaps ** caps)
2491 {
2492   GstStructure *structure;
2493
2494   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CAPS);
2495   g_return_if_fail (caps != NULL);
2496
2497   structure = GST_QUERY_STRUCTURE (query);
2498   *caps = g_value_get_boxed (gst_structure_id_get_value (structure,
2499           GST_QUARK (CAPS)));
2500 }
2501
2502 #if 0
2503 void
2504 gst_query_intersect_caps_result (GstQuery * query, GstCaps * filter,
2505     GstCapsIntersectMode mode)
2506 {
2507   GstCaps *res, *caps = NULL;
2508
2509   gst_query_parse_caps_result (query, &caps);
2510   res = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
2511   gst_query_set_caps_result (query, res);
2512   gst_caps_unref (res);
2513 }
2514 #endif
2515
2516 /**
2517  * gst_query_new_drain:
2518  *
2519  * Constructs a new query object for querying the drain state.
2520  *
2521  * Free-function: gst_query_unref()
2522  *
2523  * Returns: (transfer full): a new #GstQuery
2524  */
2525 GstQuery *
2526 gst_query_new_drain (void)
2527 {
2528   GstQuery *query;
2529   GstStructure *structure;
2530
2531   structure = gst_structure_new_id_empty (GST_QUARK (QUERY_DRAIN));
2532   query = gst_query_new_custom (GST_QUERY_DRAIN, structure);
2533
2534   return query;
2535 }
2536
2537 /**
2538  * gst_query_new_context:
2539  * @context_type: Context type to query
2540  *
2541  * Constructs a new query object for querying the pipeline-local context.
2542  *
2543  * Free-function: gst_query_unref()
2544  *
2545  * Returns: (transfer full): a new #GstQuery
2546  *
2547  * Since: 1.2
2548  */
2549 GstQuery *
2550 gst_query_new_context (const gchar * context_type)
2551 {
2552   GstQuery *query;
2553   GstStructure *structure;
2554
2555   g_return_val_if_fail (context_type != NULL, NULL);
2556
2557   structure = gst_structure_new_id (GST_QUARK (QUERY_CONTEXT),
2558       GST_QUARK (CONTEXT_TYPE), G_TYPE_STRING, context_type, NULL);
2559   query = gst_query_new_custom (GST_QUERY_CONTEXT, structure);
2560
2561   return query;
2562 }
2563
2564 /**
2565  * gst_query_set_context:
2566  * @query: a #GstQuery with query type GST_QUERY_CONTEXT
2567  * @context: the requested #GstContext
2568  *
2569  * Answer a context query by setting the requested context.
2570  *
2571  * Since: 1.2
2572  */
2573 void
2574 gst_query_set_context (GstQuery * query, GstContext * context)
2575 {
2576   GstStructure *s;
2577   const gchar *context_type;
2578
2579   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONTEXT);
2580
2581   gst_query_parse_context_type (query, &context_type);
2582   g_return_if_fail (strcmp (gst_context_get_context_type (context),
2583           context_type) == 0);
2584
2585   s = GST_QUERY_STRUCTURE (query);
2586
2587   gst_structure_id_set (s,
2588       GST_QUARK (CONTEXT), GST_TYPE_CONTEXT, context, NULL);
2589 }
2590
2591 /**
2592  * gst_query_parse_context:
2593  * @query: The query to parse
2594  * @context: (out) (transfer none): A pointer to store the #GstContext
2595  *
2596  * Get the context from the context @query. The context remains valid as long as
2597  * @query remains valid.
2598  *
2599  * Since: 1.2
2600  */
2601 void
2602 gst_query_parse_context (GstQuery * query, GstContext ** context)
2603 {
2604   GstStructure *structure;
2605   const GValue *v;
2606
2607   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONTEXT);
2608   g_return_if_fail (context != NULL);
2609
2610   structure = GST_QUERY_STRUCTURE (query);
2611   v = gst_structure_id_get_value (structure, GST_QUARK (CONTEXT));
2612   if (v)
2613     *context = g_value_get_boxed (v);
2614   else
2615     *context = NULL;
2616 }
2617
2618 /**
2619  * gst_query_parse_context_type:
2620  * @query: a GST_QUERY_CONTEXT type query
2621  * @context_type: (out) (transfer none) (allow-none): the context type, or %NULL
2622  *
2623  * Parse a context type from an existing GST_QUERY_CONTEXT query.
2624  *
2625  * Returns: a #gboolean indicating if the parsing succeeded.
2626  *
2627  * Since: 1.2
2628  */
2629 gboolean
2630 gst_query_parse_context_type (GstQuery * query, const gchar ** context_type)
2631 {
2632   GstStructure *structure;
2633   const GValue *value;
2634
2635   g_return_val_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONTEXT, FALSE);
2636
2637   structure = GST_QUERY_STRUCTURE (query);
2638
2639   if (context_type) {
2640     value = gst_structure_id_get_value (structure, GST_QUARK (CONTEXT_TYPE));
2641     *context_type = g_value_get_string (value);
2642   }
2643
2644   return TRUE;
2645 }