2 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3 * 2000 Wim Taymans <wtay@chello.be>
4 * 2004 Thomas Vander Stichele <thomas@apestaart.org>
6 * gst-inspect.c: tool to inspect the GStreamer registry
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the
20 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 * Boston, MA 02111-1307, USA.
28 #include <gst/controller/gstcontroller.h>
34 #include <glib/gprintf.h>
38 static int print_element_info (GstElementFactory * factory,
39 gboolean print_names);
42 n_print (const char *format, ...)
50 va_start (args, format);
51 retval = g_vprintf (format, args);
56 print_field (GQuark field, const GValue * value, gpointer pfx)
58 gchar *str = gst_value_serialize (value);
60 n_print ("%s %15s: %s\n", (gchar *) pfx, g_quark_to_string (field), str);
66 print_caps (const GstCaps * caps, const gchar * pfx)
70 g_return_if_fail (caps != NULL);
72 if (gst_caps_is_any (caps)) {
73 n_print ("%sANY\n", pfx);
76 if (gst_caps_is_empty (caps)) {
77 n_print ("%sEMPTY\n", pfx);
81 for (i = 0; i < gst_caps_get_size (caps); i++) {
82 GstStructure *structure = gst_caps_get_structure (caps, i);
84 n_print ("%s%s\n", pfx, gst_structure_get_name (structure));
85 gst_structure_foreach (structure, print_field, (gpointer) pfx);
91 print_formats (const GstFormat * formats)
93 while (formats && *formats) {
94 const GstFormatDefinition *definition;
96 definition = gst_format_get_details (*formats);
98 n_print ("\t\t(%d):\t%s (%s)\n", *formats,
99 definition->nick, definition->description);
101 n_print ("\t\t(%d):\tUnknown format\n", *formats);
109 print_query_types (const GstQueryType * types)
111 while (types && *types) {
112 const GstQueryTypeDefinition *definition;
114 definition = gst_query_type_get_details (*types);
116 n_print ("\t\t(%d):\t%s (%s)\n", *types,
117 definition->nick, definition->description);
119 n_print ("\t\t(%d):\tUnknown query format\n", *types);
125 #ifndef GST_DISABLE_ENUMTYPES
128 print_event_masks (const GstEventMask * masks)
133 GFlagsClass *flags_class = NULL;
135 event_type = gst_event_type_get_type ();
136 klass = (GEnumClass *) g_type_class_ref (event_type);
138 while (masks && masks->type) {
140 gint flags = 0, index = 0;
142 switch (masks->type) {
144 flags = masks->flags;
145 event_flags = gst_seek_type_get_type ();
146 flags_class = (GFlagsClass *) g_type_class_ref (event_flags);
152 value = g_enum_get_value (klass, masks->type);
153 g_print ("\t\t%s ", value->value_nick);
159 value = g_flags_get_first_value (flags_class, 1 << index);
162 g_print ("| %s ", value->value_nick);
177 print_event_masks (const GstEventMask * masks)
183 get_rank_name (gint rank)
188 case GST_RANK_MARGINAL:
190 case GST_RANK_SECONDARY:
192 case GST_RANK_PRIMARY:
200 print_factory_details_info (GstElementFactory * factory)
202 n_print ("Factory Details:\n");
203 n_print (" Long name:\t%s\n", factory->details.longname);
204 n_print (" Class:\t%s\n", factory->details.klass);
205 n_print (" Description:\t%s\n", factory->details.description);
206 n_print (" Author(s):\t%s\n", factory->details.author);
207 n_print (" Rank:\t\t%s (%d)\n",
208 get_rank_name (GST_PLUGIN_FEATURE (factory)->rank),
209 GST_PLUGIN_FEATURE (factory)->rank);
214 print_hierarchy (GType type, gint level, gint * maxlevel)
219 parent = g_type_parent (type);
221 *maxlevel = *maxlevel + 1;
225 print_hierarchy (parent, level, maxlevel);
230 for (i = 1; i < *maxlevel - level; i++)
232 if (*maxlevel - level)
235 g_print ("%s\n", g_type_name (type));
242 print_interfaces (GType type)
245 GType *iface, *ifaces = g_type_interfaces (type, &n_ifaces);
249 g_print ("%s", _name);
250 g_print (_("Implemented Interfaces:\n"));
253 g_print ("%s %s\n", _name, g_type_name (*iface));
256 g_print ("%s\n", _name);
263 print_element_properties_info (GstElement * element)
265 GParamSpec **property_specs;
266 guint num_properties, i;
270 property_specs = g_object_class_list_properties
271 (G_OBJECT_GET_CLASS (element), &num_properties);
273 n_print ("Element Properties:\n");
275 for (i = 0; i < num_properties; i++) {
276 GValue value = { 0, };
277 GParamSpec *param = property_specs[i];
281 g_value_init (&value, param->value_type);
283 n_print (" %-20s: %s\n", g_param_spec_get_name (param),
284 g_param_spec_get_blurb (param));
287 n_print ("%-23.23s flags: ", "");
288 if (param->flags & G_PARAM_READABLE) {
289 g_object_get_property (G_OBJECT (element), param->name, &value);
291 g_print ((first_flag ? "" : ", "));
292 g_print (_("readable"));
295 if (param->flags & G_PARAM_WRITABLE) {
296 g_print ((first_flag ? "" : ", "));
297 g_print (_("writable"));
300 if (param->flags & GST_PARAM_CONTROLLABLE) {
301 g_print ((first_flag ? "" : ", "));
302 g_print (_("controllable"));
307 switch (G_VALUE_TYPE (&value)) {
310 GParamSpecString *pstring = G_PARAM_SPEC_STRING (param);
312 n_print ("%-23.23s String. ", "");
314 if (pstring->default_value == NULL)
315 g_print ("Default: null ");
317 g_print ("Default: \"%s\" ", pstring->default_value);
320 const char *string_val = g_value_get_string (&value);
322 if (string_val == NULL)
323 g_print ("Current: null");
325 g_print ("Current: \"%s\"", string_val);
331 GParamSpecBoolean *pboolean = G_PARAM_SPEC_BOOLEAN (param);
333 n_print ("%-23.23s Boolean. ", "");
334 g_print ("Default: %s ", (pboolean->default_value ? "true" : "false"));
336 g_print ("Current: %s",
337 (g_value_get_boolean (&value) ? "true" : "false"));
342 GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
344 n_print ("%-23.23s Unsigned Long. ", "");
345 g_print ("Range: %lu - %lu Default: %lu ",
346 pulong->minimum, pulong->maximum, pulong->default_value);
348 g_print ("Current: %lu", g_value_get_ulong (&value));
353 GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
355 n_print ("%-23.23s Long. ", "");
356 g_print ("Range: %ld - %ld Default: %ld ",
357 plong->minimum, plong->maximum, plong->default_value);
359 g_print ("Current: %ld", g_value_get_long (&value));
364 GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
366 n_print ("%-23.23s Unsigned Integer. ", "");
367 g_print ("Range: %u - %u Default: %u ",
368 puint->minimum, puint->maximum, puint->default_value);
370 g_print ("Current: %u", g_value_get_uint (&value));
375 GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
377 n_print ("%-23.23s Integer. ", "");
378 g_print ("Range: %d - %d Default: %d ",
379 pint->minimum, pint->maximum, pint->default_value);
381 g_print ("Current: %d", g_value_get_int (&value));
386 GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
388 n_print ("%-23.23s Unsigned Integer64. ", "");
389 g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT
390 " Default: %" G_GUINT64_FORMAT " ",
391 puint64->minimum, puint64->maximum, puint64->default_value);
393 g_print ("Current: %" G_GUINT64_FORMAT, g_value_get_uint64 (&value));
398 GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
400 n_print ("%-23.23s Integer64. ", "");
401 g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT
402 " Default: %" G_GINT64_FORMAT " ",
403 pint64->minimum, pint64->maximum, pint64->default_value);
405 g_print ("Current: %" G_GINT64_FORMAT, g_value_get_int64 (&value));
410 GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
412 n_print ("%-23.23s Float. ", "");
413 g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
414 pfloat->minimum, pfloat->maximum, pfloat->default_value);
416 g_print ("Current: %15.7g", g_value_get_float (&value));
421 GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
423 n_print ("%-23.23s Double. ", "");
424 g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
425 pdouble->minimum, pdouble->maximum, pdouble->default_value);
427 g_print ("Current: %15.7g", g_value_get_double (&value));
431 if (param->value_type == GST_TYPE_CAPS) {
432 const GstCaps *caps = gst_value_get_caps (&value);
435 n_print ("%-23.23s Caps (NULL)", "");
437 print_caps (caps, " ");
439 } else if (G_IS_PARAM_SPEC_ENUM (param)) {
444 values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
445 enum_value = g_value_get_enum (&value);
447 while (values[j].value_name) {
448 if (values[j].value == enum_value)
453 n_print ("%-23.23s Enum \"%s\" Current: %d, \"%s\"", "",
454 g_type_name (G_VALUE_TYPE (&value)),
455 enum_value, values[j].value_nick);
458 while (values[j].value_name) {
459 g_print ("\n%s%-23.23s (%d): %-16s - %s", "",
460 _name, values[j].value, values[j].value_nick,
461 values[j].value_name);
464 /* g_type_class_unref (ec); */
465 } else if (G_IS_PARAM_SPEC_FLAGS (param)) {
469 GString *flags = NULL;
471 values = G_FLAGS_CLASS (g_type_class_ref (param->value_type))->values;
472 flags_value = g_value_get_flags (&value);
474 while (values[j].value_name) {
475 if (values[j].value & flags_value) {
477 g_string_append_printf (flags, " | %s", values[j].value_nick);
479 flags = g_string_new (values[j].value_nick);
485 n_print ("%-23.23s Flags \"%s\" Current: %d, \"%s\"", "",
486 g_type_name (G_VALUE_TYPE (&value)),
487 flags_value, (flags ? flags->str : "(none)"));
490 while (values[j].value_name) {
491 g_print ("\n%s%-23.23s (0x%08x): %-16s - %s", "",
492 _name, values[j].value, values[j].value_nick,
493 values[j].value_name);
498 g_string_free (flags, TRUE);
499 } else if (G_IS_PARAM_SPEC_OBJECT (param)) {
500 n_print ("%-23.23s Object of type \"%s\"", "",
501 g_type_name (param->value_type));
502 } else if (G_IS_PARAM_SPEC_BOXED (param)) {
503 n_print ("%-23.23s Boxed pointer of type \"%s\"", "",
504 g_type_name (param->value_type));
505 } else if (G_IS_PARAM_SPEC_POINTER (param)) {
506 if (param->value_type != G_TYPE_POINTER) {
507 n_print ("%-23.23s Pointer of type \"%s\".", "",
508 g_type_name (param->value_type));
510 n_print ("%-23.23s Pointer.", "");
512 } else if (param->value_type == G_TYPE_VALUE_ARRAY) {
513 n_print ("%-23.23s Array of GValues", "");
515 n_print ("%-23.23s Unknown type %ld \"%s\"", "", param->value_type,
516 g_type_name (param->value_type));
521 g_print (" Write only\n");
525 if (num_properties == 0)
528 g_free (property_specs);
532 print_pad_templates_info (GstElement * element, GstElementFactory * factory)
534 GstElementClass *gstelement_class;
536 GstStaticPadTemplate *padtemplate;
538 n_print ("Pad Templates:\n");
539 if (!factory->numpadtemplates) {
544 gstelement_class = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element));
546 pads = factory->staticpadtemplates;
548 padtemplate = (GstStaticPadTemplate *) (pads->data);
549 pads = g_list_next (pads);
551 if (padtemplate->direction == GST_PAD_SRC)
552 n_print (" SRC template: '%s'\n", padtemplate->name_template);
553 else if (padtemplate->direction == GST_PAD_SINK)
554 n_print (" SINK template: '%s'\n", padtemplate->name_template);
556 n_print (" UNKNOWN!!! template: '%s'\n", padtemplate->name_template);
558 if (padtemplate->presence == GST_PAD_ALWAYS)
559 n_print (" Availability: Always\n");
560 else if (padtemplate->presence == GST_PAD_SOMETIMES)
561 n_print (" Availability: Sometimes\n");
562 else if (padtemplate->presence == GST_PAD_REQUEST) {
563 n_print (" Availability: On request\n");
564 n_print (" Has request_new_pad() function: %s\n",
565 GST_DEBUG_FUNCPTR_NAME (gstelement_class->request_new_pad));
567 n_print (" Availability: UNKNOWN!!!\n");
569 if (padtemplate->static_caps.string) {
570 n_print (" Capabilities:\n");
571 print_caps (gst_static_caps_get (&padtemplate->static_caps), " ");
579 print_element_flag_info (GstElement * element)
581 gboolean have_flags = FALSE;
584 n_print ("Element Flags:\n");
587 n_print (" no flags set\n");
589 if (GST_IS_BIN (element)) {
591 n_print ("Bin Flags:\n");
593 n_print (" no flags set\n");
598 print_implementation_info (GstElement * element)
600 GstObjectClass *gstobject_class;
601 GstElementClass *gstelement_class;
603 gstobject_class = GST_OBJECT_CLASS (G_OBJECT_GET_CLASS (element));
604 gstelement_class = GST_ELEMENT_CLASS (G_OBJECT_GET_CLASS (element));
607 n_print ("Element Implementation:\n");
609 n_print (" No loopfunc(), must be chain-based or not configured yet\n");
611 n_print (" Has change_state() function: %s\n",
612 GST_DEBUG_FUNCPTR_NAME (gstelement_class->change_state));
613 #ifndef GST_DISABLE_LOADSAVE
614 n_print (" Has custom save_thyself() function: %s\n",
615 GST_DEBUG_FUNCPTR_NAME (gstobject_class->save_thyself));
616 n_print (" Has custom restore_thyself() function: %s\n",
617 GST_DEBUG_FUNCPTR_NAME (gstobject_class->restore_thyself));
622 print_clocking_info (GstElement * element)
624 if (!gst_element_requires_clock (element) &&
625 !(gst_element_provides_clock (element) &&
626 gst_element_get_clock (element))) {
628 n_print ("Element has no clocking capabilities.");
633 n_print ("Clocking Interaction:\n");
634 if (gst_element_requires_clock (element)) {
635 n_print (" element requires a clock\n");
638 if (gst_element_provides_clock (element)) {
641 clock = gst_element_get_clock (element);
643 n_print (" element provides a clock: %s\n", GST_OBJECT_NAME (clock));
645 n_print (" element is supposed to provide a clock but returned NULL\n");
649 #ifndef GST_DISABLE_INDEX
651 print_index_info (GstElement * element)
653 if (gst_element_is_indexable (element)) {
655 n_print ("Indexing capabilities:\n");
656 n_print (" element can do indexing\n");
659 n_print ("Element has no indexing capabilities.\n");
664 print_index_info (GstElement * element)
670 print_pad_info (GstElement * element)
678 if (!element->numpads) {
683 pads = element->pads;
685 pad = GST_PAD (pads->data);
686 pads = g_list_next (pads);
690 if (gst_pad_get_direction (pad) == GST_PAD_SRC)
691 g_print (" SRC: '%s'", gst_pad_get_name (pad));
692 else if (gst_pad_get_direction (pad) == GST_PAD_SINK)
693 g_print (" SINK: '%s'", gst_pad_get_name (pad));
695 g_print (" UNKNOWN!!!: '%s'", gst_pad_get_name (pad));
699 n_print (" Implementation:\n");
701 n_print (" Has chainfunc(): %s\n",
702 GST_DEBUG_FUNCPTR_NAME (pad->chainfunc));
703 if (pad->getrangefunc)
704 n_print (" Has getrangefunc(): %s\n",
705 GST_DEBUG_FUNCPTR_NAME (pad->getrangefunc));
706 if (pad->eventfunc != gst_pad_event_default)
707 n_print (" Has custom eventfunc(): %s\n",
708 GST_DEBUG_FUNCPTR_NAME (pad->eventfunc));
709 if (pad->queryfunc != gst_pad_query_default)
710 n_print (" Has custom queryfunc(): %s\n",
711 GST_DEBUG_FUNCPTR_NAME (pad->queryfunc));
712 if (pad->querytypefunc != gst_pad_get_query_types_default) {
713 n_print (" Provides query types:\n");
714 print_query_types (gst_pad_get_query_types (pad));
717 if (pad->intlinkfunc != gst_pad_get_internal_links_default)
718 n_print (" Has custom intconnfunc(): %s\n",
719 GST_DEBUG_FUNCPTR_NAME (pad->intlinkfunc));
721 if (pad->bufferallocfunc)
722 n_print (" Has bufferallocfunc(): %s\n",
723 GST_DEBUG_FUNCPTR_NAME (pad->bufferallocfunc));
725 if (pad->padtemplate)
726 n_print (" Pad Template: '%s'\n", pad->padtemplate->name_template);
729 n_print (" Capabilities:\n");
730 print_caps (pad->caps, " ");
737 compare_signal_names (GSignalQuery * a, GSignalQuery * b)
739 return strcmp (a->signal_name, b->signal_name);
744 print_signal_info (GstElement * element)
746 /* Signals/Actions Block */
750 GSignalQuery *query = NULL;
752 GSList *found_signals, *l;
754 for (k = 0; k < 2; k++) {
755 found_signals = NULL;
756 for (type = G_OBJECT_TYPE (element); type; type = g_type_parent (type)) {
757 if (type == GST_TYPE_ELEMENT || type == GST_TYPE_OBJECT)
760 if (type == GST_TYPE_BIN && G_OBJECT_TYPE (element) != GST_TYPE_BIN)
763 signals = g_signal_list_ids (type, &nsignals);
764 for (i = 0; i < nsignals; i++) {
765 query = g_new0 (GSignalQuery, 1);
766 g_signal_query (signals[i], query);
768 if ((k == 0 && !(query->signal_flags & G_SIGNAL_ACTION)) ||
769 (k == 1 && (query->signal_flags & G_SIGNAL_ACTION)))
770 found_signals = g_slist_append (found_signals, query);
777 n_print ("Element Signals:\n");
779 n_print ("Element Actions:\n");
784 for (l = found_signals; l; l = l->next) {
788 query = (GSignalQuery *) l->data;
789 indent_len = strlen (query->signal_name) +
790 strlen (g_type_name (query->return_type)) + 24;
792 indent = g_new0 (gchar, indent_len + 1);
793 memset (indent, ' ', indent_len);
795 n_print (" \"%s\" : %s user_function (%s* object",
797 g_type_name (query->return_type), g_type_name (type));
799 for (j = 0; j < query->n_params; j++) {
800 if (G_TYPE_IS_FUNDAMENTAL (query->param_types[j])) {
801 g_print (",\n%s%s%s arg%d", _name, indent,
802 g_type_name (query->param_types[j]), j);
803 } else if (G_TYPE_IS_ENUM (query->param_types[j])) {
804 g_print (",\n%s%s%s arg%d", _name, indent,
805 g_type_name (query->param_types[j]), j);
807 g_print (",\n%s%s%s* arg%d", _name, indent,
808 g_type_name (query->param_types[j]), j);
813 g_print (",\n%s%sgpointer user_data);\n", _name, indent);
821 g_slist_foreach (found_signals, (GFunc) g_free, NULL);
822 g_slist_free (found_signals);
828 print_children_info (GstElement * element)
832 if (!GST_IS_BIN (element))
835 children = (GList *) GST_BIN (element)->children;
838 g_print ("Children:\n");
842 n_print (" %s\n", GST_ELEMENT_NAME (GST_ELEMENT (children->data)));
843 children = g_list_next (children);
848 print_element_list (gboolean print_all)
850 int plugincount = 0, featurecount = 0;
851 GList *plugins, *orig_plugins;
853 orig_plugins = plugins = gst_default_registry_get_plugin_list ();
855 GList *features, *orig_features;
858 plugin = (GstPlugin *) (plugins->data);
859 plugins = g_list_next (plugins);
862 orig_features = features =
863 gst_registry_get_feature_list_by_plugin (gst_registry_get_default (),
866 GstPluginFeature *feature;
868 feature = GST_PLUGIN_FEATURE (features->data);
871 if (GST_IS_ELEMENT_FACTORY (feature)) {
872 GstElementFactory *factory;
874 factory = GST_ELEMENT_FACTORY (feature);
876 print_element_info (factory, TRUE);
878 g_print ("%s: %s: %s\n", plugin->desc.name,
879 GST_PLUGIN_FEATURE_NAME (factory), factory->details.longname);
881 #ifndef GST_DISABLE_INDEX
882 else if (GST_IS_INDEX_FACTORY (feature)) {
883 GstIndexFactory *factory;
885 factory = GST_INDEX_FACTORY (feature);
887 g_print ("%s: %s: %s\n", plugin->desc.name,
888 GST_PLUGIN_FEATURE_NAME (factory), factory->longdesc);
891 else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
892 GstTypeFindFactory *factory;
894 factory = GST_TYPE_FIND_FACTORY (feature);
896 g_print ("%s: %s: ", plugin->desc.name,
897 gst_plugin_feature_get_name (feature));
898 if (factory->extensions) {
901 while (factory->extensions[i]) {
903 g_print ("%s%s", i > 0 ? ", " : "", factory->extensions[i]);
910 g_print ("no extensions\n");
914 n_print ("%s: %s (%s)\n", plugin->desc.name,
915 GST_PLUGIN_FEATURE_NAME (feature),
916 g_type_name (G_OBJECT_TYPE (feature)));
919 features = g_list_next (features);
922 gst_plugin_feature_list_free (orig_features);
925 gst_plugin_list_free (orig_plugins);
928 g_print (_("Total count: "));
929 g_print (ngettext ("%d plugin", "%d plugins", plugincount), plugincount);
931 g_print (ngettext ("%d feature", "%d features", featurecount), featurecount);
936 print_plugin_info (GstPlugin * plugin)
938 n_print ("Plugin Details:\n");
939 n_print (" Name:\t\t\t%s\n", plugin->desc.name);
940 n_print (" Description:\t\t%s\n", plugin->desc.description);
941 n_print (" Filename:\t\t%s\n",
942 plugin->filename ? plugin->filename : "(null)");
943 n_print (" Version:\t\t%s\n", plugin->desc.version);
944 n_print (" License:\t\t%s\n", plugin->desc.license);
945 n_print (" Source module:\t%s\n", plugin->desc.source);
946 n_print (" Binary package:\t%s\n", plugin->desc.package);
947 n_print (" Origin URL:\t\t%s\n", plugin->desc.origin);
952 print_plugin_features (GstPlugin * plugin)
955 gint num_features = 0;
956 gint num_elements = 0;
958 gint num_indexes = 0;
962 gst_registry_get_feature_list_by_plugin (gst_registry_get_default (),
966 GstPluginFeature *feature;
968 feature = GST_PLUGIN_FEATURE (features->data);
970 if (GST_IS_ELEMENT_FACTORY (feature)) {
971 GstElementFactory *factory;
973 factory = GST_ELEMENT_FACTORY (feature);
974 n_print (" %s: %s\n", GST_PLUGIN_FEATURE_NAME (factory),
975 factory->details.longname);
978 #ifndef GST_DISABLE_INDEX
979 else if (GST_IS_INDEX_FACTORY (feature)) {
980 GstIndexFactory *factory;
982 factory = GST_INDEX_FACTORY (feature);
983 n_print (" %s: %s\n", GST_OBJECT_NAME (factory), factory->longdesc);
987 else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
988 GstTypeFindFactory *factory;
990 factory = GST_TYPE_FIND_FACTORY (feature);
991 if (factory->extensions) {
994 g_print ("%s type: ", plugin->desc.name);
995 while (factory->extensions[i]) {
996 g_print ("%s%s", i > 0 ? ", " : "", factory->extensions[i]);
1001 g_print ("%s type: N/A\n", plugin->desc.name);
1005 n_print (" %s (%s)\n", gst_object_get_name (GST_OBJECT (feature)),
1006 g_type_name (G_OBJECT_TYPE (feature)));
1010 features = g_list_next (features);
1013 n_print (" %d features:\n", num_features);
1014 if (num_elements > 0)
1015 n_print (" +-- %d elements\n", num_elements);
1017 n_print (" +-- %d types\n", num_types);
1018 if (num_indexes > 0)
1019 n_print (" +-- %d indexes\n", num_indexes);
1021 n_print (" +-- %d other objects\n", num_other);
1027 print_element_features (const gchar * element_name)
1029 GstPluginFeature *feature;
1031 /* FIXME implement other pretty print function for these */
1032 #ifndef GST_DISABLE_INDEX
1033 feature = gst_default_registry_find_feature (element_name,
1034 GST_TYPE_INDEX_FACTORY);
1036 n_print ("%s: an index\n", element_name);
1040 feature = gst_default_registry_find_feature (element_name,
1041 GST_TYPE_TYPE_FIND_FACTORY);
1043 n_print ("%s: a typefind function\n", element_name);
1051 print_element_info (GstElementFactory * factory, gboolean print_names)
1053 GstElement *element;
1057 GST_ELEMENT_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE
1061 g_print ("element plugin couldn't be loaded\n");
1065 element = gst_element_factory_create (factory, NULL);
1067 g_print ("couldn't construct element for some reason\n");
1072 _name = g_strdup_printf ("%s: ", GST_PLUGIN_FEATURE (factory)->name);
1076 print_factory_details_info (factory);
1077 if (GST_PLUGIN_FEATURE (factory)->plugin_name) {
1080 plugin = gst_registry_find_plugin (gst_registry_get_default (),
1081 GST_PLUGIN_FEATURE (factory)->plugin_name);
1083 print_plugin_info (plugin);
1087 print_hierarchy (G_OBJECT_TYPE (element), 0, &maxlevel);
1088 print_interfaces (G_OBJECT_TYPE (element));
1090 print_pad_templates_info (element, factory);
1091 print_element_flag_info (element);
1092 print_implementation_info (element);
1093 print_clocking_info (element);
1094 print_index_info (element);
1095 print_pad_info (element);
1096 print_element_properties_info (element);
1097 print_signal_info (element);
1098 print_children_info (element);
1100 gst_object_unref (factory);
1101 if (_name[0] != '\0')
1109 print_plugin_automatic_install_info_codecs (GstElementFactory * factory)
1111 GstPadDirection direction;
1112 const gchar *type_name;
1114 const GList *static_templates, *l;
1115 GstCaps *caps = NULL;
1118 klass = gst_element_factory_get_klass (factory);
1119 g_return_if_fail (klass != NULL);
1121 if (strstr (klass, "Codec/") == NULL)
1124 if (strstr (klass, "Demuxer") ||
1125 strstr (klass, "Decoder") ||
1126 strstr (klass, "Depay") || strstr (klass, "Parser")) {
1127 type_name = "decoder";
1128 direction = GST_PAD_SINK;
1129 } else if (strstr (klass, "Muxer") ||
1130 strstr (klass, "Encoder") || strstr (klass, "Pay")) {
1131 type_name = "encoder";
1132 direction = GST_PAD_SRC;
1134 g_printerr ("Unhandled Codec klass: %s\n", klass);
1138 /* decoder/demuxer sink pads should always be static and there should only
1139 * be one, the same applies to encoders/muxers and source pads */
1140 static_templates = gst_element_factory_get_static_pad_templates (factory);
1141 for (l = static_templates; l != NULL; l = l->next) {
1142 GstStaticPadTemplate *tmpl = NULL;
1144 tmpl = (GstStaticPadTemplate *) l->data;
1145 if (tmpl->direction == direction) {
1146 caps = gst_static_pad_template_get_caps (tmpl);
1152 g_printerr ("Couldn't find static pad template for %s '%s'\n",
1153 type_name, GST_PLUGIN_FEATURE_NAME (factory));
1157 caps = gst_caps_make_writable (caps);
1158 num = gst_caps_get_size (caps);
1159 for (i = 0; i < num; ++i) {
1163 s = gst_caps_get_structure (caps, i);
1164 /* remove fields that are almost always just MIN-MAX of some sort
1165 * in order to make the caps look less messy */
1166 gst_structure_remove_field (s, "pixel-aspect-ratio");
1167 gst_structure_remove_field (s, "framerate");
1168 gst_structure_remove_field (s, "channels");
1169 gst_structure_remove_field (s, "width");
1170 gst_structure_remove_field (s, "height");
1171 gst_structure_remove_field (s, "rate");
1172 gst_structure_remove_field (s, "depth");
1173 gst_structure_remove_field (s, "clock-rate");
1174 s_str = gst_structure_to_string (s);
1175 g_print ("%s-%s\n", type_name, s_str);
1178 gst_caps_unref (caps);
1182 print_plugin_automatic_install_info_protocols (GstElementFactory * factory)
1184 gchar **protocols, **p;
1186 protocols = gst_element_factory_get_uri_protocols (factory);
1187 if (protocols != NULL && *protocols != NULL) {
1188 switch (gst_element_factory_get_uri_type (factory)) {
1190 for (p = protocols; *p != NULL; ++p)
1191 g_print ("urisink-%s\n", *p);
1194 for (p = protocols; *p != NULL; ++p)
1195 g_print ("urisource-%s\n", *p);
1200 g_strfreev (protocols);
1205 print_plugin_automatic_install_info (GstPlugin * plugin)
1207 const gchar *plugin_name;
1208 GList *features, *l;
1210 plugin_name = gst_plugin_get_name (plugin);
1212 /* not interested in typefind factories, only element factories */
1213 features = gst_registry_get_feature_list (gst_registry_get_default (),
1214 GST_TYPE_ELEMENT_FACTORY);
1216 for (l = features; l != NULL; l = l->next) {
1217 GstPluginFeature *feature;
1219 feature = GST_PLUGIN_FEATURE (l->data);
1221 /* only interested in the ones that are in the plugin we just loaded */
1222 if (g_str_equal (plugin_name, feature->plugin_name)) {
1223 GstElementFactory *factory;
1225 g_print ("element-%s\n", gst_plugin_feature_get_name (feature));
1227 factory = GST_ELEMENT_FACTORY (feature);
1228 print_plugin_automatic_install_info_protocols (factory);
1229 print_plugin_automatic_install_info_codecs (factory);
1233 g_list_foreach (features, (GFunc) gst_object_unref, NULL);
1234 g_list_free (features);
1238 main (int argc, char *argv[])
1240 gboolean print_all = FALSE;
1241 gboolean print_aii = FALSE;
1242 GOptionEntry options[] = {
1243 {"print-all", 'a', 0, G_OPTION_ARG_NONE, &print_all,
1244 N_("Print all elements"), NULL},
1245 {"print-plugin-auto-install-info", '\0', 0, G_OPTION_ARG_NONE, &print_aii,
1246 N_("Print a machine-parsable list of features the specified plugin "
1248 "Useful in connection with external automatic plugin "
1249 "installation mechanisms"), NULL},
1250 GST_TOOLS_GOPTION_VERSION,
1253 GOptionContext *ctx;
1257 bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
1258 bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
1259 textdomain (GETTEXT_PACKAGE);
1262 if (!g_thread_supported ())
1263 g_thread_init (NULL);
1265 ctx = g_option_context_new ("[ELEMENT-NAME | PLUGIN-NAME]");
1266 g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
1267 g_option_context_add_group (ctx, gst_init_get_option_group ());
1268 if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
1269 g_print ("Error initializing: %s\n", err->message);
1272 g_option_context_free (ctx);
1274 gst_tools_print_version ("gst-inspect");
1276 if (print_all && argc > 2) {
1277 g_print ("-a requires no extra arguments\n");
1281 /* if no arguments, print out list of elements */
1282 if (argc == 1 || print_all) {
1283 print_element_list (print_all);
1284 /* else we try to get a factory */
1286 GstElementFactory *factory;
1288 const char *arg = argv[argc - 1];
1291 factory = gst_element_factory_find (arg);
1292 /* if there's a factory, print out the info */
1294 retval = print_element_info (factory, print_all);
1295 gst_object_unref (factory);
1297 retval = print_element_features (arg);
1300 /* otherwise check if it's a plugin */
1302 plugin = gst_default_registry_find_plugin (arg);
1304 /* if there is such a plugin, print out info */
1307 print_plugin_automatic_install_info (plugin);
1309 print_plugin_info (plugin);
1310 print_plugin_features (plugin);
1313 GError *error = NULL;
1315 if (g_file_test (arg, G_FILE_TEST_EXISTS)) {
1316 plugin = gst_plugin_load_file (arg, &error);
1320 print_plugin_automatic_install_info (plugin);
1322 print_plugin_info (plugin);
1323 print_plugin_features (plugin);
1326 g_print (_("Could not load plugin file: %s\n"), error->message);
1327 g_error_free (error);
1331 g_print (_("No such element or plugin '%s'\n"), arg);