/* GStreamer

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

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

 *                    2005 Wim Taymans <wim@fluendo.com>

 *

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

 *

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

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

 * License as published by the Free Software Foundation; either

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

 *

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

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

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

 * Library General Public License for more details.

 *

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

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

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:gstquery

 * @short_description: Dynamically register new query types. Provide functions

 *                     to create queries, and to set and parse values in them.

 * @see_also: #GstPad, #GstElement

 *

 * GstQuery functions are used to register a new query types to the gstreamer

 * core.

 * Query types can be used to perform queries on pads and elements.

 *

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

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

 * gst_query_parse_xxx() helpers.

 *

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

 * 

 * <example>

 *  <title>Query duration on a pipeline</title>

 *  <programlisting>

 *  GstQuery *query;

 *  gboolean res;

 *  query = gst_query_new_duration (GST_FORMAT_TIME);

 *  res = gst_element_query (pipeline, query);

 *  if (res) {

 *    gint64 duration;

 *    gst_query_parse_duration (query, NULL, &duration);

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

 *  }

 *  else {

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

 *  }

 *  gst_query_unref (query);

 *  </programlisting>

 * </example>

 *

 * Last reviewed on 2006-02-14 (0.10.4)

 */

#include "gst_private.h"

#include "gstinfo.h"

#include "gstquery.h"

#include "gstvalue.h"

#include "gstenumtypes.h"

#include "gstquark.h"

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

GST_DEBUG_CATEGORY_STATIC (gst_query_debug);

#define GST_CAT_DEFAULT gst_query_debug

static void gst_query_finalize (GstQuery * query);

static GstQuery *_gst_query_copy (GstQuery * query);

static GStaticMutex mutex = G_STATIC_MUTEX_INIT;

static GList *_gst_queries = NULL;

static GHashTable *_nick_to_query = NULL;

static GHashTable *_query_type_to_nick = NULL;

static guint32 _n_values = 1;   /* we start from 1 because 0 reserved for NONE */

static GstMiniObjectClass *parent_class = NULL;

static GstQueryTypeDefinition standard_definitions[] = {

  {GST_QUERY_POSITION, "position", "Current position", 0},

  {GST_QUERY_DURATION, "duration", "Total duration", 0},

  {GST_QUERY_LATENCY, "latency", "Latency", 0},

  {GST_QUERY_JITTER, "jitter", "Jitter", 0},

  {GST_QUERY_RATE, "rate", "Configured rate 1000000 = 1", 0},

  {GST_QUERY_SEEKING, "seeking", "Seeking capabilities and parameters", 0},

  {GST_QUERY_SEGMENT, "segment", "currently configured segment", 0},

  {GST_QUERY_CONVERT, "convert", "Converting between formats", 0},

  {GST_QUERY_FORMATS, "formats", "Supported formats for conversion", 0},

  {0, NULL, NULL, 0}

};

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

_gst_query_initialize (void)

{

  GstQueryTypeDefinition *standards = standard_definitions;

  GST_CAT_INFO (GST_CAT_GST_INIT, "init queries");

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

  g_static_mutex_lock (&mutex);

  if (_nick_to_query == NULL) {

    _nick_to_query = g_hash_table_new (g_str_hash, g_str_equal);

    _query_type_to_nick = g_hash_table_new (NULL, NULL);

  }

  while (standards->nick) {

    standards->quark = g_quark_from_static_string (standards->nick);

    g_hash_table_insert (_nick_to_query, standards->nick, standards);

    g_hash_table_insert (_query_type_to_nick,

        GINT_TO_POINTER (standards->value), standards);

    _gst_queries = g_list_append (_gst_queries, standards);

    standards++;

    _n_values++;

  }

  g_static_mutex_unlock (&mutex);

  g_type_class_ref (gst_query_get_type ());

}

/**

 * gst_query_type_get_name:

 * @query: the query type

 *

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

 *

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

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

const gchar *

gst_query_type_get_name (GstQueryType query)

{

  const GstQueryTypeDefinition *def;

  def = gst_query_type_get_details (query);

  return def->nick;

}

/**

 * gst_query_type_to_quark:

 * @query: the query type

 *

 * Get the unique quark for the given query type.

 *

 * Returns: the quark associated with the query type

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GQuark

gst_query_type_to_quark (GstQueryType query)

{

  const GstQueryTypeDefinition *def;

  def = gst_query_type_get_details (query);

  return def->quark;

}

{

}

static void

{

}

static void

gst_query_finalize (GstQuery * query)

{

  g_return_if_fail (query != NULL);

  if (query->structure) {

    gst_structure_set_parent_refcount (query->structure, NULL);

    gst_structure_free (query->structure);

  }

}

static GstQuery *

_gst_query_copy (GstQuery * query)

{

  GstQuery *copy;

  copy = (GstQuery *) gst_mini_object_new (GST_TYPE_QUERY);

  copy->type = query->type;

  if (query->structure) {

    copy->structure = gst_structure_copy (query->structure);

    gst_structure_set_parent_refcount (copy->structure,

        &query->mini_object.refcount);

  }

  return copy;

}

/**

 * gst_query_type_register:

 * @nick: The nick of the new query

 * @description: The description of the new query

 *

 * Create a new GstQueryType based on the nick or return an

 * already registered query with that nick

 *

 * Returns: A new GstQueryType or an already registered query

 * with the same nick.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstQueryType

gst_query_type_register (const gchar * nick, const gchar * description)

{

  GstQueryTypeDefinition *query;

  GstQueryType lookup;

  g_return_val_if_fail (nick != NULL, 0);

  g_return_val_if_fail (description != NULL, 0);

  lookup = gst_query_type_get_by_nick (nick);

  if (lookup != GST_QUERY_NONE)

    return lookup;

  query = g_new0 (GstQueryTypeDefinition, 1);

  query->value = _n_values;

  query->nick = g_strdup (nick);

  query->description = g_strdup (description);

  query->quark = g_quark_from_static_string (query->nick);

  g_static_mutex_lock (&mutex);

  g_hash_table_insert (_nick_to_query, query->nick, query);

  g_hash_table_insert (_query_type_to_nick, GINT_TO_POINTER (query->value),

      query);

  _gst_queries = g_list_append (_gst_queries, query);

  _n_values++;

  g_static_mutex_unlock (&mutex);

  return query->value;

}

/**

 * gst_query_type_get_by_nick:

 * @nick: The nick of the query

 *

 * Get the query type registered with @nick.

 *

 * Returns: The query registered with @nick or #GST_QUERY_NONE

 * if the query was not registered.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstQueryType

gst_query_type_get_by_nick (const gchar * nick)

{

  GstQueryTypeDefinition *query;

  g_return_val_if_fail (nick != NULL, 0);

  g_static_mutex_lock (&mutex);

  query = g_hash_table_lookup (_nick_to_query, nick);

  g_static_mutex_unlock (&mutex);

  if (query != NULL)

    return query->value;

  else

    return GST_QUERY_NONE;

}

/**

 * gst_query_types_contains:

 * @types: The query array to search

 * @type: the #GstQueryType to find

 *

 * See if the given #GstQueryType is inside the @types query types array.

 *

 * Returns: TRUE if the type is found inside the array

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_query_types_contains (const GstQueryType * types, GstQueryType type)

{

  if (!types)

    return FALSE;

  while (*types) {

    if (*types == type)

      return TRUE;

    types++;

  }

  return FALSE;

}

/**

 * gst_query_type_get_details:

 * @type: a #GstQueryType

 *

 * Get details about the given #GstQueryType.

 *

 * Returns: The #GstQueryTypeDefinition for @type or NULL on failure.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

const GstQueryTypeDefinition *

gst_query_type_get_details (GstQueryType type)

{

  const GstQueryTypeDefinition *result;

  g_static_mutex_lock (&mutex);

  result = g_hash_table_lookup (_query_type_to_nick, GINT_TO_POINTER (type));

  g_static_mutex_unlock (&mutex);

  return result;

}

/**

 * gst_query_type_iterate_definitions:

 *

 * Get a #GstIterator of all the registered query types. The definitions 

 * iterated over are read only.

 *

 * Returns: A #GstIterator of #GstQueryTypeDefinition.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstIterator *

gst_query_type_iterate_definitions (void)

{

  GstIterator *result;

  g_static_mutex_lock (&mutex);

  /* FIXME: register a boxed type for GstQueryTypeDefinition */

  result = gst_iterator_new_list (G_TYPE_POINTER,

      g_static_mutex_get_mutex (&mutex), &_n_values, &_gst_queries,

      NULL, NULL, NULL);

  g_static_mutex_unlock (&mutex);

  return result;

}

static GstQuery *

gst_query_new (GstQueryType type, GstStructure * structure)

{

  GstQuery *query;

  query = (GstQuery *) gst_mini_object_new (GST_TYPE_QUERY);

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

  query->type = type;

  if (structure) {

    query->structure = structure;

    gst_structure_set_parent_refcount (query->structure,

        &query->mini_object.refcount);

  } else {

    query->structure = NULL;

  }

  return query;

}

/**

 * gst_query_new_position:

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

 *

 * Constructs a new query stream position query object. Use gst_query_unref()

 * when done with it. A position query is used to query the current position

 * of playback in the streams, in some format.

 *

 * Returns: A #GstQuery

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstQuery *

gst_query_new_position (GstFormat format)

{

  GstQuery *query;

  GstStructure *structure;

      GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,

  query = gst_query_new (GST_QUERY_POSITION, structure);

  return query;

}

/**

 * gst_query_set_position:

 * @query: a #GstQuery with query type GST_QUERY_POSITION

 * @format: the requested #GstFormat

 * @cur: the position to set

 *

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

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

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

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_POSITION);

  structure = gst_query_get_structure (query);

  gst_structure_id_set (structure,

      GST_QUARK (FORMAT), GST_TYPE_FORMAT, format,

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

}

/**

 * gst_query_parse_position:

 * @query: a #GstQuery

 * @format: the storage for the #GstFormat of the position values (may be NULL)

 * @cur: the storage for the current position (may be NULL)

 *

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

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

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

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

{

  GstStructure *structure;

  g_return_if_fail (GST_QUERY_TYPE (query) == GST_QUERY_POSITION);

  structure = gst_query_get_structure (query);

  if (format)

    *format = g_value_get_enum (gst_structure_id_get_value (structure,

            GST_QUARK (FORMAT)));

  if (cur)

    *cur = g_value_get_int64 (gst_structure_id_get_value (structure,

            GST_QUARK (CURRENT)));

}

/**

 * gst_query_new_duration:

 * @format: the #GstFormat for this duration query

 *

 * Constructs a new stream duration query object to query in the given format. 

 * Use gst_query_unref() when done with it. A duration query will give the

 * total length of the stream.

 *