/* GStreamer

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

 *               2000 Wim Taymans <wtay@chello.be>

 *               2004 Thomas Vander Stichele <thomas@apestaart.org>

 *

 * gst-inspect.c: tool to inspect the GStreamer registry

 *

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

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include "tools.h"

#include <string.h>

#include <locale.h>

#include <glib/gprintf.h>

static char *_name = NULL;

static int print_element_info (GstElementFactory * factory,

    gboolean print_names);

static void

n_print (const char *format, ...)

{

  va_list args;

  gint retval;

  if (_name)

    g_print (_name);

  va_start (args, format);

  retval = g_vprintf (format, args);

  va_end (args);

}

static gboolean

print_field (GQuark field, const GValue * value, gpointer pfx)

{

  gchar *str = gst_value_serialize (value);

  n_print ("%s  %15s: %s\n", (gchar *) pfx, g_quark_to_string (field), str);

  g_free (str);

  return TRUE;

}

static void

print_caps (const GstCaps * caps, const gchar * pfx)

{

  guint i;

  g_return_if_fail (caps != NULL);

  if (gst_caps_is_any (caps)) {

    n_print ("%sANY\n", pfx);

    return;

  }

  if (gst_caps_is_empty (caps)) {

    n_print ("%sEMPTY\n", pfx);

    return;

  }

  for (i = 0; i < gst_caps_get_size (caps); i++) {

    GstStructure *structure = gst_caps_get_structure (caps, i);

    n_print ("%s%s\n", pfx, gst_structure_get_name (structure));

    gst_structure_foreach (structure, print_field, (gpointer) pfx);

  }

}

#if 0

static void

print_formats (const GstFormat * formats)

{

  while (formats && *formats) {

    const GstFormatDefinition *definition;

    definition = gst_format_get_details (*formats);

    if (definition)

      n_print ("\t\t(%d):\t%s (%s)\n", *formats,

          definition->nick, definition->description);

    else

      n_print ("\t\t(%d):\tUnknown format\n", *formats);

    formats++;

  }

}

#endif

static void

print_query_types (const GstQueryType * types)

{

  while (types && *types) {

    const GstQueryTypeDefinition *definition;

    definition = gst_query_type_get_details (*types);

    if (definition)

      n_print ("\t\t(%d):\t%s (%s)\n", *types,

          definition->nick, definition->description);

    else

      n_print ("\t\t(%d):\tUnknown query format\n", *types);

    types++;

  }

}

#ifndef GST_DISABLE_ENUMTYPES

#if 0

static void

print_event_masks (const GstEventMask * masks)

{

  GType event_type;

  GEnumClass *klass;

  GType event_flags;

  GFlagsClass *flags_class = NULL;

  event_type = gst_event_type_get_type ();

  klass = (GEnumClass *) g_type_class_ref (event_type);

  while (masks && masks->type) {

    GEnumValue *value;

    gint flags = 0, index = 0;

    switch (masks->type) {

      case GST_EVENT_SEEK:

        flags = masks->flags;

        event_flags = gst_seek_type_get_type ();

        flags_class = (GFlagsClass *) g_type_class_ref (event_flags);

        break;

      default:

        break;

    }

    value = g_enum_get_value (klass, masks->type);

    g_print ("\t\t%s ", value->value_nick);

    while (flags) {

      GFlagsValue *value;

      if (flags & 1) {

        value = g_flags_get_first_value (flags_class, 1 << index);

        if (value)

          g_print ("| %s ", value->value_nick);

        else

          g_print ("| ? ");

      }

      flags >>= 1;

      index++;

    }

    g_print ("\n");

    masks++;

  }

}

#endif

#else

static void

print_event_masks (const GstEventMask * masks)

{

}

#endif

static char *

get_rank_name (gint rank)

{

  switch (rank) {

    case GST_RANK_NONE:

      return "none";

    case GST_RANK_MARGINAL:

      return "marginal";

    case GST_RANK_SECONDARY:

      return "secondary";

    case GST_RANK_PRIMARY:

      return "primary";

    default:

      return "unknown";

  }

}

static void

print_factory_details_info (GstElementFactory * factory)

{

  n_print ("Factory Details:\n");

  n_print ("  Long name:\t%s\n", factory->details.longname);

  n_print ("  Class:\t%s\n", factory->details.klass);

  n_print ("  Description:\t%s\n", factory->details.description);

  n_print ("  Author(s):\t%s\n", factory->details.author);

  n_print ("  Rank:\t\t%s (%d)\n",

      get_rank_name (GST_PLUGIN_FEATURE (factory)->rank),

      GST_PLUGIN_FEATURE (factory)->rank);

  n_print ("\n");

}

static void

print_hierarchy (GType type, gint level, gint * maxlevel)

{

  GType parent;

  gint i;

  parent = g_type_parent (type);

  *maxlevel = *maxlevel + 1;

  level++;

  if (parent)

    print_hierarchy (parent, level, maxlevel);

  if (_name)

    g_print (_name);

  for (i = 1; i < *maxlevel - level; i++)

    g_print ("      ");

  if (*maxlevel - level)

    g_print (" +----");

  g_print ("%s\n", g_type_name (type));

  if (level == 1)

    n_print ("\n");

}

static void

print_interfaces (GType type)

{

  guint n_ifaces;

  GType *iface, *ifaces = g_type_interfaces (type, &n_ifaces);

  if (ifaces) {

    if (n_ifaces) {

      if (_name)

        g_print (_name);

      g_print (_("Implemented Interfaces:\n"));

      iface = ifaces;

      while (*iface) {

        if (_name)

          g_print (_name);

        g_print ("  %s\n", g_type_name (*iface));

        iface++;

      }

      if (_name)

        g_print (_name);

      g_print ("\n");

    }

    g_free (ifaces);

  }

}

static void

print_element_properties_info (GstElement * element)

{

  GParamSpec **property_specs;

  guint num_properties, i;

  gboolean readable;

  gboolean first_flag;

  property_specs = g_object_class_list_properties

      (G_OBJECT_GET_CLASS (element), &num_properties);

  n_print ("\n");

  n_print ("Element Properties:\n");

  for (i = 0; i < num_properties; i++) {

    GValue value = { 0, };

    GParamSpec *param = property_specs[i];

    readable = FALSE;

    g_value_init (&value, param->value_type);

    n_print ("  %-20s: %s\n", g_param_spec_get_name (param),

        g_param_spec_get_blurb (param));

    first_flag = TRUE;

    n_print ("%-23.23s flags: ", "");

    if (param->flags & G_PARAM_READABLE) {

      g_object_get_property (G_OBJECT (element), param->name, &value);

      readable = TRUE;

      if (!first_flag)

        g_print (", ");

      else

        first_flag = FALSE;

      g_print (_("readable"));

    }

    if (param->flags & G_PARAM_WRITABLE) {

      if (!first_flag)

        g_print (", ");

      else

        first_flag = FALSE;

      g_print (_("writable"));

    }

    if (param->flags & GST_PARAM_CONTROLLABLE) {

      if (!first_flag)

        g_print (", ");

      else

        first_flag = FALSE;

      g_print (_("controllable"));

    }

    n_print ("\n");

    switch (G_VALUE_TYPE (&value)) {

      case G_TYPE_STRING:

      {

        GParamSpecString *pstring = G_PARAM_SPEC_STRING (param);

        n_print ("%-23.23s String. ", "");

        if (pstring->default_value == NULL)

          g_print ("Default: null ");

        else

          g_print ("Default: \"%s\" ", pstring->default_value);

        if (readable) {

          const char *string_val = g_value_get_string (&value);

          if (string_val == NULL)

            g_print ("Current: null");

          else

            g_print ("Current: \"%s\"", string_val);

        }

        break;

      }

      case G_TYPE_BOOLEAN:

      {

        GParamSpecBoolean *pboolean = G_PARAM_SPEC_BOOLEAN (param);

        n_print ("%-23.23s Boolean. ", "");

        g_print ("Default: %s ", (pboolean->default_value ? "true" : "false"));

        if (readable)

          g_print ("Current: %s",

              (g_value_get_boolean (&value) ? "true" : "false"));

        break;

      }

      case G_TYPE_ULONG:

      {

        GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);

        n_print ("%-23.23s Unsigned Long. ", "");

        g_print ("Range: %lu - %lu Default: %lu ",

            pulong->minimum, pulong->maximum, pulong->default_value);

        if (readable)

          g_print ("Current: %lu", g_value_get_ulong (&value));

        break;

      }

      case G_TYPE_LONG:

      {

        GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);

        n_print ("%-23.23s Long. ", "");

        g_print ("Range: %ld - %ld Default: %ld ",

            plong->minimum, plong->maximum, plong->default_value);

        if (readable)

          g_print ("Current: %ld", g_value_get_long (&value));

        break;

      }

      case G_TYPE_UINT:

      {

        GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);

        n_print ("%-23.23s Unsigned Integer. ", "");

        g_print ("Range: %u - %u Default: %u ",

            puint->minimum, puint->maximum, puint->default_value);

        if (readable)

          g_print ("Current: %u", g_value_get_uint (&value));

        break;

      }

      case G_TYPE_INT:

      {

        GParamSpecInt *pint = G_PARAM_SPEC_INT (param);

        n_print ("%-23.23s Integer. ", "");

        g_print ("Range: %d - %d Default: %d ",

            pint->minimum, pint->maximum, pint->default_value);

        if (readable)

          g_print ("Current: %d", g_value_get_int (&value));

        break;

      }

      case G_TYPE_UINT64:

      {

        GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);

        n_print ("%-23.23s Unsigned Integer64. ", "");

        g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT

            " Default: %" G_GUINT64_FORMAT " ",

            puint64->minimum, puint64->maximum, puint64->default_value);

        if (readable)

          g_print ("Current: %" G_GUINT64_FORMAT, g_value_get_uint64 (&value));

        break;

      }

      case G_TYPE_INT64:

      {

        GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);

        n_print ("%-23.23s Integer64. ", "");

        g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT

            " Default: %" G_GINT64_FORMAT " ",

            pint64->minimum, pint64->maximum, pint64->default_value);

        if (readable)

          g_print ("Current: %" G_GINT64_FORMAT, g_value_get_int64 (&value));

        break;

      }

      case G_TYPE_FLOAT:

      {

        GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);

        n_print ("%-23.23s Float. ", "");

        g_print ("Range: %15.7g - %15.7g Default: %15.7g ",

            pfloat->minimum, pfloat->maximum, pfloat->default_value);

        if (readable)

          g_print ("Current: %15.7g", g_value_get_float (&value));

        break;

      }

      case G_TYPE_DOUBLE:

      {

        GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);

        n_print ("%-23.23s Double. ", "");

        g_print ("Range: %15.7g - %15.7g Default: %15.7g ",

            pdouble->minimum, pdouble->maximum, pdouble->default_value);

        if (readable)

          g_print ("Current: %15.7g", g_value_get_double (&value));

        break;

      }

      default:

        if (param->value_type == GST_TYPE_CAPS) {

          const GstCaps *caps = gst_value_get_caps (&value);

          if (!caps)

            n_print ("%-23.23s Caps (NULL)", "");

          else {

            print_caps (caps, "                           ");

          }

        } else if (G_IS_PARAM_SPEC_ENUM (param)) {

          GParamSpecEnum *penum = G_PARAM_SPEC_ENUM (param);

          GEnumValue *values;

          guint j = 0;

          gint enum_value;

          const gchar *def_val_nick = "", *cur_val_nick = "";

          values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;

          enum_value = g_value_get_enum (&value);

          while (values[j].value_name) {

            if (values[j].value == enum_value)

              cur_val_nick = values[j].value_nick;

            if (values[j].value == penum->default_value)

              def_val_nick = values[j].value_nick;

            j++;

          }

          n_print

              ("%-23.23s Enum \"%s\" Default: %d, \"%s\" Current: %d, \"%s\"",

              "", g_type_name (G_VALUE_TYPE (&value)), penum->default_value,

              def_val_nick, enum_value, cur_val_nick);

          j = 0;

          while (values[j].value_name) {

            g_print ("\n");

            if (_name)

              g_print (_name);

            g_print ("%-23.23s    (%d): %-16s - %s", "",

                values[j].value, values[j].value_nick, values[j].value_name);

            j++;

          }

          /* g_type_class_unref (ec); */

        } else if (G_IS_PARAM_SPEC_FLAGS (param)) {

          GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (param);

          GFlagsValue *values;

          guint j = 0;

          gint flags_value;

          GString *cur_flags = NULL, *def_flags = NULL;

          values = G_FLAGS_CLASS (g_type_class_ref (param->value_type))->values;

          flags_value = g_value_get_flags (&value);

          while (values[j].value_name) {

            if (values[j].value & flags_value) {

              if (cur_flags) {

                g_string_append_printf (cur_flags, " | %s",

                    values[j].value_nick);

              } else {

                cur_flags = g_string_new (values[j].value_nick);

              }

            }

            if (values[j].value & pflags->default_value) {

              if (def_flags) {

                g_string_append_printf (def_flags, " | %s",

                    values[j].value_nick);

              } else {

                def_flags = g_string_new (values[j].value_nick);

              }

            }

            j++;

          }

          n_print

              ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\" Current: 0x%08x, \"%s\"",

              "", g_type_name (G_VALUE_TYPE (&value)), pflags->default_value,

              (def_flags ? def_flags->str : "(none)"), flags_value,

              (cur_flags ? cur_flags->str : "(none)"));

          j = 0;

          while (values[j].value_name) {

            g_print ("\n");

            if (_name)

              g_print (_name);

            g_print ("%-23.23s    (0x%08x): %-16s - %s", "",

                values[j].value, values[j].value_nick, values[j].value_name);

            j++;