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
   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., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23 /**
  24  * SECTION:gstquery
  25  * @short_description: Dynamically register new query types and parse results
  26  * @see_also: #GstPad, #GstElement
  27  *
  28  * GstQuery functions are used to register a new query types to the gstreamer core.
  29  * Query types can be used to perform queries on pads and elements.
  30  *
  31  * Query answer can be parsed using gst_query_parse_xxx() helpers.
  32  */
  33 #include <string.h>
  34
  35 #include "gst_private.h"
  36 #include "gstquery.h"
  37 #include "gstenumtypes.h"
  38
  39 GST_DEBUG_CATEGORY_STATIC (gst_query_debug);
  40 #define GST_CAT_DEFAULT gst_query_debug
  41
  42 static void gst_query_init (GTypeInstance * instance, gpointer g_class);
  43 static void gst_query_class_init (gpointer g_class, gpointer class_data);
  44 static void gst_query_finalize (GstQuery * query);
  45 static GstQuery *_gst_query_copy (GstQuery * query);
  46
  47
  48 static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
  49 static GList *_gst_queries = NULL;
  50 static GHashTable *_nick_to_query = NULL;
  51 static GHashTable *_query_type_to_nick = NULL;
  52 static guint32 _n_values = 1;   /* we start from 1 because 0 reserved for NONE */
  53
  54 static GstQueryTypeDefinition standard_definitions[] = {
  55   {GST_QUERY_POSITION, "position", "Current Position"},
  56   {GST_QUERY_LATENCY, "latency", "Latency"},
  57   {GST_QUERY_JITTER, "jitter", "Jitter"},
  58   {GST_QUERY_RATE, "rate", "Configured rate 1000000 = 1"},
  59   {GST_QUERY_SEEKING, "seeking", "Seeking capabilities and parameters"},
  60   {GST_QUERY_CONVERT, "convert", "Converting between formats"},
  61   {GST_QUERY_FORMATS, "formats", "Supported formats for conversion"},
  62   {0, NULL, NULL}
  63 };
  64
  65 void
  66 _gst_query_initialize (void)
  67 {
  68   GstQueryTypeDefinition *standards = standard_definitions;
  69
  70   GST_CAT_INFO (GST_CAT_GST_INIT, "init queries");
  71
  72   GST_DEBUG_CATEGORY_INIT (gst_query_debug, "query", 0, "query system");
  73
  74   g_static_mutex_lock (&mutex);
  75   if (_nick_to_query == NULL) {
  76     _nick_to_query = g_hash_table_new (g_str_hash, g_str_equal);
  77     _query_type_to_nick = g_hash_table_new (NULL, NULL);
  78   }
  79
  80   while (standards->nick) {
  81     g_hash_table_insert (_nick_to_query, standards->nick, standards);
  82     g_hash_table_insert (_query_type_to_nick,
  83         GINT_TO_POINTER (standards->value), standards);
  84
  85     _gst_queries = g_list_append (_gst_queries, standards);
  86     standards++;
  87     _n_values++;
  88   }
  89   g_static_mutex_unlock (&mutex);
  90
  91   gst_query_get_type ();
  92 }
  93
  94 GType
  95 gst_query_get_type (void)
  96 {
  97   static GType _gst_query_type;
  98
  99   if (G_UNLIKELY (_gst_query_type == 0)) {
 100     static const GTypeInfo query_info = {
 101       sizeof (GstQueryClass),
 102       NULL,
 103       NULL,
 104       gst_query_class_init,
 105       NULL,
 106       NULL,
 107       sizeof (GstQuery),
 108       0,
 109       gst_query_init,
 110       NULL
 111     };
 112
 113     _gst_query_type = g_type_register_static (GST_TYPE_MINI_OBJECT,
 114         "GstQuery", &query_info, 0);
 115   }
 116   return _gst_query_type;
 117 }
 118
 119 static void
 120 gst_query_class_init (gpointer g_class, gpointer class_data)
 121 {
 122   GstQueryClass *query_class = GST_QUERY_CLASS (g_class);
 123
 124   query_class->mini_object_class.copy =
 125       (GstMiniObjectCopyFunction) _gst_query_copy;
 126   query_class->mini_object_class.finalize =
 127       (GstMiniObjectFinalizeFunction) gst_query_finalize;
 128
 129 }
 130
 131 static void
 132 gst_query_finalize (GstQuery * query)
 133 {
 134   g_return_if_fail (query != NULL);
 135
 136   if (query->structure) {
 137     gst_structure_set_parent_refcount (query->structure, NULL);
 138     gst_structure_free (query->structure);
 139   }
 140 }
 141
 142 static void
 143 gst_query_init (GTypeInstance * instance, gpointer g_class)
 144 {
 145
 146 }
 147
 148 static GstQuery *
 149 _gst_query_copy (GstQuery * query)
 150 {
 151   GstQuery *copy;
 152
 153   copy = (GstQuery *) gst_mini_object_new (GST_TYPE_QUERY);
 154
 155   copy->type = query->type;
 156
 157   if (query->structure) {
 158     copy->structure = gst_structure_copy (query->structure);
 159     gst_structure_set_parent_refcount (copy->structure,
 160         &query->mini_object.refcount);
 161   }
 162
 163   return copy;
 164 }
 165
 166
 167
 168 /**
 169  * gst_query_type_register:
 170  * @nick: The nick of the new query
 171  * @description: The description of the new query
 172  *
 173  * Create a new GstQueryType based on the nick or return an
 174  * allrady registered query with that nick
 175  *
 176  * Returns: A new GstQueryType or an already registered query
 177  * with the same nick.
 178  */
 179 GstQueryType
 180 gst_query_type_register (const gchar * nick, const gchar * description)
 181 {
 182   GstQueryTypeDefinition *query;
 183   GstQueryType lookup;
 184
 185   g_return_val_if_fail (nick != NULL, 0);
 186   g_return_val_if_fail (description != NULL, 0);
 187
 188   lookup = gst_query_type_get_by_nick (nick);
 189   if (lookup != GST_QUERY_NONE)
 190     return lookup;
 191
 192   query = g_new0 (GstQueryTypeDefinition, 1);
 193   query->value = _n_values;
 194   query->nick = g_strdup (nick);
 195   query->description = g_strdup (description);
 196
 197   g_static_mutex_lock (&mutex);
 198   g_hash_table_insert (_nick_to_query, query->nick, query);
 199   g_hash_table_insert (_query_type_to_nick, GINT_TO_POINTER (query->value),
 200       query);
 201   _gst_queries = g_list_append (_gst_queries, query);
 202   _n_values++;
 203   g_static_mutex_unlock (&mutex);
 204
 205   return query->value;
 206 }
 207
 208 /**
 209  * gst_query_type_get_by_nick:
 210  * @nick: The nick of the query
 211  *
 212  * Return the query registered with the given nick.
 213  *
 214  * Returns: The query with @nick or GST_QUERY_NONE
 215  * if the query was not registered.
 216  */
 217 GstQueryType
 218 gst_query_type_get_by_nick (const gchar * nick)
 219 {
 220   GstQueryTypeDefinition *query;
 221
 222   g_return_val_if_fail (nick != NULL, 0);
 223
 224   g_static_mutex_lock (&mutex);
 225   query = g_hash_table_lookup (_nick_to_query, nick);
 226   g_static_mutex_unlock (&mutex);
 227
 228   if (query != NULL)
 229     return query->value;
 230   else
 231     return GST_QUERY_NONE;
 232 }
 233
 234 /**
 235  * gst_query_types_contains:
 236  * @types: The query array to search
 237  * @type: the querytype to find
 238  *
 239  * See if the given query is inside the query array.
 240  *
 241  * Returns: TRUE if the query is found inside the array
 242  */
 243 gboolean
 244 gst_query_types_contains (const GstQueryType * types, GstQueryType type)
 245 {
 246   if (!types)
 247     return FALSE;
 248
 249   while (*types) {
 250     if (*types == type)
 251       return TRUE;
 252
 253     types++;
 254   }
 255   return FALSE;
 256 }
 257
 258
 259 /**
 260  * gst_query_type_get_details:
 261  * @type: The query to get details of
 262  *
 263  * Get details about the given query.
 264  *
 265  * Returns: The #GstQueryTypeDefinition for @query or NULL on failure.
 266  */
 267 const GstQueryTypeDefinition *
 268 gst_query_type_get_details (GstQueryType type)
 269 {
 270   const GstQueryTypeDefinition *result;
 271
 272   g_static_mutex_lock (&mutex);
 273   result = g_hash_table_lookup (_query_type_to_nick, GINT_TO_POINTER (type));
 274   g_static_mutex_unlock (&mutex);
 275
 276   return result;
 277 }
 278
 279 /**
 280  * gst_query_type_iterate_definitions:
 281  *
 282  * Get an Iterator of all the registered query types. The querytype
 283  * definition is read only.
 284  *
 285  * Returns: A #GstIterator of #GstQueryTypeDefinition.
 286  */
 287 GstIterator *
 288 gst_query_type_iterate_definitions (void)
 289 {
 290   GstIterator *result;
 291
 292   g_static_mutex_lock (&mutex);
 293   result = gst_iterator_new_list (g_static_mutex_get_mutex (&mutex),
 294       &_n_values, &_gst_queries, NULL, NULL, NULL);
 295   g_static_mutex_unlock (&mutex);
 296
 297   return result;
 298 }
 299
 300 static GstQuery *
 301 gst_query_new (GstQueryType type, GstStructure * structure)
 302 {
 303   GstQuery *query;
 304
 305   query = (GstQuery *) gst_mini_object_new (GST_TYPE_QUERY);
 306
 307   GST_DEBUG ("creating new query %p %d", query, type);
 308
 309   query->type = type;
 310
 311   if (structure) {
 312     query->structure = structure;
 313     gst_structure_set_parent_refcount (query->structure,
 314         &query->mini_object.refcount);
 315   } else {
 316     query->structure = NULL;
 317   }
 318
 319   return query;
 320 }
 321
 322 /**
 323  * gst_query_new_position:
 324  * @format: the default #GstFormat for the new query
 325  *
 326  * Constructs a new query stream position query object. Use gst_query_unref()
 327  * when done with it.
 328  *
 329  * Returns: A new #GstQuery
 330  */
 331 GstQuery *
 332 gst_query_new_position (GstFormat format)
 333 {
 334   GstQuery *query;
 335   GstStructure *structure;
 336
 337   structure = gst_structure_new ("GstQueryPosition",
 338       "format", GST_TYPE_FORMAT, format,
 339       "cur", G_TYPE_INT64, (gint64) - 1,
 340       "end", G_TYPE_INT64, (gint64) - 1, NULL);
 341   query = gst_query_new (GST_QUERY_POSITION, structure);
 342
 343   return query;
 344 }
 345
 346 /**
 347  * gst_query_set_position:
 348  * @query: the query to fill in
 349  * @format: the requested #GstFormat
 350  * @cur: the current position
 351  * @end: the end position
 352  *
 353  * Answer a position query by setting the requested values.
 354  */
 355 void
 356 gst_query_set_position (GstQuery * query, GstFormat format,
 357     gint64 cur, gint64 end)
 358 {
 359   GstStructure *structure;
 360
 361   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_POSITION);
 362
 363   structure = gst_query_get_structure (query);
 364   gst_structure_set (structure,
 365       "format", GST_TYPE_FORMAT, format,
 366       "cur", G_TYPE_INT64, cur, "end", G_TYPE_INT64, end, NULL);
 367 }
 368
 369 /**
 370  * gst_query_parse_position:
 371  * @query: the query to fill in
 372  * @format: the requested #GstFormat or NULL for the default (used when creating
 373  * the query)
 374  * @cur: the storage for the current position
 375  * @end: the storage for the end position
 376  *
 377  * Parse a position query answer.
 378  */
 379 void
 380 gst_query_parse_position (GstQuery * query, GstFormat * format,
 381     gint64 * cur, gint64 * end)
 382 {
 383   GstStructure *structure;
 384
 385   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_POSITION);
 386
 387   structure = gst_query_get_structure (query);
 388   if (format)
 389     *format = g_value_get_enum (gst_structure_get_value (structure, "format"));
 390   if (cur)
 391     *cur = g_value_get_int64 (gst_structure_get_value (structure, "cur"));
 392   if (end)
 393     *end = g_value_get_int64 (gst_structure_get_value (structure, "end"));
 394 }
 395
 396 GstQuery *
 397 gst_query_new_convert (GstFormat src_fmt, gint64 value, GstFormat dest_fmt)
 398 {
 399   GstQuery *query;
 400   GstStructure *structure;
 401
 402   g_return_val_if_fail (value >= 0, NULL);
 403
 404   structure = gst_structure_new ("GstQueryConvert",
 405       "src_format", GST_TYPE_FORMAT, src_fmt,
 406       "src_value", G_TYPE_INT64, value,
 407       "dest_format", GST_TYPE_FORMAT, dest_fmt,
 408       "dest_value", G_TYPE_INT64, (gint64) - 1, NULL);
 409   query = gst_query_new (GST_QUERY_CONVERT, structure);
 410
 411   return query;
 412 }
 413
 414 void
 415 gst_query_set_convert (GstQuery * query, GstFormat src_format, gint64 src_value,
 416     GstFormat dest_format, gint64 dest_value)
 417 {
 418   GstStructure *structure;
 419
 420   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONVERT);
 421
 422   structure = gst_query_get_structure (query);
 423   gst_structure_set (structure,
 424       "src_format", GST_TYPE_FORMAT, src_format,
 425       "src_value", G_TYPE_INT64, src_value,
 426       "dest_format", GST_TYPE_FORMAT, dest_format,
 427       "dest_value", G_TYPE_INT64, dest_value, NULL);
 428 }
 429
 430 void
 431 gst_query_parse_convert (GstQuery * query, GstFormat * src_format,
 432     gint64 * src_value, GstFormat * dest_format, gint64 * dest_value)
 433 {
 434   GstStructure *structure;
 435
 436   g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_CONVERT);
 437
 438   structure = gst_query_get_structure (query);
 439   if (src_format)
 440     *src_format =
 441         g_value_get_enum (gst_structure_get_value (structure, "src_format"));
 442   if (src_value)
 443     *src_value =
 444         g_value_get_int64 (gst_structure_get_value (structure, "src_value"));
 445   if (dest_format)
 446     *dest_format =
 447         g_value_get_enum (gst_structure_get_value (structure, "dest_format"));
 448   if (dest_value)
 449     *dest_value =
 450         g_value_get_int64 (gst_structure_get_value (structure, "dest_value"));
 451 }
 452
 453
 454 GstQuery *
 455 gst_query_new_application (GstQueryType type, GstStructure * structure)
 456 {
 457   g_return_val_if_fail (gst_query_type_get_details (type) != NULL, NULL);
 458   g_return_val_if_fail (structure != NULL, NULL);
 459
 460   return gst_query_new (type, structure);
 461 }
 462
 463 GstStructure *
 464 gst_query_get_structure (GstQuery * query)
 465 {
 466   g_return_val_if_fail (GST_IS_QUERY (query), NULL);
 467
 468   return query->structure;
 469 }