X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=tools%2Fgst-inspect.c;h=e603ca5db51ffa5cb7a70361b4f441a41bc60ad3;hb=2cf16838c54e506f4f234ba71d42565e97b45b0d;hp=d549fcb8ad2ad778cc4b97e8eacba72628d49fd3;hpb=bfc39823089473c781fe8c708283e9c9616e046b;p=platform%2Fupstream%2Fgstreamer.git diff --git a/tools/gst-inspect.c b/tools/gst-inspect.c index d549fcb..e603ca5 100644 --- a/tools/gst-inspect.c +++ b/tools/gst-inspect.c @@ -2,6 +2,7 @@ * Copyright (C) 1999,2000 Erik Walthinsen * 2000 Wim Taymans * 2004 Thomas Vander Stichele + * 2018 Collabora Ltd. * * gst-inspect.c: tool to inspect the GStreamer registry * @@ -25,29 +26,107 @@ # include "config.h" #endif -/* FIXME 0.11: suppress warnings for deprecated API such as GValueArray +/* 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 /* for internal Factories */ #include #include #include +#ifdef G_OS_UNIX +# include +# include +#endif + +#define DEFAULT_PAGER "less -F -X" + +gboolean colored_output = TRUE; + +/* Console colors (true-color) */ + +/* Escape values for various colors */ +#define BLUE "\033[38;2;38;139;210m" +#define BRBLUE "\033[38;2;131;148;150m" +#define BRGREEN "\033[38;2;88;110;117m" +#define BRRED "\033[38;2;203;75;22m" +#define BRMAGENTA "\033[38;2;108;113;196m" /* VIOLET */ +#define CYAN "\033[38;2;42;161;152m" +#define GREEN "\033[38;2;133;153;0m" +#define MAGENTA "\033[38;2;211;54;130m" +#define YELLOW "\033[38;2;176;130;26m" + +/* General colors */ +#define RESET_COLOR (colored_output? "\033[0m": "") +#define HEADING_COLOR (colored_output? YELLOW : "") +#define PROP_NAME_COLOR (colored_output? BLUE: "") +#define PROP_VALUE_COLOR (colored_output? CYAN : "") +#define PROP_ATTR_NAME_COLOR (colored_output? BRRED : "") +#define PROP_ATTR_VALUE_COLOR (colored_output? BRGREEN : "") +/* FIXME: find a good color that works on both dark & light bg. */ +#define DESC_COLOR (colored_output? RESET_COLOR: "") + +/* Datatype-related colors */ +#define DATATYPE_COLOR (colored_output? MAGENTA : "") +#define CHILD_LINK_COLOR (colored_output? BRMAGENTA : "") + +/* Caps colors */ +#define FIELD_NAME_COLOR (colored_output? BLUE : "") +#define FIELD_VALUE_COLOR (colored_output? BRGREEN : "") +#define CAPS_TYPE_COLOR (colored_output? YELLOW : "") +#define STRUCT_NAME_COLOR (colored_output? YELLOW : "") +#define CAPS_FEATURE_COLOR (colored_output? GREEN : "") + +/* Plugin listing colors */ +#define PLUGIN_NAME_COLOR (colored_output? BRMAGENTA : "") +#define ELEMENT_NAME_COLOR (colored_output? GREEN: "") +#define ELEMENT_DETAIL_COLOR (colored_output? BRBLUE: "") +#define PLUGIN_FEATURE_COLOR (colored_output? BRBLUE: "") + +/* Feature listing colors */ +#define FEATURE_NAME_COLOR (colored_output? GREEN : "") +#define FEATURE_DIR_COLOR (colored_output? BRMAGENTA : "") +#define FEATURE_RANK_COLOR (colored_output? CYAN : "") +#define FEATURE_PROTO_COLOR (colored_output? BRRED : "") static char *_name = NULL; +static int indent = 0; -static int print_element_info (GstElementFactory * factory, +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); @@ -58,7 +137,9 @@ 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); + n_print ("%s %s%15s%s: %s%s%s\n", + (gchar *) pfx, FIELD_NAME_COLOR, g_quark_to_string (field), RESET_COLOR, + FIELD_VALUE_COLOR, str, RESET_COLOR); g_free (str); return TRUE; } @@ -71,88 +152,34 @@ print_caps (const GstCaps * caps, const gchar * pfx) g_return_if_fail (caps != NULL); if (gst_caps_is_any (caps)) { - n_print ("%sANY\n", pfx); + n_print ("%s%sANY%s\n", CAPS_TYPE_COLOR, pfx, RESET_COLOR); return; } if (gst_caps_is_empty (caps)) { - n_print ("%sEMPTY\n", pfx); + n_print ("%s%sEMPTY%s\n", CAPS_TYPE_COLOR, pfx, RESET_COLOR); 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); - 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++; - } -} - -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 (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); - if (value) - g_print ("| %s ", value->value_nick); - else - g_print ("| ? "); - } - flags >>= 1; - index++; + n_print ("%s%s%s%s(%s%s%s)\n", pfx, STRUCT_NAME_COLOR, + gst_structure_get_name (structure), RESET_COLOR, + CAPS_FEATURE_COLOR, features_string, RESET_COLOR); + g_free (features_string); + } else { + n_print ("%s%s%s%s\n", pfx, STRUCT_NAME_COLOR, + gst_structure_get_name (structure), RESET_COLOR); } - g_print ("\n"); - - masks++; + gst_structure_foreach (structure, print_field, (gpointer) pfx); } } -#endif static const char * get_rank_name (char *s, gint rank) @@ -189,8 +216,11 @@ print_factory_details_info (GstElementFactory * factory) char s[20]; rank = gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory)); - n_print ("Factory Details:\n"); - n_print (" %-25s%s (%d)\n", "Rank", get_rank_name (s, rank), rank); + n_print ("%sFactory Details:%s\n", HEADING_COLOR, RESET_COLOR); + + push_indent (); + n_print ("%s%-25s%s%s (%d)%s\n", PROP_NAME_COLOR, "Rank", PROP_VALUE_COLOR, + get_rank_name (s, rank), rank, RESET_COLOR); keys = gst_element_factory_get_metadata_keys (factory); if (keys != NULL) { @@ -200,10 +230,12 @@ print_factory_details_info (GstElementFactory * factory) val = gst_element_factory_get_metadata (factory, key); key[0] = g_ascii_toupper (key[0]); - n_print (" %-25s%s\n", key, val); + n_print ("%s%-25s%s%s%s\n", PROP_NAME_COLOR, key, PROP_VALUE_COLOR, val, + RESET_COLOR); } g_strfreev (keys); } + pop_indent (); n_print ("\n"); } @@ -222,14 +254,14 @@ print_hierarchy (GType type, gint level, gint * maxlevel) print_hierarchy (parent, level, maxlevel); if (_name) - g_print ("%s", _name); + g_print ("%s%s%s", DATATYPE_COLOR, _name, RESET_COLOR); for (i = 1; i < *maxlevel - level; i++) g_print (" "); if (*maxlevel - level) - g_print (" +----"); + g_print (" %s+----%s", CHILD_LINK_COLOR, RESET_COLOR); - g_print ("%s\n", g_type_name (type)); + g_print ("%s%s%s\n", DATATYPE_COLOR, g_type_name (type), RESET_COLOR); if (level == 1) n_print ("\n"); @@ -243,19 +275,15 @@ print_interfaces (GType type) if (ifaces) { if (n_ifaces) { - if (_name) - g_print ("%s", _name); - g_print (_("Implemented Interfaces:\n")); + n_print (_("%sImplemented Interfaces%s:\n"), HEADING_COLOR, RESET_COLOR); + push_indent (); iface = ifaces; while (*iface) { - if (_name) - g_print ("%s", _name); - g_print (" %s\n", g_type_name (*iface)); + n_print ("%s%s%s\n", DATATYPE_COLOR, g_type_name (*iface), RESET_COLOR); iface++; } - if (_name) - g_print ("%s", _name); - g_print ("\n"); + pop_indent (); + n_print ("\n"); } g_free (ifaces); } @@ -298,100 +326,138 @@ flags_to_string (GFlagsValue * vals, guint flags) #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 | GST_PARAM_CONTROLLABLE | \ - GST_PARAM_MUTABLE_PLAYING | GST_PARAM_MUTABLE_PAUSED | \ - GST_PARAM_MUTABLE_READY) + G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_DEPRECATED | \ + GST_PARAM_CONTROLLABLE | GST_PARAM_MUTABLE_PLAYING | \ + GST_PARAM_MUTABLE_PAUSED | GST_PARAM_MUTABLE_READY) + +static int +sort_gparamspecs (GParamSpec ** a, GParamSpec ** b) +{ + return g_strcmp0 (g_param_spec_get_name (*a), g_param_spec_get_name (*b)); +} +/* obj will be NULL if we're printing properties of pad template pads */ static void -print_element_properties_info (GstElement * element) +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 - (G_OBJECT_GET_CLASS (element), &num_properties); - n_print ("\n"); - n_print ("Element Properties:\n"); + property_specs = g_object_class_list_properties (obj_class, &num_properties); + g_qsort_with_data (property_specs, num_properties, sizeof (gpointer), + (GCompareDataFunc) sort_gparamspecs, NULL); + + n_print ("%s%s%s:\n", HEADING_COLOR, desc, RESET_COLOR); + + 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)); + n_print ("%s%-20s%s: %s%s%s\n", PROP_NAME_COLOR, + g_param_spec_get_name (param), RESET_COLOR, PROP_VALUE_COLOR, + g_param_spec_get_blurb (param), RESET_COLOR); + + push_indent_n (11); 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; - g_print ("%s%s", (first_flag) ? "" : ", ", _("readable")); - first_flag = FALSE; + n_print ("%sflags%s: ", PROP_ATTR_NAME_COLOR, RESET_COLOR); + 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%s%s", (first_flag) ? "" : ", ", PROP_ATTR_VALUE_COLOR, + _("readable"), RESET_COLOR); + first_flag = FALSE; + } if (param->flags & G_PARAM_WRITABLE) { - g_print ("%s%s", (first_flag) ? "" : ", ", _("writable")); + g_print ("%s%s%s%s", (first_flag) ? "" : ", ", PROP_ATTR_VALUE_COLOR, + _("writable"), RESET_COLOR); + first_flag = FALSE; + } + if (param->flags & G_PARAM_DEPRECATED) { + g_print ("%s%s%s%s", (first_flag) ? "" : ", ", PROP_ATTR_VALUE_COLOR, + _("deprecated"), RESET_COLOR); first_flag = FALSE; } if (param->flags & GST_PARAM_CONTROLLABLE) { - g_print (", %s", _("controllable")); + g_print (", %s%s%s", PROP_ATTR_VALUE_COLOR, _("controllable"), + RESET_COLOR); first_flag = FALSE; } if (param->flags & GST_PARAM_MUTABLE_PLAYING) { - g_print (", %s", _("changeable in NULL, READY, PAUSED or PLAYING state")); + g_print (", %s%s%s", PROP_ATTR_VALUE_COLOR, + _("changeable in NULL, READY, PAUSED or PLAYING state"), RESET_COLOR); } else if (param->flags & GST_PARAM_MUTABLE_PAUSED) { - g_print (", %s", _("changeable only in NULL, READY or PAUSED state")); + g_print (", %s%s%s", PROP_ATTR_VALUE_COLOR, + _("changeable only in NULL, READY or PAUSED state"), RESET_COLOR); } else if (param->flags & GST_PARAM_MUTABLE_READY) { - g_print (", %s", _("changeable only in NULL or READY state")); + g_print (", %s%s%s", PROP_ATTR_VALUE_COLOR, + _("changeable only in NULL or READY state"), RESET_COLOR); } if (param->flags & ~KNOWN_PARAM_FLAGS) { - g_print ("%s0x%0x", (first_flag) ? "" : ", ", - param->flags & ~KNOWN_PARAM_FLAGS); + g_print ("%s0x%s%0x%s", (first_flag) ? "" : ", ", PROP_ATTR_VALUE_COLOR, + param->flags & ~KNOWN_PARAM_FLAGS, RESET_COLOR); } - n_print ("\n"); + g_print ("\n"); switch (G_VALUE_TYPE (&value)) { case G_TYPE_STRING: { const char *string_val = g_value_get_string (&value); - n_print ("%-23.23s String. ", ""); + n_print ("%sString%s. ", DATATYPE_COLOR, RESET_COLOR); if (string_val == NULL) - g_print ("Default: null"); + g_print ("%sDefault%s: %snull%s", PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, RESET_COLOR); else - g_print ("Default: \"%s\"", string_val); + g_print ("%sDefault%s: %s\"%s\"%s", PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, string_val, RESET_COLOR); break; } case G_TYPE_BOOLEAN: { gboolean bool_val = g_value_get_boolean (&value); - n_print ("%-23.23s Boolean. ", ""); - - g_print ("Default: %s", bool_val ? "true" : "false"); + n_print ("%sBoolean%s. %sDefault%s: %s%s%s", DATATYPE_COLOR, + RESET_COLOR, PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, bool_val ? "true" : "false", RESET_COLOR); 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, g_value_get_ulong (&value)); + n_print + ("%sUnsigned Long%s. %sRange%s: %s%lu - %lu%s %sDefault%s: %s%lu%s ", + DATATYPE_COLOR, RESET_COLOR, PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, pulong->minimum, pulong->maximum, + RESET_COLOR, PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, g_value_get_ulong (&value), RESET_COLOR); GST_ERROR ("%s: property '%s' of type ulong: consider changing to " - "uint/uint64", GST_OBJECT_NAME (element), + "uint/uint64", G_OBJECT_CLASS_NAME (obj_class), g_param_spec_get_name (param)); break; } @@ -399,12 +465,14 @@ print_element_properties_info (GstElement * element) { GParamSpecLong *plong = G_PARAM_SPEC_LONG (param); - n_print ("%-23.23s Long. ", ""); - g_print ("Range: %ld - %ld Default: %ld ", - plong->minimum, plong->maximum, g_value_get_long (&value)); + n_print ("%sLong%s. %sRange%s: %s%ld - %ld%s %sDefault%s: %s%ld%s ", + DATATYPE_COLOR, RESET_COLOR, PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, plong->minimum, plong->maximum, RESET_COLOR, + PROP_ATTR_NAME_COLOR, RESET_COLOR, PROP_ATTR_VALUE_COLOR, + g_value_get_long (&value), RESET_COLOR); GST_ERROR ("%s: property '%s' of type long: consider changing to " - "int/int64", GST_OBJECT_NAME (element), + "int/int64", G_OBJECT_CLASS_NAME (obj_class), g_param_spec_get_name (param)); break; } @@ -412,62 +480,77 @@ print_element_properties_info (GstElement * element) { GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param); - n_print ("%-23.23s Unsigned Integer. ", ""); - g_print ("Range: %u - %u Default: %u ", - puint->minimum, puint->maximum, g_value_get_uint (&value)); + n_print + ("%sUnsigned Integer%s. %sRange%s: %s%u - %u%s %sDefault%s: %s%u%s ", + DATATYPE_COLOR, RESET_COLOR, PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, puint->minimum, puint->maximum, RESET_COLOR, + PROP_ATTR_NAME_COLOR, RESET_COLOR, PROP_ATTR_VALUE_COLOR, + g_value_get_uint (&value), RESET_COLOR); 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, g_value_get_int (&value)); + n_print ("%sInteger%s. %sRange%s: %s%d - %d%s %sDefault%s: %s%d%s ", + DATATYPE_COLOR, RESET_COLOR, PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, pint->minimum, pint->maximum, RESET_COLOR, + PROP_ATTR_NAME_COLOR, RESET_COLOR, PROP_ATTR_VALUE_COLOR, + g_value_get_int (&value), RESET_COLOR); 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, g_value_get_uint64 (&value)); + n_print ("%sUnsigned Integer64%s. %sRange%s: %s%" G_GUINT64_FORMAT " - " + "%" G_GUINT64_FORMAT "%s %sDefault%s: %s%" G_GUINT64_FORMAT "%s ", + DATATYPE_COLOR, RESET_COLOR, PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, puint64->minimum, puint64->maximum, + RESET_COLOR, PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, g_value_get_uint64 (&value), RESET_COLOR); 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, g_value_get_int64 (&value)); + n_print ("%sInteger64%s. %sRange%s: %s%" G_GINT64_FORMAT " - %" + G_GINT64_FORMAT "%s %sDefault%s: %s%" G_GINT64_FORMAT "%s ", + DATATYPE_COLOR, RESET_COLOR, PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, pint64->minimum, pint64->maximum, + RESET_COLOR, PROP_ATTR_NAME_COLOR, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, g_value_get_int64 (&value), RESET_COLOR); 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, g_value_get_float (&value)); + n_print ("%sFloat%s. %sRange%s: %s%15.7g - %15.7g%s " + "%sDefault%s: %s%15.7g%s ", DATATYPE_COLOR, RESET_COLOR, + PROP_ATTR_NAME_COLOR, RESET_COLOR, PROP_ATTR_VALUE_COLOR, + pfloat->minimum, pfloat->maximum, RESET_COLOR, PROP_ATTR_NAME_COLOR, + RESET_COLOR, PROP_ATTR_VALUE_COLOR, g_value_get_float (&value), + RESET_COLOR); 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, g_value_get_double (&value)); + n_print ("%sDouble%s. %sRange%s: %s%15.7g - %15.7g%s " + "%sDefault%s: %s%15.7g%s ", DATATYPE_COLOR, RESET_COLOR, + PROP_ATTR_NAME_COLOR, RESET_COLOR, PROP_ATTR_VALUE_COLOR, + pdouble->minimum, pdouble->maximum, RESET_COLOR, + PROP_ATTR_NAME_COLOR, RESET_COLOR, PROP_ATTR_VALUE_COLOR, + g_value_get_double (&value), RESET_COLOR); break; } case G_TYPE_CHAR: case G_TYPE_UCHAR: GST_ERROR ("%s: property '%s' of type char: consider changing to " - "int/string", GST_OBJECT_NAME (element), + "int/string", G_OBJECT_CLASS_NAME (obj_class), g_param_spec_get_name (param)); /* fall through */ default: @@ -475,7 +558,7 @@ print_element_properties_info (GstElement * element) const GstCaps *caps = gst_value_get_caps (&value); if (!caps) - n_print ("%-23.23s Caps (NULL)", ""); + n_print ("%sCaps%s (NULL)", DATATYPE_COLOR, RESET_COLOR); else { print_caps (caps, " "); } @@ -494,16 +577,18 @@ print_element_properties_info (GstElement * element) j++; } - n_print ("%-23.23s Enum \"%s\" Default: %d, \"%s\"", "", - g_type_name (G_VALUE_TYPE (&value)), enum_value, value_nick); + n_print ("%sEnum \"%s\"%s %sDefault%s: %s%d, \"%s\"%s", + DATATYPE_COLOR, g_type_name (G_VALUE_TYPE (&value)), RESET_COLOR, + PROP_ATTR_NAME_COLOR, RESET_COLOR, PROP_ATTR_VALUE_COLOR, + enum_value, value_nick, RESET_COLOR); j = 0; while (values[j].value_name) { g_print ("\n"); - if (_name) - g_print ("%s", _name); - g_print ("%-23.23s (%d): %-16s - %s", "", - values[j].value, values[j].value_nick, values[j].value_name); + n_print (" %s(%d)%s: %s%-16s%s - %s%s%s", + PROP_ATTR_NAME_COLOR, values[j].value, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, values[j].value_nick, RESET_COLOR, + DESC_COLOR, values[j].value_name, RESET_COLOR); j++; } /* g_type_class_unref (ec); */ @@ -516,149 +601,189 @@ print_element_properties_info (GstElement * element) cur = flags_to_string (vals, g_value_get_flags (&value)); - n_print ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\"", "", - g_type_name (G_VALUE_TYPE (&value)), - g_value_get_flags (&value), cur); + n_print ("%sFlags \"%s\"%s %sDefault%s: %s0x%08x, \"%s\"%s", + DATATYPE_COLOR, g_type_name (G_VALUE_TYPE (&value)), RESET_COLOR, + PROP_ATTR_NAME_COLOR, RESET_COLOR, PROP_ATTR_VALUE_COLOR, + g_value_get_flags (&value), cur, RESET_COLOR); while (vals[0].value_name) { g_print ("\n"); - if (_name) - g_print ("%s", _name); - g_print ("%-23.23s (0x%08x): %-16s - %s", "", - vals[0].value, vals[0].value_nick, vals[0].value_name); + n_print (" %s(0x%08x)%s: %s%-16s%s - %s%s%s", + PROP_ATTR_NAME_COLOR, vals[0].value, RESET_COLOR, + PROP_ATTR_VALUE_COLOR, vals[0].value_nick, RESET_COLOR, + DESC_COLOR, vals[0].value_name, RESET_COLOR); ++vals; } g_free (cur); } else if (G_IS_PARAM_SPEC_OBJECT (param)) { - n_print ("%-23.23s Object of type \"%s\"", "", - g_type_name (param->value_type)); + n_print ("%sObject of type%s %s\"%s\"%s", PROP_VALUE_COLOR, + RESET_COLOR, DATATYPE_COLOR, + g_type_name (param->value_type), RESET_COLOR); } else if (G_IS_PARAM_SPEC_BOXED (param)) { - n_print ("%-23.23s Boxed pointer of type \"%s\"", "", - g_type_name (param->value_type)); + n_print ("%sBoxed pointer of type%s %s\"%s\"%s", PROP_VALUE_COLOR, + RESET_COLOR, DATATYPE_COLOR, + g_type_name (param->value_type), RESET_COLOR); + 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 ("%-23.23s Pointer of type \"%s\".", "", - g_type_name (param->value_type)); + n_print ("%sPointer of type%s %s\"%s\"%s.", PROP_VALUE_COLOR, + RESET_COLOR, DATATYPE_COLOR, g_type_name (param->value_type), + RESET_COLOR); } else { - n_print ("%-23.23s Pointer.", ""); + n_print ("%sPointer.%s", PROP_VALUE_COLOR, RESET_COLOR); } } else if (param->value_type == G_TYPE_VALUE_ARRAY) { GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (param); if (pvarray->element_spec) { - n_print ("%-23.23s Array of GValues of type \"%s\"", "", - g_type_name (pvarray->element_spec->value_type)); + n_print ("%sArray of GValues of type%s %s\"%s\"%s", + PROP_VALUE_COLOR, RESET_COLOR, DATATYPE_COLOR, + g_type_name (pvarray->element_spec->value_type), RESET_COLOR); } else { - n_print ("%-23.23s Array of GValues", ""); + n_print ("%sArray of GValues%s", PROP_VALUE_COLOR, RESET_COLOR); } } else if (GST_IS_PARAM_SPEC_FRACTION (param)) { GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param); - n_print ("%-23.23s Fraction. ", ""); - - g_print ("Range: %d/%d - %d/%d Default: %d/%d ", - pfraction->min_num, pfraction->min_den, - pfraction->max_num, pfraction->max_den, + n_print ("%sFraction%s. %sRange%s: %s%d/%d - %d/%d%s " + "%sDefault%s: %s%d/%d%s ", DATATYPE_COLOR, RESET_COLOR, + PROP_ATTR_NAME_COLOR, RESET_COLOR, PROP_ATTR_VALUE_COLOR, + pfraction->min_num, pfraction->min_den, pfraction->max_num, + pfraction->max_den, RESET_COLOR, PROP_ATTR_NAME_COLOR, + RESET_COLOR, PROP_ATTR_VALUE_COLOR, gst_value_get_fraction_numerator (&value), - gst_value_get_fraction_denominator (&value)); + gst_value_get_fraction_denominator (&value), RESET_COLOR); + } else if (param->value_type == GST_TYPE_ARRAY) { + GstParamSpecArray *parray = GST_PARAM_SPEC_ARRAY_LIST (param); + + if (parray->element_spec) { + n_print ("%sGstValueArray of GValues of type%s %s\"%s\"%s", + PROP_VALUE_COLOR, RESET_COLOR, DATATYPE_COLOR, + g_type_name (parray->element_spec->value_type), RESET_COLOR); + } else { + n_print ("%sGstValueArray of GValues%s", PROP_VALUE_COLOR, + RESET_COLOR); + } } else { - n_print ("%-23.23s Unknown type %ld \"%s\"", "", param->value_type, - g_type_name (param->value_type)); + n_print ("%sUnknown type %ld%s %s\"%s\"%s", PROP_VALUE_COLOR, + (glong) param->value_type, RESET_COLOR, DATATYPE_COLOR, + g_type_name (param->value_type), RESET_COLOR); } break; } if (!readable) - g_print (" Write only\n"); + g_print (" %sWrite only%s\n", PROP_VALUE_COLOR, RESET_COLOR); else g_print ("\n"); + pop_indent_n (11); + g_value_reset (&value); } if (num_properties == 0) - n_print (" none\n"); + n_print ("%snone%s\n", PROP_VALUE_COLOR, RESET_COLOR); + + 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) { - GstElementClass *gstelement_class; const GList *pads; GstStaticPadTemplate *padtemplate; + GstPadTemplate *tmpl; + + n_print ("%sPad Templates%s:\n", HEADING_COLOR, RESET_COLOR); + + push_indent (); - n_print ("Pad Templates:\n"); if (gst_element_factory_get_num_pad_templates (factory) == 0) { - n_print (" none\n"); - return; + n_print ("%snone%s\n", PROP_VALUE_COLOR, RESET_COLOR); + goto done; } - gstelement_class = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element)); - 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); + n_print ("%sSRC template%s: %s'%s'%s\n", PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR, padtemplate->name_template, RESET_COLOR); else if (padtemplate->direction == GST_PAD_SINK) - n_print (" SINK template: '%s'\n", padtemplate->name_template); + n_print ("%sSINK template%s: %s'%s'%s\n", PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR, padtemplate->name_template, RESET_COLOR); else - n_print (" UNKNOWN!!! template: '%s'\n", padtemplate->name_template); + n_print ("%sUNKNOWN template%s: %s'%s'%s\n", PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR, padtemplate->name_template, RESET_COLOR); + + push_indent (); if (padtemplate->presence == GST_PAD_ALWAYS) - n_print (" Availability: Always\n"); + n_print ("%sAvailability%s: %sAlways%s\n", PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR, RESET_COLOR); else if (padtemplate->presence == GST_PAD_SOMETIMES) - n_print (" Availability: Sometimes\n"); + n_print ("%sAvailability%s: %sSometimes%s\n", PROP_NAME_COLOR, + RESET_COLOR, PROP_VALUE_COLOR, RESET_COLOR); else if (padtemplate->presence == GST_PAD_REQUEST) { - n_print (" Availability: On request\n"); - n_print (" Has request_new_pad() function: %s\n", - GST_DEBUG_FUNCPTR_NAME (gstelement_class->request_new_pad)); + n_print ("%sAvailability%s: %sOn request%s\n", PROP_NAME_COLOR, + RESET_COLOR, PROP_VALUE_COLOR, RESET_COLOR); } else - n_print (" Availability: UNKNOWN!!!\n"); + n_print ("%sAvailability%s: %sUNKNOWN%s\n", PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR, RESET_COLOR); if (padtemplate->static_caps.string) { - n_print (" Capabilities:\n"); - print_caps (gst_static_caps_get (&padtemplate->static_caps), " "); - } + GstCaps *caps = gst_static_caps_get (&padtemplate->static_caps); - n_print ("\n"); - } -} + n_print ("%sCapabilities%s:\n", PROP_NAME_COLOR, RESET_COLOR); -static void -print_element_flag_info (GstElement * element) -{ - gboolean have_flags = FALSE; + push_indent (); + print_caps (caps, ""); // FIXME + pop_indent (); - n_print ("\n"); - n_print ("Element Flags:\n"); + gst_caps_unref (caps); + } - if (!have_flags) - n_print (" no flags set\n"); + 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 (GST_IS_BIN (element)) { - n_print ("\n"); - n_print ("Bin Flags:\n"); - if (!have_flags) - n_print (" no flags set\n"); - } -} + if (pad_type != G_TYPE_NONE && pad_type != GST_TYPE_PAD) { + gpointer pad_klass; -static void -print_implementation_info (GstElement * element) -{ - GstElementClass *gstelement_class; + pad_klass = g_type_class_ref (pad_type); + n_print ("%sType%s: %s%s%s\n", PROP_NAME_COLOR, RESET_COLOR, + DATATYPE_COLOR, g_type_name (pad_type), RESET_COLOR); + print_object_properties_info (NULL, pad_klass, "Pad Properties"); + g_type_class_unref (pad_klass); + } + } - gstelement_class = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element)); + pop_indent (); - n_print ("\n"); - n_print ("Element Implementation:\n"); + if (pads != NULL) + n_print ("\n"); + } - n_print (" Has change_state() function: %s\n", - GST_DEBUG_FUNCPTR_NAME (gstelement_class->change_state)); +done: + pop_indent (); } static void @@ -673,14 +798,18 @@ print_clocking_info (GstElement * element) if (!requires_clock && !provides_clock) { n_print ("\n"); - n_print ("Element has no clocking capabilities."); + n_print ("%sElement has no clocking capabilities.%s\n", DESC_COLOR, + RESET_COLOR); return; } n_print ("\n"); - n_print ("Clocking Interaction:\n"); + n_print ("%sClocking Interaction%s:\n", PROP_NAME_COLOR, RESET_COLOR); + + push_indent (); + if (requires_clock) { - n_print (" element requires a clock\n"); + n_print ("%selement requires a clock%s\n", PROP_VALUE_COLOR, RESET_COLOR); } if (provides_clock) { @@ -688,24 +817,15 @@ print_clocking_info (GstElement * element) clock = gst_element_get_clock (element); if (clock) { - n_print (" element provides a clock: %s\n", GST_OBJECT_NAME (clock)); + n_print ("%selement provides a clock%s: %s%s%s\n", PROP_VALUE_COLOR, + RESET_COLOR, DATATYPE_COLOR, GST_OBJECT_NAME (clock), RESET_COLOR); gst_object_unref (clock); } else - n_print (" element is supposed to provide a clock but returned NULL\n"); + n_print ("%selement is supposed to provide a clock but returned NULL%s\n", + PROP_VALUE_COLOR, RESET_COLOR); } -} -static void -print_index_info (GstElement * element) -{ - if (GST_OBJECT_FLAG_IS_SET (element, GST_ELEMENT_FLAG_INDEXABLE)) { - n_print ("\n"); - n_print ("Indexing capabilities:\n"); - n_print (" element can do indexing\n"); - } else { - n_print ("\n"); - n_print ("Element has no indexing capabilities.\n"); - } + pop_indent (); } static void @@ -726,18 +846,30 @@ print_uri_handler_info (GstElement * element) uri_protocols = gst_uri_handler_get_protocols (GST_URI_HANDLER (element)); n_print ("\n"); - n_print ("URI handling capabilities:\n"); - n_print (" Element can act as %s.\n", uri_type); + n_print ("%sURI handling capabilities:%s\n", PROP_NAME_COLOR, RESET_COLOR); + + push_indent (); + + n_print ("%sElement can act as %s.%s\n", PROP_VALUE_COLOR, uri_type, + RESET_COLOR); if (uri_protocols && *uri_protocols) { - n_print (" Supported URI protocols:\n"); + n_print ("%sSupported URI protocols%s:\n", PROP_ATTR_NAME_COLOR, + RESET_COLOR); + push_indent (); for (; *uri_protocols != NULL; uri_protocols++) - n_print (" %s\n", *uri_protocols); + n_print ("%s%s%s\n", PROP_ATTR_VALUE_COLOR, *uri_protocols, + RESET_COLOR); + pop_indent (); } else { - n_print (" No supported URI protocols\n"); + n_print ("%sNo supported URI protocols%s\n", PROP_VALUE_COLOR, + RESET_COLOR); } + + pop_indent (); } else { - n_print ("Element has no URI handling capabilities.\n"); + n_print ("%sElement has no URI handling capabilities.%s\n", DESC_COLOR, + RESET_COLOR); } } @@ -748,11 +880,13 @@ print_pad_info (GstElement * element) GstPad *pad; n_print ("\n"); - n_print ("Pads:\n"); + n_print ("%sPads:%s\n", HEADING_COLOR, RESET_COLOR); + + push_indent (); if (!element->numpads) { - n_print (" none\n"); - return; + n_print ("%snone%s\n", PROP_VALUE_COLOR, RESET_COLOR); + goto done; } pads = element->pads; @@ -763,48 +897,38 @@ print_pad_info (GstElement * element) pad = GST_PAD (pads->data); pads = g_list_next (pads); - n_print (""); - name = gst_pad_get_name (pad); if (gst_pad_get_direction (pad) == GST_PAD_SRC) - g_print (" SRC: '%s'", name); + n_print ("%sSRC%s: %s'%s'%s\n", PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR, name, RESET_COLOR); else if (gst_pad_get_direction (pad) == GST_PAD_SINK) - g_print (" SINK: '%s'", name); + n_print ("%sSINK%s: %s'%s'%s\n", PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR, name, RESET_COLOR); else - g_print (" UNKNOWN!!!: '%s'", name); + n_print ("%sUNKNOWN%s: %s'%s'%s\n", PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR, name, RESET_COLOR); g_free (name); - g_print ("\n"); - - n_print (" Implementation:\n"); - if (pad->chainfunc) - n_print (" Has chainfunc(): %s\n", - GST_DEBUG_FUNCPTR_NAME (pad->chainfunc)); - if (pad->getrangefunc) - n_print (" Has getrangefunc(): %s\n", - GST_DEBUG_FUNCPTR_NAME (pad->getrangefunc)); - if (pad->eventfunc != gst_pad_event_default) - n_print (" Has custom eventfunc(): %s\n", - GST_DEBUG_FUNCPTR_NAME (pad->eventfunc)); - if (pad->queryfunc != gst_pad_query_default) - n_print (" Has custom queryfunc(): %s\n", - GST_DEBUG_FUNCPTR_NAME (pad->queryfunc)); - - if (pad->iterintlinkfunc != gst_pad_iterate_internal_links_default) - n_print (" Has custom iterintlinkfunc(): %s\n", - GST_DEBUG_FUNCPTR_NAME (pad->iterintlinkfunc)); - - if (pad->padtemplate) - n_print (" Pad Template: '%s'\n", pad->padtemplate->name_template); + if (pad->padtemplate) { + push_indent (); + n_print ("%sPad Template%s: %s'%s'%s\n", PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR, pad->padtemplate->name_template, RESET_COLOR); + pop_indent (); + } caps = gst_pad_get_current_caps (pad); if (caps) { - n_print (" Capabilities:\n"); - print_caps (caps, " "); + n_print ("%sCapabilities:%s\n", PROP_NAME_COLOR, RESET_COLOR); + push_indent (); + print_caps (caps, ""); // FIXME + pop_indent (); gst_caps_unref (caps); } } + +done: + pop_indent (); } static gboolean @@ -821,6 +945,19 @@ has_sometimes_template (GstElement * element) 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) { @@ -875,45 +1012,53 @@ print_signal_info (GstElement * element) if (found_signals) { n_print ("\n"); if (k == 0) - n_print ("Element Signals:\n"); + n_print ("%sElement Signals%s:\n", HEADING_COLOR, RESET_COLOR); else - n_print ("Element Actions:\n"); + n_print ("%sElement Actions%s:\n", HEADING_COLOR, RESET_COLOR); } 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) + strlen (g_type_name (query->return_type)) + 24; + if (gtype_needs_ptr_marker (query->return_type)) { + pmark = "* "; + indent_len += 2; + } else { + pmark = " "; + } + indent = g_new0 (gchar, indent_len + 1); memset (indent, ' ', indent_len); - n_print (" \"%s\" : %s user_function (%s* object", - query->signal_name, - g_type_name (query->return_type), g_type_name (type)); + n_print (" %s\"%s\"%s : %s%s%s%suser_function%s (%s%s%s* object%s", + PROP_NAME_COLOR, query->signal_name, RESET_COLOR, + DATATYPE_COLOR, g_type_name (query->return_type), PROP_VALUE_COLOR, + pmark, RESET_COLOR, DATATYPE_COLOR, g_type_name (type), + PROP_VALUE_COLOR, RESET_COLOR); for (j = 0; j < query->n_params; j++) { + const gchar *type_name, *asterisk; + + type_name = g_type_name (query->param_types[j]); + asterisk = gtype_needs_ptr_marker (query->param_types[j]) ? "*" : ""; + g_print (",\n"); - if (G_TYPE_IS_FUNDAMENTAL (query->param_types[j])) { - n_print ("%s%s arg%d", indent, - g_type_name (query->param_types[j]), j); - } else if (G_TYPE_IS_ENUM (query->param_types[j])) { - n_print ("%s%s arg%d", indent, - g_type_name (query->param_types[j]), j); - } else { - n_print ("%s%s* arg%d", indent, - g_type_name (query->param_types[j]), j); - } + n_print ("%s%s%s%s%s arg%d%s", indent, DATATYPE_COLOR, type_name, + PROP_VALUE_COLOR, asterisk, j, RESET_COLOR); } if (k == 0) { g_print (",\n"); - n_print ("%sgpointer user_data);\n", indent); + n_print ("%s%sgpointer %suser_data%s);\n", indent, DATATYPE_COLOR, + PROP_VALUE_COLOR, RESET_COLOR); } else g_print (");\n"); @@ -938,22 +1083,42 @@ print_children_info (GstElement * element) children = (GList *) GST_BIN (element)->children; if (children) { n_print ("\n"); - n_print ("Children:\n"); + n_print ("%sChildren%s:\n", HEADING_COLOR, RESET_COLOR); } while (children) { - n_print (" %s\n", GST_ELEMENT_NAME (GST_ELEMENT (children->data))); + n_print (" %s%s%s\n", DATATYPE_COLOR, + GST_ELEMENT_NAME (GST_ELEMENT (children->data)), RESET_COLOR); children = g_list_next (children); } } static void +print_preset_list (GstElement * element) +{ + gchar **presets, **preset; + + if (!GST_IS_PRESET (element)) + return; + + presets = gst_preset_get_preset_names (GST_PRESET (element)); + if (presets && *presets) { + n_print ("\n"); + n_print ("%sPresets%s:\n", HEADING_COLOR, RESET_COLOR); + for (preset = presets; *preset; preset++) { + n_print (" \"%s\"\n", *preset); + } + g_strfreev (presets); + } +} + +static void print_blacklist (void) { GList *plugins, *cur; gint count = 0; - g_print ("%s\n", _("Blacklisted files:")); + g_print ("%s%s%s\n", HEADING_COLOR, _("Blacklisted files:"), RESET_COLOR); plugins = gst_registry_get_plugin_list (gst_registry_get ()); for (cur = plugins; cur != NULL; cur = g_list_next (cur)) { @@ -965,18 +1130,40 @@ print_blacklist (void) } g_print ("\n"); - g_print (_("Total count: ")); + g_print (_("%sTotal count%s: %s"), PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR); g_print (ngettext ("%d blacklisted file", "%d blacklisted files", count), count); - g_print ("\n"); + g_print ("%s\n", RESET_COLOR); gst_plugin_list_free (plugins); } static void -print_element_list (gboolean print_all) +print_typefind_extensions (const gchar * const *extensions, const gchar * color) +{ + guint i = 0; + + while (extensions[i]) { + g_print ("%s%s%s%s", i > 0 ? ", " : "", color, extensions[i], RESET_COLOR); + i++; + } +} + +static void +print_element_list (gboolean print_all, gchar * ftypes) { int plugincount = 0, featurecount = 0, blacklistcount = 0; GList *plugins, *orig_plugins; + gchar **types = NULL; + + if (ftypes) { + gint i; + + types = g_strsplit (ftypes, "/", -1); + for (i = 0; types[i]; i++) + *types[i] = g_ascii_toupper (*types[i]); + + } orig_plugins = plugins = gst_registry_get_plugin_list (gst_registry_get ()); while (plugins) { @@ -1004,53 +1191,65 @@ print_element_list (gboolean print_all) featurecount++; if (GST_IS_ELEMENT_FACTORY (feature)) { + const gchar *klass; GstElementFactory *factory; factory = GST_ELEMENT_FACTORY (feature); + if (types) { + gint i; + gboolean all_found = TRUE; + + klass = + gst_element_factory_get_metadata (factory, + GST_ELEMENT_METADATA_KLASS); + for (i = 0; types[i]; i++) { + if (!strstr (klass, types[i])) { + all_found = FALSE; + break; + } + } + + if (!all_found) + goto next; + } if (print_all) - print_element_info (factory, TRUE); + print_element_info (feature, TRUE); else - g_print ("%s: %s: %s\n", gst_plugin_get_name (plugin), - GST_OBJECT_NAME (factory), + g_print ("%s%s%s: %s%s%s: %s%s%s\n", PLUGIN_NAME_COLOR, + gst_plugin_get_name (plugin), RESET_COLOR, ELEMENT_NAME_COLOR, + GST_OBJECT_NAME (factory), RESET_COLOR, ELEMENT_DETAIL_COLOR, gst_element_factory_get_metadata (factory, - GST_ELEMENT_METADATA_LONGNAME)); -#if 0 - } else if (GST_IS_INDEX_FACTORY (feature)) { - GstIndexFactory *factory; - - factory = GST_INDEX_FACTORY (feature); - if (!print_all) - g_print ("%s: %s: %s\n", plugin->desc.name, - GST_OBJECT_NAME (factory), factory->longdesc); -#endif + GST_ELEMENT_METADATA_LONGNAME), RESET_COLOR); } else if (GST_IS_TYPE_FIND_FACTORY (feature)) { GstTypeFindFactory *factory; const gchar *const *extensions; + if (types) + goto next; factory = GST_TYPE_FIND_FACTORY (feature); if (!print_all) - g_print ("%s: %s: ", gst_plugin_get_name (plugin), - gst_plugin_feature_get_name (feature)); + g_print ("%s%s%s: %s%s%s: ", PLUGIN_NAME_COLOR, + gst_plugin_get_name (plugin), RESET_COLOR, ELEMENT_NAME_COLOR, + gst_plugin_feature_get_name (feature), RESET_COLOR); extensions = gst_type_find_factory_get_extensions (factory); if (extensions != NULL) { - guint i = 0; - - while (extensions[i]) { - if (!print_all) - g_print ("%s%s", i > 0 ? ", " : "", extensions[i]); - i++; - } - if (!print_all) + if (!print_all) { + print_typefind_extensions (extensions, ELEMENT_DETAIL_COLOR); g_print ("\n"); + } } else { if (!print_all) - g_print ("no extensions\n"); + g_print ("%sno extensions%s\n", ELEMENT_DETAIL_COLOR, RESET_COLOR); } } else { + if (types) + goto next; if (!print_all) - n_print ("%s: %s (%s)\n", gst_plugin_get_name (plugin), - GST_OBJECT_NAME (feature), g_type_name (G_OBJECT_TYPE (feature))); + n_print ("%s%s%s: %s%s%s (%s%s%s)\n", PLUGIN_NAME_COLOR, + gst_plugin_get_name (plugin), RESET_COLOR, ELEMENT_NAME_COLOR, + GST_OBJECT_NAME (feature), RESET_COLOR, ELEMENT_DETAIL_COLOR, + g_type_name (G_OBJECT_TYPE (feature)), RESET_COLOR); } next: @@ -1061,9 +1260,11 @@ print_element_list (gboolean print_all) } gst_plugin_list_free (orig_plugins); + g_strfreev (types); g_print ("\n"); - g_print (_("Total count: ")); + g_print (_("%sTotal count%s: %s"), PROP_NAME_COLOR, RESET_COLOR, + PROP_VALUE_COLOR); g_print (ngettext ("%d plugin", "%d plugins", plugincount), plugincount); if (blacklistcount) { g_print (" ("); @@ -1071,9 +1272,9 @@ print_element_list (gboolean print_all) blacklistcount), blacklistcount); g_print (" not shown)"); } - g_print (", "); + g_print ("%s, %s", RESET_COLOR, PROP_VALUE_COLOR); g_print (ngettext ("%d feature", "%d features", featurecount), featurecount); - g_print ("\n"); + g_print ("%s\n", RESET_COLOR); } static void @@ -1114,8 +1315,8 @@ print_all_uri_handlers (void) if (GST_IS_URI_HANDLER (element)) { const gchar *const *uri_protocols; + const gchar *const *protocol; const gchar *dir; - gchar *joined; switch (gst_uri_handler_get_uri_type (GST_URI_HANDLER (element))) { case GST_URI_SRC: @@ -1129,16 +1330,22 @@ print_all_uri_handlers (void) break; } - uri_protocols = - gst_uri_handler_get_protocols (GST_URI_HANDLER (element)); - joined = g_strjoinv (", ", (gchar **) uri_protocols); - - g_print ("%s (%s, rank %u): %s\n", - gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)), dir, + g_print ("%s%s%s (%s%s%s, %srank %u%s): ", + FEATURE_NAME_COLOR, + gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)), + RESET_COLOR, FEATURE_DIR_COLOR, dir, RESET_COLOR, + FEATURE_RANK_COLOR, gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory)), - joined); + RESET_COLOR); - g_free (joined); + uri_protocols = + gst_uri_handler_get_protocols (GST_URI_HANDLER (element)); + for (protocol = uri_protocols; *protocol != NULL; protocol++) { + if (protocol != uri_protocols) + g_print (", "); + g_print ("%s%s%s", FEATURE_PROTO_COLOR, *protocol, RESET_COLOR); + } + g_print ("\n"); } gst_object_unref (element); @@ -1158,20 +1365,29 @@ print_plugin_info (GstPlugin * plugin) const gchar *release_date = gst_plugin_get_release_date_string (plugin); const gchar *filename = gst_plugin_get_filename (plugin); - n_print ("Plugin Details:\n"); - n_print (" %-25s%s\n", "Name", gst_plugin_get_name (plugin)); - n_print (" %-25s%s\n", "Description", gst_plugin_get_description (plugin)); - n_print (" %-25s%s\n", "Filename", (filename != NULL) ? filename : "(null)"); - n_print (" %-25s%s\n", "Version", gst_plugin_get_version (plugin)); - n_print (" %-25s%s\n", "License", gst_plugin_get_license (plugin)); - n_print (" %-25s%s\n", "Source module", gst_plugin_get_source (plugin)); + n_print ("%sPlugin Details%s:\n", HEADING_COLOR, RESET_COLOR); + + push_indent (); + + n_print ("%s%-25s%s%s%s%s\n", PROP_NAME_COLOR, "Name", RESET_COLOR, + PROP_VALUE_COLOR, gst_plugin_get_name (plugin), RESET_COLOR); + n_print ("%s%-25s%s%s%s%s\n", PROP_NAME_COLOR, "Description", RESET_COLOR, + PROP_VALUE_COLOR, gst_plugin_get_description (plugin), RESET_COLOR); + n_print ("%s%-25s%s%s%s%s\n", PROP_NAME_COLOR, "Filename", RESET_COLOR, + PROP_VALUE_COLOR, (filename != NULL) ? filename : "(null)", RESET_COLOR); + n_print ("%s%-25s%s%s%s%s\n", PROP_NAME_COLOR, "Version", RESET_COLOR, + PROP_VALUE_COLOR, gst_plugin_get_version (plugin), RESET_COLOR); + n_print ("%s%-25s%s%s%s%s\n", PROP_NAME_COLOR, "License", RESET_COLOR, + PROP_VALUE_COLOR, gst_plugin_get_license (plugin), RESET_COLOR); + n_print ("%s%-25s%s%s%s%s\n", PROP_NAME_COLOR, "Source module", RESET_COLOR, + PROP_VALUE_COLOR, gst_plugin_get_source (plugin), RESET_COLOR); if (release_date != NULL) { const gchar *tz = "(UTC)"; gchar *str, *sep; - /* may be: YYYY-MM-DD or YYYY-MM-DDTHH:MMZ */ - /* YYYY-MM-DDTHH:MMZ => YYYY-MM-DD HH:MM (UTC) */ +/* may be: YYYY-MM-DD or YYYY-MM-DDTHH:MMZ */ +/* YYYY-MM-DDTHH:MMZ => YYYY-MM-DD HH:MM (UTC) */ str = g_strdup (release_date); sep = strstr (str, "T"); if (sep != NULL) { @@ -1182,11 +1398,17 @@ print_plugin_info (GstPlugin * plugin) } else { tz = ""; } - n_print (" %-25s%s%s\n", "Source release date", str, tz); + n_print ("%s%-25s%s%s%s%s%s\n", PROP_NAME_COLOR, "Source release date", + RESET_COLOR, PROP_VALUE_COLOR, str, tz, RESET_COLOR); g_free (str); } - n_print (" %-25s%s\n", "Binary package", gst_plugin_get_package (plugin)); - n_print (" %-25s%s\n", "Origin URL", gst_plugin_get_origin (plugin)); + n_print ("%s%-25s%s%s%s%s\n", PROP_NAME_COLOR, "Binary package", RESET_COLOR, + PROP_VALUE_COLOR, gst_plugin_get_package (plugin), RESET_COLOR); + n_print ("%s%-25s%s%s%s%s\n", PROP_NAME_COLOR, "Origin URL", RESET_COLOR, + PROP_VALUE_COLOR, gst_plugin_get_origin (plugin), RESET_COLOR); + + pop_indent (); + n_print ("\n"); } @@ -1196,8 +1418,9 @@ print_plugin_features (GstPlugin * plugin) GList *features, *origlist; gint num_features = 0; gint num_elements = 0; + gint num_tracers = 0; gint num_typefinders = 0; - gint num_indexes = 0; + gint num_devproviders = 0; gint num_other = 0; origlist = features = @@ -1213,18 +1436,11 @@ print_plugin_features (GstPlugin * plugin) GstElementFactory *factory; factory = GST_ELEMENT_FACTORY (feature); - n_print (" %s: %s\n", GST_OBJECT_NAME (factory), + n_print (" %s%s%s: %s%s%s\n", ELEMENT_NAME_COLOR, + GST_OBJECT_NAME (factory), RESET_COLOR, ELEMENT_DETAIL_COLOR, gst_element_factory_get_metadata (factory, - GST_ELEMENT_METADATA_LONGNAME)); + GST_ELEMENT_METADATA_LONGNAME), RESET_COLOR); num_elements++; -#if 0 - } else if (GST_IS_INDEX_FACTORY (feature)) { - GstIndexFactory *factory; - - factory = GST_INDEX_FACTORY (feature); - n_print (" %s: %s\n", GST_OBJECT_NAME (factory), factory->longdesc); - num_indexes++; -#endif } else if (GST_IS_TYPE_FIND_FACTORY (feature)) { GstTypeFindFactory *factory; const gchar *const *extensions; @@ -1232,23 +1448,34 @@ print_plugin_features (GstPlugin * plugin) factory = GST_TYPE_FIND_FACTORY (feature); extensions = gst_type_find_factory_get_extensions (factory); if (extensions) { - guint i = 0; - - g_print ("%s: %s: ", gst_plugin_get_name (plugin), - gst_plugin_feature_get_name (feature)); - while (extensions[i]) { - g_print ("%s%s", i > 0 ? ", " : "", extensions[i]); - i++; - } + g_print (" %s%s%s: ", ELEMENT_NAME_COLOR, + gst_plugin_feature_get_name (feature), RESET_COLOR); + print_typefind_extensions (extensions, ELEMENT_DETAIL_COLOR); g_print ("\n"); } else - g_print ("%s: %s: no extensions\n", gst_plugin_get_name (plugin), - gst_plugin_feature_get_name (feature)); + g_print (" %s%s%s: %sno extensions%s\n", ELEMENT_NAME_COLOR, + gst_plugin_feature_get_name (feature), RESET_COLOR, + ELEMENT_DETAIL_COLOR, RESET_COLOR); num_typefinders++; + } else if (GST_IS_DEVICE_PROVIDER_FACTORY (feature)) { + GstDeviceProviderFactory *factory; + + factory = GST_DEVICE_PROVIDER_FACTORY (feature); + n_print (" %s%s%s: %s%s%s\n", ELEMENT_NAME_COLOR, + GST_OBJECT_NAME (factory), RESET_COLOR, ELEMENT_DETAIL_COLOR, + gst_device_provider_factory_get_metadata (factory, + GST_ELEMENT_METADATA_LONGNAME), RESET_COLOR); + num_devproviders++; + } else if (GST_IS_TRACER_FACTORY (feature)) { + n_print (" %s%s%s (%s%s%s)\n", ELEMENT_NAME_COLOR, + gst_object_get_name (GST_OBJECT (feature)), RESET_COLOR, + DATATYPE_COLOR, g_type_name (G_OBJECT_TYPE (feature)), RESET_COLOR); + num_tracers++; } else if (feature) { - n_print (" %s (%s)\n", gst_object_get_name (GST_OBJECT (feature)), - g_type_name (G_OBJECT_TYPE (feature))); + n_print (" %s%s%s (%s%s%s)\n", ELEMENT_NAME_COLOR, + gst_object_get_name (GST_OBJECT (feature)), RESET_COLOR, + DATATYPE_COLOR, g_type_name (G_OBJECT_TYPE (feature)), RESET_COLOR); num_other++; } num_features++; @@ -1258,68 +1485,85 @@ print_plugin_features (GstPlugin * plugin) gst_plugin_feature_list_free (origlist); n_print ("\n"); - n_print (" %d features:\n", num_features); + n_print (" %s%d features%s:\n", HEADING_COLOR, num_features, RESET_COLOR); if (num_elements > 0) - n_print (" +-- %d elements\n", num_elements); + n_print (" %s+--%s %s%d elements%s\n", CHILD_LINK_COLOR, RESET_COLOR, + PLUGIN_FEATURE_COLOR, num_elements, RESET_COLOR); if (num_typefinders > 0) - n_print (" +-- %d typefinders\n", num_typefinders); - if (num_indexes > 0) - n_print (" +-- %d indexes\n", num_indexes); + n_print (" %s+--%s %s%d typefinders%s\n", CHILD_LINK_COLOR, RESET_COLOR, + PLUGIN_FEATURE_COLOR, num_typefinders, RESET_COLOR); + if (num_devproviders > 0) + n_print (" %s+--%s %s%d device providers%s\n", CHILD_LINK_COLOR, + RESET_COLOR, PLUGIN_FEATURE_COLOR, num_devproviders, RESET_COLOR); + if (num_tracers > 0) + n_print (" %s+--%s %s%d tracers%s\n", CHILD_LINK_COLOR, RESET_COLOR, + PLUGIN_FEATURE_COLOR, num_tracers, RESET_COLOR); if (num_other > 0) - n_print (" +-- %d other objects\n", num_other); + n_print (" %s+--%s %s%d other objects%s\n", CHILD_LINK_COLOR, RESET_COLOR, + PLUGIN_FEATURE_COLOR, num_other, RESET_COLOR); n_print ("\n"); } static int -print_element_features (const gchar * element_name) +print_feature_info (const gchar * feature_name, gboolean print_all) { GstPluginFeature *feature; + GstRegistry *registry = gst_registry_get (); + int ret; - /* FIXME implement other pretty print function for these */ -#if 0 - feature = gst_default_registry_find_feature (element_name, - GST_TYPE_INDEX_FACTORY); - if (feature) { - n_print ("%s: an index\n", element_name); - return 0; + if ((feature = gst_registry_find_feature (registry, feature_name, + GST_TYPE_ELEMENT_FACTORY))) { + ret = print_element_info (feature, print_all); + goto handled; } -#endif - feature = gst_registry_find_feature (gst_registry_get (), element_name, - GST_TYPE_TYPE_FIND_FACTORY); - if (feature) { - n_print ("%s: a typefind function\n", element_name); - return 0; + if ((feature = gst_registry_find_feature (registry, feature_name, + GST_TYPE_TYPE_FIND_FACTORY))) { + ret = print_typefind_info (feature, print_all); + goto handled; } + if ((feature = gst_registry_find_feature (registry, feature_name, + GST_TYPE_TRACER_FACTORY))) { + ret = print_tracer_info (feature, print_all); + goto handled; + } + + /* TODO: handle DEVICE_PROVIDER_FACTORY */ return -1; + +handled: + gst_object_unref (feature); + return ret; } static int -print_element_info (GstElementFactory * factory, gboolean print_names) +print_element_info (GstPluginFeature * feature, gboolean print_names) { + GstElementFactory *factory; GstElement *element; GstPlugin *plugin; gint maxlevel = 0; - factory = - GST_ELEMENT_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE - (factory))); - + factory = GST_ELEMENT_FACTORY (gst_plugin_feature_load (feature)); if (!factory) { - g_print ("element plugin couldn't be loaded\n"); + g_print ("%selement plugin couldn't be loaded%s\n", DESC_COLOR, + RESET_COLOR); return -1; } element = gst_element_factory_create (factory, NULL); if (!element) { gst_object_unref (factory); - g_print ("couldn't construct element for some reason\n"); + g_print ("%scouldn't construct element for some reason%s\n", DESC_COLOR, + RESET_COLOR); return -1; } if (print_names) - _name = g_strdup_printf ("%s: ", GST_OBJECT_NAME (factory)); + _name = + g_strdup_printf ("%s%s%s: ", DATATYPE_COLOR, GST_OBJECT_NAME (factory), + RESET_COLOR); else _name = NULL; @@ -1335,24 +1579,146 @@ print_element_info (GstElementFactory * factory, gboolean print_names) print_interfaces (G_OBJECT_TYPE (element)); print_pad_templates_info (element, factory); - print_element_flag_info (element); - print_implementation_info (element); print_clocking_info (element); - print_index_info (element); print_uri_handler_info (element); print_pad_info (element); print_element_properties_info (element); print_signal_info (element); print_children_info (element); + print_preset_list (element); gst_object_unref (element); gst_object_unref (factory); g_free (_name); + return 0; +} +static int +print_typefind_info (GstPluginFeature * feature, gboolean print_names) +{ + GstTypeFindFactory *factory; + GstPlugin *plugin; + GstCaps *caps; + GstRank rank; + char s[20]; + const gchar *const *extensions; + + factory = GST_TYPE_FIND_FACTORY (gst_plugin_feature_load (feature)); + if (!factory) { + g_print ("%stypefind plugin couldn't be loaded%s\n", DESC_COLOR, + RESET_COLOR); + return -1; + } + + if (print_names) + _name = + g_strdup_printf ("%s%s%s: ", DATATYPE_COLOR, GST_OBJECT_NAME (factory), + RESET_COLOR); + else + _name = NULL; + + n_print ("%sFactory Details%s:\n", HEADING_COLOR, RESET_COLOR); + rank = gst_plugin_feature_get_rank (feature); + n_print (" %s%-25s%s%s (%d)%s\n", PROP_NAME_COLOR, "Rank", PROP_VALUE_COLOR, + get_rank_name (s, rank), rank, RESET_COLOR); + n_print (" %s%-25s%s%s%s\n", PROP_NAME_COLOR, "Name", PROP_VALUE_COLOR, + GST_OBJECT_NAME (factory), RESET_COLOR); + caps = gst_type_find_factory_get_caps (factory); + if (caps) { + gchar *caps_str = gst_caps_to_string (factory->caps); + + n_print (" %s%-25s%s%s%s\n", PROP_NAME_COLOR, "Caps", PROP_VALUE_COLOR, + caps_str, RESET_COLOR); + g_free (caps_str); + } + extensions = gst_type_find_factory_get_extensions (factory); + if (extensions) { + n_print (" %s%-25s%s", PROP_NAME_COLOR, "Extensions", RESET_COLOR); + print_typefind_extensions (extensions, PROP_VALUE_COLOR); + n_print ("\n"); + } + n_print ("\n"); + + plugin = gst_plugin_feature_get_plugin (GST_PLUGIN_FEATURE (factory)); + if (plugin) { + print_plugin_info (plugin); + gst_object_unref (plugin); + } + + gst_object_unref (factory); + g_free (_name); return 0; } +static int +print_tracer_info (GstPluginFeature * feature, gboolean print_names) +{ + GstTracerFactory *factory; + GstTracer *tracer; + GstPlugin *plugin; + gint maxlevel = 0; + + factory = GST_TRACER_FACTORY (gst_plugin_feature_load (feature)); + if (!factory) { + g_print ("%stracer plugin couldn't be loaded%s\n", DESC_COLOR, RESET_COLOR); + return -1; + } + + tracer = (GstTracer *) g_object_new (factory->type, NULL); + if (!tracer) { + gst_object_unref (factory); + g_print ("%scouldn't construct tracer for some reason%s\n", DESC_COLOR, + RESET_COLOR); + return -1; + } + if (print_names) + _name = + g_strdup_printf ("%s%s%s: ", DATATYPE_COLOR, GST_OBJECT_NAME (factory), + RESET_COLOR); + else + _name = NULL; + + n_print ("%sFactory Details%s:\n", HEADING_COLOR, RESET_COLOR); + n_print (" %s%-25s%s%s%s\n", PROP_NAME_COLOR, "Name", PROP_VALUE_COLOR, + GST_OBJECT_NAME (factory), RESET_COLOR); + n_print ("\n"); + + plugin = gst_plugin_feature_get_plugin (GST_PLUGIN_FEATURE (factory)); + if (plugin) { + print_plugin_info (plugin); + gst_object_unref (plugin); + } + + print_hierarchy (G_OBJECT_TYPE (tracer), 0, &maxlevel); + print_interfaces (G_OBJECT_TYPE (tracer)); + + /* TODO: list what hooks it registers + * - the data is available in gsttracerutils, we need to iterate the + * _priv_tracers hashtable for each probe and then check the list of hooks + * for each probe whether hook->tracer == tracer :/ + */ + + /* TODO: list what records it emits + * - in class_init tracers can create GstTracerRecord instances + * - those only get logged right now and there is no association with the + * tracer that created them + * - we'd need to add them to GstTracerFactory + * gst_tracer_class_add_record (klass, record); + * - needs work in gstregistrychunks to (de)serialize specs + * - gst_tracer_register() would need to iterate the list of records and + * copy the record->spec into the factory + */ + + gst_object_unref (tracer); + gst_object_unref (factory); + g_free (_name); + return 0; +} + +/* NOTE: Not coloring output from automatic install functions, as their output + * is meant for machines, not humans. + */ static void print_plugin_automatic_install_info_codecs (GstElementFactory * factory) { @@ -1500,6 +1866,81 @@ print_all_plugin_automatic_install_info (void) gst_plugin_list_free (orig_plugins); } +#ifdef G_OS_UNIX +static void +redirect_stdout (void) +{ + int pipefd[2]; + pid_t child_id; + + if (pipe (pipefd) == -1) { + g_printerr (_("Error creating pipe: %s\n"), g_strerror (errno)); + exit (-1); + } + + child_id = fork (); + if (child_id == -1) { + g_printerr (_("Error forking: %s\n"), g_strerror (errno)); + exit (-1); + } + + if (child_id == 0) { + char **argv; + const char *pager; + int ret; + + pager = g_getenv ("PAGER"); + if (pager == NULL) + pager = DEFAULT_PAGER; + argv = g_strsplit (pager, " ", 0); + + /* child process */ + close (pipefd[1]); + dup2 (pipefd[0], STDIN_FILENO); + close (pipefd[0]); + + ret = execvp (argv[0], argv); + g_strfreev (argv); + if (ret == -1) { + /* No less? Let's just dump everything to stdout then */ + char buffer[1024]; + + do { + int bytes_written; + + if ((ret = read (STDIN_FILENO, buffer, sizeof (buffer))) == -1) { + if (errno == EINTR || errno == EAGAIN) { + continue; + } + + g_printerr (_("Error reading from console: %s\n"), + g_strerror (errno)); + exit (-1); + } + + do { + bytes_written = write (STDOUT_FILENO, buffer, ret); + } while (bytes_written == -1 && (errno == EINTR || errno == EAGAIN)); + + if (bytes_written < 0) { + g_printerr (_("Error writing to console: %s\n"), g_strerror (errno)); + exit (-1); + } + } while (ret > 0); + + exit (0); + } + } else { + close (pipefd[0]); + dup2 (pipefd[1], STDOUT_FILENO); + if (isatty (STDERR_FILENO)) + dup2 (pipefd[1], STDERR_FILENO); + close (pipefd[1]); + close (STDIN_FILENO); + } +} +#endif + int main (int argc, char *argv[]) { @@ -1513,6 +1954,8 @@ main (int argc, char *argv[]) guint minver_maj = GST_VERSION_MAJOR; guint minver_min = GST_VERSION_MINOR; guint minver_micro = 0; + gchar *types = NULL; + const gchar *colorterm, *no_colors; #ifndef GST_DISABLE_OPTION_PARSING GOptionEntry options[] = { {"print-all", 'a', 0, G_OPTION_ARG_NONE, &print_all, @@ -1526,6 +1969,9 @@ main (int argc, char *argv[]) "installation mechanisms"), NULL}, {"plugin", '\0', 0, G_OPTION_ARG_NONE, &plugin_name, N_("List the plugin contents"), NULL}, + {"types", 't', 0, G_OPTION_ARG_STRING, &types, + N_("A slashes ('/') separated list of types of elements (also known " + "as klass) to list. (unordered)"), NULL}, {"exists", '\0', 0, G_OPTION_ARG_NONE, &check_exists, N_("Check if the specified element or plugin exists"), NULL}, {"atleast-version", '\0', 0, G_OPTION_ARG_STRING, &min_version, @@ -1536,6 +1982,12 @@ main (int argc, char *argv[]) N_ ("Print supported URI schemes, with the elements that implement them"), NULL}, + {"no-colors", '\0', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, + &colored_output, + N_ + ("Disable colors in output. You can also achieve the same by setting" + "'GST_INSPECT_NO_COLORS' environment variable to any value."), + NULL}, GST_TOOLS_GOPTION_VERSION, {NULL} }; @@ -1543,12 +1995,17 @@ main (int argc, char *argv[]) GError *err = NULL; #endif + setlocale (LC_ALL, ""); + #ifdef ENABLE_NLS bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #endif + /* avoid glib warnings when inspecting deprecated properties */ + g_setenv ("G_ENABLE_DIAGNOSTIC", "0", FALSE); + g_set_prgname ("gst-inspect-" GST_API_VERSION); #ifndef GST_DISABLE_OPTION_PARSING @@ -1557,6 +2014,8 @@ main (int argc, char *argv[]) g_option_context_add_group (ctx, gst_init_get_option_group ()); if (!g_option_context_parse (ctx, &argc, &argv, &err)) { g_printerr ("Error initializing: %s\n", err->message); + g_clear_error (&err); + g_option_context_free (ctx); return -1; } g_option_context_free (ctx); @@ -1564,6 +2023,19 @@ main (int argc, char *argv[]) gst_init (&argc, &argv); #endif + no_colors = g_getenv ("GST_INSPECT_NO_COLORS"); + /* We only support truecolor */ + colorterm = g_getenv ("COLORTERM"); + colored_output &= ((no_colors == NULL) && + ((g_strcmp0 (colorterm, "truecolor") == 0) || + (g_strcmp0 (colorterm, "24bit") == 0))); + +#ifdef G_OS_UNIX + if (isatty (STDOUT_FILENO)) { + redirect_stdout (); + } +#endif + gst_tools_print_version (); if (print_all && argc > 1) { @@ -1604,6 +2076,9 @@ main (int argc, char *argv[]) } else { exit_code = 1; } + + if (feature) + gst_object_unref (feature); } else { /* FIXME: support checking for plugins too */ g_printerr ("Checking for plugins is not supported yet\n"); @@ -1623,32 +2098,20 @@ main (int argc, char *argv[]) if (print_aii) print_all_plugin_automatic_install_info (); else - print_element_list (print_all); + print_element_list (print_all, types); } } else { /* else we try to get a factory */ - GstElementFactory *factory; - GstPlugin *plugin; const char *arg = argv[argc - 1]; - int retval; + int retval = -1; if (!plugin_name) { - factory = gst_element_factory_find (arg); - - /* if there's a factory, print out the info */ - if (factory) { - retval = print_element_info (factory, print_all); - gst_object_unref (factory); - } else { - retval = print_element_features (arg); - } - } else { - retval = -1; + retval = print_feature_info (arg, print_all); } /* otherwise check if it's a plugin */ if (retval) { - plugin = gst_registry_find_plugin (gst_registry_get (), arg); + GstPlugin *plugin = gst_registry_find_plugin (gst_registry_get (), arg); /* if there is such a plugin, print out info */ if (plugin) { @@ -1673,7 +2136,7 @@ main (int argc, char *argv[]) } } else { g_printerr (_("Could not load plugin file: %s\n"), error->message); - g_error_free (error); + g_clear_error (&error); return -1; } } else { @@ -1684,5 +2147,14 @@ main (int argc, char *argv[]) } } +#ifdef G_OS_UNIX + fflush (stdout); + fflush (stderr); + /* So that the pipe we create in redirect_stdout() is closed */ + close (STDOUT_FILENO); + close (STDERR_FILENO); + wait (NULL); +#endif + return 0; }