/* 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., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

/* FIXME 2.0: suppress warnings for deprecated API such as GValueArray

 * with newer GLib versions (>= 2.31.0) */

#define GLIB_DISABLE_DEPRECATION_WARNINGS

#include "tools.h"

#include <gst/gst_private.h>    /* for internal Factories */

#include <string.h>

#include <locale.h>

#include <glib/gprintf.h>

static char *_name = NULL;

static int indent = 0;

static int print_element_info (GstPluginFeature * feature,

    gboolean print_names);

static int print_typefind_info (GstPluginFeature * feature,

    gboolean print_names);

static int print_tracer_info (GstPluginFeature * feature, gboolean print_names);

#define push_indent() push_indent_n(1)

#define pop_indent() push_indent_n(-1)

#define pop_indent_n(n) push_indent_n(-n)

static void

push_indent_n (int n)

{

  g_assert (n > 0 || indent > 0);

  indent += n;

}

/* *INDENT-OFF* */

G_GNUC_PRINTF (1, 2)

/* *INDENT-ON* */

static void

n_print (const char *format, ...)

{

  va_list args;

  int i;

  if (_name)

    g_print ("%s", _name);

  for (i = 0; i < indent; ++i)

    g_print ("  ");

  va_start (args, format);

  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);

    GstCapsFeatures *features = gst_caps_get_features (caps, i);

    if (features && (gst_caps_features_is_any (features) ||

            !gst_caps_features_is_equal (features,

                GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY))) {

      gchar *features_string = gst_caps_features_to_string (features);

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

          features_string);

      g_free (features_string);

    } else {

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

    }

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

  }

}

static const char *

get_rank_name (char *s, gint rank)

{

  static const int ranks[4] = {

    GST_RANK_NONE, GST_RANK_MARGINAL, GST_RANK_SECONDARY, GST_RANK_PRIMARY

  };

  static const char *rank_names[4] = { "none", "marginal", "secondary",

    "primary"

  };

  int i;

  int best_i;

  best_i = 0;

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

    if (rank == ranks[i])

      return rank_names[i];

    if (abs (rank - ranks[i]) < abs (rank - ranks[best_i])) {

      best_i = i;

    }

  }

  sprintf (s, "%s %c %d", rank_names[best_i],

      (rank - ranks[best_i] > 0) ? '+' : '-', abs (ranks[best_i] - rank));

  return s;

}

static void

print_factory_details_info (GstElementFactory * factory)

{

  gchar **keys, **k;

  GstRank rank;

  char s[20];

  rank = gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory));

  n_print ("Factory Details:\n");

  push_indent ();

  n_print ("%-25s%s (%d)\n", "Rank", get_rank_name (s, rank), rank);

  keys = gst_element_factory_get_metadata_keys (factory);

  if (keys != NULL) {

    for (k = keys; *k != NULL; ++k) {

      const gchar *val;

      gchar *key = *k;

      val = gst_element_factory_get_metadata (factory, key);

      key[0] = g_ascii_toupper (key[0]);

      n_print ("%-25s%s\n", key, val);

    }

    g_strfreev (keys);

  }

  pop_indent ();

  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 ("%s", _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) {

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

      push_indent ();

      iface = ifaces;

      while (*iface) {

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

        iface++;

      }

      pop_indent ();

      n_print ("\n");

    }

    g_free (ifaces);

  }

}

static gchar *

flags_to_string (GFlagsValue * vals, guint flags)

{

  GString *s = NULL;

  guint flags_left, i;

  /* first look for an exact match and count the number of values */

  for (i = 0; vals[i].value_name != NULL; ++i) {

    if (vals[i].value == flags)

      return g_strdup (vals[i].value_nick);

  }

  s = g_string_new (NULL);

  /* we assume the values are sorted from lowest to highest value */

  flags_left = flags;

  while (i > 0) {

    --i;

    if (vals[i].value != 0 && (flags_left & vals[i].value) == vals[i].value) {

      if (s->len > 0)

        g_string_append_c (s, '+');

      g_string_append (s, vals[i].value_nick);

      flags_left -= vals[i].value;

      if (flags_left == 0)

        break;

    }

  }

  if (s->len == 0)

    g_string_assign (s, "(none)");

  return g_string_free (s, FALSE);

}

#define KNOWN_PARAM_FLAGS \

  (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY | \

  G_PARAM_LAX_VALIDATION |  G_PARAM_STATIC_STRINGS | \

  G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_DEPRECATED | \

  GST_PARAM_CONTROLLABLE | GST_PARAM_MUTABLE_PLAYING | \

  GST_PARAM_MUTABLE_PAUSED | GST_PARAM_MUTABLE_READY)

/* obj will be NULL if we're printing properties of pad template pads */

static void

print_object_properties_info (GObject * obj, GObjectClass * obj_class,

    const gchar * desc)

{

  GParamSpec **property_specs;

  guint num_properties, i;

  gboolean readable;

  gboolean first_flag;

  property_specs = g_object_class_list_properties (obj_class, &num_properties);

  n_print ("%s:\n", desc);

  push_indent ();

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

    GValue value = { 0, };

    GParamSpec *param = property_specs[i];

    GType owner_type = param->owner_type;

    /* We're printing pad properties */

    if (obj == NULL && (owner_type == G_TYPE_OBJECT

            || owner_type == GST_TYPE_OBJECT || owner_type == GST_TYPE_PAD))

      continue;

    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));

    push_indent_n (11);

    first_flag = TRUE;

    n_print ("flags: ");

    readable = ! !(param->flags & G_PARAM_READABLE);

    if (readable && obj != NULL) {

      g_object_get_property (obj, param->name, &value);

    } else {

      /* if we can't read the property value, assume it's set to the default

       * (which might not be entirely true for sub-classes, but that's an

       * unlikely corner-case anyway) */

      g_param_value_set_default (param, &value);

    }

    if (readable) {

      g_print ("%s%s", (first_flag) ? "" : ", ", _("readable"));

      first_flag = FALSE;

    }

    if (param->flags & G_PARAM_WRITABLE) {

      g_print ("%s%s", (first_flag) ? "" : ", ", _("writable"));

      first_flag = FALSE;

    }

    if (param->flags & G_PARAM_DEPRECATED) {

      g_print ("%s%s", (first_flag) ? "" : ", ", _("deprecated"));

      first_flag = FALSE;

    }

    if (param->flags & GST_PARAM_CONTROLLABLE) {

      g_print (", %s", _("controllable"));

      first_flag = FALSE;

    }

    if (param->flags & GST_PARAM_MUTABLE_PLAYING) {

      g_print (", %s", _("changeable in NULL, READY, PAUSED or PLAYING state"));

    } else if (param->flags & GST_PARAM_MUTABLE_PAUSED) {

      g_print (", %s", _("changeable only in NULL, READY or PAUSED state"));

    } else if (param->flags & GST_PARAM_MUTABLE_READY) {

      g_print (", %s", _("changeable only in NULL or READY state"));

    }

    if (param->flags & ~KNOWN_PARAM_FLAGS) {

      g_print ("%s0x%0x", (first_flag) ? "" : ", ",

          param->flags & ~KNOWN_PARAM_FLAGS);

    }

    g_print ("\n");

    switch (G_VALUE_TYPE (&value)) {

      case G_TYPE_STRING:

      {

        const char *string_val = g_value_get_string (&value);

        n_print ("String. ");

        if (string_val == NULL)

          g_print ("Default: null");

        else

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

        break;

      }

      case G_TYPE_BOOLEAN:

      {

        gboolean bool_val = g_value_get_boolean (&value);

        n_print ("Boolean. Default: %s", bool_val ? "true" : "false");

        break;

      }

      case G_TYPE_ULONG:

      {

        GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);

        n_print ("Unsigned Long. Range: %lu - %lu Default: %lu ",

            pulong->minimum, pulong->maximum, g_value_get_ulong (&value));

        GST_ERROR ("%s: property '%s' of type ulong: consider changing to "

            "uint/uint64", G_OBJECT_CLASS_NAME (obj_class),

            g_param_spec_get_name (param));

        break;

      }

      case G_TYPE_LONG:

      {

        GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);

        n_print ("Long. Range: %ld - %ld Default: %ld ",

            plong->minimum, plong->maximum, g_value_get_long (&value));

        GST_ERROR ("%s: property '%s' of type long: consider changing to "

            "int/int64", G_OBJECT_CLASS_NAME (obj_class),

            g_param_spec_get_name (param));

        break;

      }

      case G_TYPE_UINT:

      {

        GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);

        n_print ("Unsigned Integer. Range: %u - %u Default: %u ",

            puint->minimum, puint->maximum, g_value_get_uint (&value));

        break;

      }

      case G_TYPE_INT:

      {

        GParamSpecInt *pint = G_PARAM_SPEC_INT (param);

        n_print ("Integer. Range: %d - %d Default: %d ",

            pint->minimum, pint->maximum, g_value_get_int (&value));

        break;

      }

      case G_TYPE_UINT64:

      {

        GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);

        n_print ("Unsigned Integer64. Range: %" G_GUINT64_FORMAT " - "

            "%" G_GUINT64_FORMAT " Default: %" G_GUINT64_FORMAT " ",

            puint64->minimum, puint64->maximum, g_value_get_uint64 (&value));

        break;

      }

      case G_TYPE_INT64:

      {

        GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);

        n_print ("Integer64. Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT

            " Default: %" G_GINT64_FORMAT " ",

            pint64->minimum, pint64->maximum, g_value_get_int64 (&value));

        break;

      }

      case G_TYPE_FLOAT:

      {

        GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);

        n_print ("Float. Range: %15.7g - %15.7g Default: %15.7g ",

            pfloat->minimum, pfloat->maximum, g_value_get_float (&value));

        break;

      }

      case G_TYPE_DOUBLE:

      {

        GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);

        n_print ("Double. Range: %15.7g - %15.7g Default: %15.7g ",

            pdouble->minimum, pdouble->maximum, g_value_get_double (&value));

        break;

      }

      case G_TYPE_CHAR:

      case G_TYPE_UCHAR:

        GST_ERROR ("%s: property '%s' of type char: consider changing to "

            "int/string", G_OBJECT_CLASS_NAME (obj_class),

            g_param_spec_get_name (param));

        /* fall through */

      default:

        if (param->value_type == GST_TYPE_CAPS) {

          const GstCaps *caps = gst_value_get_caps (&value);

          if (!caps)

            n_print ("Caps (NULL)");

          else {

            print_caps (caps, "                           ");

          }

        } else if (G_IS_PARAM_SPEC_ENUM (param)) {

          GEnumValue *values;

          guint j = 0;

          gint enum_value;

          const gchar *value_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)

              value_nick = values[j].value_nick;

            j++;

          }

          n_print ("Enum \"%s\" Default: %d, \"%s\"",

              g_type_name (G_VALUE_TYPE (&value)), enum_value, value_nick);

          j = 0;

          while (values[j].value_name) {

            g_print ("\n");

            n_print ("   (%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 *vals;

          gchar *cur;

          vals = pflags->flags_class->values;

          cur = flags_to_string (vals, g_value_get_flags (&value));

          n_print ("Flags \"%s\" Default: 0x%08x, \"%s\"",

              g_type_name (G_VALUE_TYPE (&value)),

              g_value_get_flags (&value), cur);

          while (vals[0].value_name) {

            g_print ("\n");

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

                vals[0].value, vals[0].value_nick, vals[0].value_name);

            ++vals;

          }

          g_free (cur);

        } else if (G_IS_PARAM_SPEC_OBJECT (param)) {

          n_print ("Object of type \"%s\"", g_type_name (param->value_type));

        } else if (G_IS_PARAM_SPEC_BOXED (param)) {

          n_print ("Boxed pointer of type \"%s\"",

              g_type_name (param->value_type));

          if (param->value_type == GST_TYPE_STRUCTURE) {

            const GstStructure *s = gst_value_get_structure (&value);

            if (s)

              gst_structure_foreach (s, print_field,

                  (gpointer) "                           ");

          }

        } else if (G_IS_PARAM_SPEC_POINTER (param)) {

          if (param->value_type != G_TYPE_POINTER) {

            n_print ("Pointer of type \"%s\".",

                g_type_name (param->value_type));

          } else {

            n_print ("Pointer.");

          }

        } else if (param->value_type == G_TYPE_VALUE_ARRAY) {

          GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (param);

          if (pvarray->element_spec) {

            n_print ("Array of GValues of type \"%s\"",

                g_type_name (pvarray->element_spec->value_type));

          } else {

            n_print ("Array of GValues");

          }

        } else if (GST_IS_PARAM_SPEC_FRACTION (param)) {

          GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param);

          n_print ("Fraction. Range: %d/%d - %d/%d Default: %d/%d ",

              pfraction->min_num, pfraction->min_den,

              pfraction->max_num, pfraction->max_den,

              gst_value_get_fraction_numerator (&value),

              gst_value_get_fraction_denominator (&value));

        } else if (param->value_type == GST_TYPE_ARRAY) {

          GstParamSpecArray *parray = GST_PARAM_SPEC_ARRAY_LIST (param);

          if (parray->element_spec) {

            n_print ("GstValueArray of GValues of type \"%s\"",

                g_type_name (parray->element_spec->value_type));

          } else {

            n_print ("GstValueArray of GValues");

          }

        } else {

          n_print ("Unknown type %ld \"%s\"",

              (glong) param->value_type, g_type_name (param->value_type));

        }

        break;

    }

    if (!readable)

      g_print (" Write only\n");

    else

      g_print ("\n");

    pop_indent_n (11);

    g_value_reset (&value);

  }

  if (num_properties == 0)

    n_print ("none\n");

  pop_indent ();

  g_free (property_specs);

}

static void

print_element_properties_info (GstElement * element)

{

  g_print ("\n");

  print_object_properties_info (G_OBJECT (element),

      G_OBJECT_GET_CLASS (element), "Element Properties");

}

static void

print_pad_templates_info (GstElement * element, GstElementFactory * factory)

{

  const GList *pads;

  GstStaticPadTemplate *padtemplate;

  GstPadTemplate *tmpl;

  n_print ("Pad Templates:\n");

  push_indent ();

  if (gst_element_factory_get_num_pad_templates (factory) == 0) {

    n_print ("none\n");

    goto done;

  }

  pads = gst_element_factory_get_static_pad_templates (factory);

  while (pads) {

    padtemplate = (GstStaticPadTemplate *) (pads->data);

    pads = g_list_next (pads);

    if (padtemplate->direction == GST_PAD_SRC)

      n_print ("SRC template: '%s'\n", padtemplate->name_template);

    else if (padtemplate->direction == GST_PAD_SINK)

      n_print ("SINK template: '%s'\n", padtemplate->name_template);

    else

      n_print ("UNKNOWN template: '%s'\n", padtemplate->name_template);

    push_indent ();

    if (padtemplate->presence == GST_PAD_ALWAYS)

      n_print ("Availability: Always\n");

    else if (padtemplate->presence == GST_PAD_SOMETIMES)

      n_print ("Availability: Sometimes\n");

    else if (padtemplate->presence == GST_PAD_REQUEST) {

      n_print ("Availability: On request\n");

    } else

      n_print ("Availability: UNKNOWN\n");

    if (padtemplate->static_caps.string) {

      GstCaps *caps = gst_static_caps_get (&padtemplate->static_caps);

      n_print ("Capabilities:\n");

      push_indent ();

      print_caps (caps, "");    // FIXME

      pop_indent ();

      gst_caps_unref (caps);

    }

    tmpl = gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (element),

        padtemplate->name_template);

    if (tmpl != NULL) {

      GType pad_type = GST_PAD_TEMPLATE_GTYPE (tmpl);

      if (pad_type != G_TYPE_NONE && pad_type != GST_TYPE_PAD) {

        gpointer pad_klass;

        pad_klass = g_type_class_ref (pad_type);

        n_print ("Type: %s\n", g_type_name (pad_type));

        print_object_properties_info (NULL, pad_klass, "Pad Properties");

        g_type_class_unref (pad_klass);

      }

    }

    pop_indent ();

    if (pads != NULL)

      n_print ("\n");

  }

done:

  pop_indent ();

}

static void

print_clocking_info (GstElement * element)

{

  gboolean requires_clock, provides_clock;

  requires_clock =

      GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_REQUIRE_CLOCK);

  provides_clock =

      GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_PROVIDE_CLOCK);

  if (!requires_clock && !provides_clock) {

    n_print ("\n");

    n_print ("Element has no clocking capabilities.\n");

    return;

  }

  n_print ("\n");

  n_print ("Clocking Interaction:\n");

  push_indent ();

  if (requires_clock) {

    n_print ("element requires a clock\n");

  }

  if (provides_clock) {

    GstClock *clock;

    clock = gst_element_get_clock (element);

    if (clock) {

      n_print ("element provides a clock: %s\n", GST_OBJECT_NAME (clock));

      gst_object_unref (clock);

    } else

      n_print ("element is supposed to provide a clock but returned NULL\n");

  }

  pop_indent ();

}

static void

print_uri_handler_info (GstElement * element)

{

  if (GST_IS_URI_HANDLER (element)) {

    const gchar *const *uri_protocols;

    const gchar *uri_type;

    if (gst_uri_handler_get_uri_type (GST_URI_HANDLER (element)) == GST_URI_SRC)

      uri_type = "source";

    else if (gst_uri_handler_get_uri_type (GST_URI_HANDLER (element)) ==

        GST_URI_SINK)

      uri_type = "sink";

    else

      uri_type = "unknown";

    uri_protocols = gst_uri_handler_get_protocols (GST_URI_HANDLER (element));

    n_print ("\n");

    n_print ("URI handling capabilities:\n");

    push_indent ();

    n_print ("Element can act as %s.\n", uri_type);

    if (uri_protocols && *uri_protocols) {

      n_print ("Supported URI protocols:\n");

      push_indent ();

      for (; *uri_protocols != NULL; uri_protocols++)

        n_print ("%s\n", *uri_protocols);

      pop_indent ();

    } else {

      n_print ("No supported URI protocols\n");

    }

    pop_indent ();

  } else {

    n_print ("Element has no URI handling capabilities.\n");

  }

}

static void

print_pad_info (GstElement * element)

{

  const GList *pads;

  GstPad *pad;

  n_print ("\n");

  n_print ("Pads:\n");

  push_indent ();

  if (!element->numpads) {

    n_print ("none\n");

    goto done;

  }

  pads = element->pads;

  while (pads) {

    gchar *name;

    GstCaps *caps;

    pad = GST_PAD (pads->data);

    pads = g_list_next (pads);

    name = gst_pad_get_name (pad);

    if (gst_pad_get_direction (pad) == GST_PAD_SRC)

      n_print ("SRC: '%s'\n", name);

    else if (gst_pad_get_direction (pad) == GST_PAD_SINK)

      n_print ("SINK: '%s'\n", name);

    else

      n_print ("UNKNOWN: '%s'\n", name);

    g_free (name);

    if (pad->padtemplate) {

      push_indent ();

      n_print ("Pad Template: '%s'\n", pad->padtemplate->name_template);

      pop_indent ();

    }

    caps = gst_pad_get_current_caps (pad);

    if (caps) {

      n_print ("Capabilities:\n");

      push_indent ();

      print_caps (caps, "");    // FIXME

      pop_indent ();

      gst_caps_unref (caps);

    }

  }

done:

  pop_indent ();

}

static gboolean

has_sometimes_template (GstElement * element)

{

  GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);

  GList *l;

  for (l = klass->padtemplates; l != NULL; l = l->next) {

    if (GST_PAD_TEMPLATE (l->data)->presence == GST_PAD_SOMETIMES)

      return TRUE;

  }

  return FALSE;

}

static gboolean

gtype_needs_ptr_marker (GType type)

{

  if (type == G_TYPE_POINTER)

    return FALSE;

  if (G_TYPE_FUNDAMENTAL (type) == G_TYPE_POINTER || G_TYPE_IS_BOXED (type)

      || G_TYPE_IS_OBJECT (type))

    return TRUE;

  return FALSE;

}

static void

print_signal_info (GstElement * element)

{

  /* Signals/Actions Block */

  guint *signals;

  guint nsignals;

  gint i = 0, j, k;

  GSignalQuery *query = NULL;

  GType type;

  GSList *found_signals, *l;

  for (k = 0; k < 2; k++) {

    found_signals = NULL;

    /* For elements that have sometimes pads, also list a few useful GstElement

     * signals. Put these first, so element-specific ones come later. */

    if (k == 0 && has_sometimes_template (element)) {

      query = g_new0 (GSignalQuery, 1);

      g_signal_query (g_signal_lookup ("pad-added", GST_TYPE_ELEMENT), query);

      found_signals = g_slist_append (found_signals, query);

      query = g_new0 (GSignalQuery, 1);

      g_signal_query (g_signal_lookup ("pad-removed", GST_TYPE_ELEMENT), query);

      found_signals = g_slist_append (found_signals, query);

      query = g_new0 (GSignalQuery, 1);

      g_signal_query (g_signal_lookup ("no-more-pads", GST_TYPE_ELEMENT),

          query);

      found_signals = g_slist_append (found_signals, query);

    }

    for (type = G_OBJECT_TYPE (element); type; type = g_type_parent (type)) {

      if (type == GST_TYPE_ELEMENT || type == GST_TYPE_OBJECT)

        break;

      if (type == GST_TYPE_BIN && G_OBJECT_TYPE (element) != GST_TYPE_BIN)

        continue;

      signals = g_signal_list_ids (type, &nsignals);

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

        query = g_new0 (GSignalQuery, 1);

        g_signal_query (signals[i], query);

        if ((k == 0 && !(query->signal_flags & G_SIGNAL_ACTION)) ||

            (k == 1 && (query->signal_flags & G_SIGNAL_ACTION)))

          found_signals = g_slist_append (found_signals, query);

        else

          g_free (query);

      }

      g_free (signals);

      signals = NULL;

    }

    if (found_signals) {

      n_print ("\n");

      if (k == 0)

        n_print ("Element Signals:\n");

      else

        n_print ("Element Actions:\n");

    } else {

      continue;

    }

    for (l = found_signals; l; l = l->next) {

      gchar *indent;

      const gchar *pmark;

      int indent_len;

      query = (GSignalQuery *) l->data;

      indent_len = strlen (query->signal_name) +