Debian Codegraph @

libs/gst/helpers/gst-completion-helper.c

raw
1 /* GStreamer
2 * Copyright (C) 2015 Mathieu Duponchelle <[email protected]>
3 *
4 * gst-completion-helper.c: tool to let other tools enjoy fast and powerful
5 * gstreamer-aware completion
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
16 *
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
20 * Boston, MA 02110-1301, USA.
21 */
22
23 #ifdef HAVE_CONFIG_H
24 # include "config.h"
25 #endif
26
27 #include <gst/gst.h>
28 #include <glib.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 static GList *
33 get_pad_templates_info (GstElement * element, GstElementFactory * factory,
34 GstPadDirection direction)
35 {
36 const GList *pads;
37 GstStaticPadTemplate *padtemplate;
38 GList *caps_list = NULL;
39
40 if (gst_element_factory_get_num_pad_templates (factory) == 0) {
41 g_print (" none\n");
42 return NULL;
43 }
44
45 pads = gst_element_factory_get_static_pad_templates (factory);
46 while (pads) {
47 padtemplate = (GstStaticPadTemplate *) (pads->data);
48 pads = g_list_next (pads);
49
50 if (padtemplate->direction != direction)
51 continue;
52
53 if (padtemplate->static_caps.string) {
54 caps_list =
55 g_list_append (caps_list,
56 gst_static_caps_get (&padtemplate->static_caps));
57 }
58
59 }
60
61 return caps_list;
62 }
63
64 static GList *
65 _get_pad_caps (const gchar * factory_name, GstPadDirection direction)
66 {
67 GstElementFactory *factory = gst_element_factory_find (factory_name);
68 GstElement *element = gst_element_factory_make (factory_name, NULL);
69
70 if (!element)
71 return NULL;
72 if (!factory)
73 return NULL;
74 factory =
75 GST_ELEMENT_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE
76 (factory)));
77 if (!factory)
78 return NULL;
79 return get_pad_templates_info (element, factory, direction);
80 }
81
82 static gboolean
83 _are_linkable (GstPluginFeature * feature, GList * caps_list)
84 {
85 gboolean print = FALSE;
86 GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
87
88 GList *tmp;
89 print = FALSE;
90 for (tmp = caps_list; tmp; tmp = tmp->next) {
91 if (gst_element_factory_can_sink_any_caps (factory, tmp->data)) {
92 print = TRUE;
93 break;
94 }
95 }
96
97 return print;
98 }
99
100 static gboolean
101 _belongs_to_klass (GstElementFactory * factory, const gchar * klass)
102 {
103 const gchar *factory_klass;
104
105
106 factory_klass =
107 gst_element_factory_get_metadata (factory, GST_ELEMENT_METADATA_KLASS);
108 if (strstr (factory_klass, klass))
109 return TRUE;
110 return FALSE;
111 }
112
113 static void
114 _list_features (const gchar * compatible_with, const gchar * klass,
115 GstCaps * sinkcaps)
116 {
117 GList *plugins, *orig_plugins;
118 GList *caps_list = NULL;
119
120 if (compatible_with) {
121 caps_list = _get_pad_caps (compatible_with, GST_PAD_SRC);
122 }
123
124 orig_plugins = plugins = gst_registry_get_plugin_list (gst_registry_get ());
125 while (plugins) {
126 GList *features, *orig_features;
127 GstPlugin *plugin;
128
129 plugin = (GstPlugin *) (plugins->data);
130 plugins = g_list_next (plugins);
131
132 if (GST_OBJECT_FLAG_IS_SET (plugin, GST_PLUGIN_FLAG_BLACKLISTED)) {
133 continue;
134 }
135
136 orig_features = features =
137 gst_registry_get_feature_list_by_plugin (gst_registry_get (),
138 gst_plugin_get_name (plugin));
139 while (features) {
140 GstPluginFeature *feature;
141
142 if (G_UNLIKELY (features->data == NULL))
143 goto next;
144 feature = GST_PLUGIN_FEATURE (features->data);
145
146 if (GST_IS_ELEMENT_FACTORY (feature)) {
147 gboolean print = TRUE;
148 if (caps_list)
149 print = _are_linkable (feature, caps_list);
150 if (print && klass)
151 print = _belongs_to_klass (GST_ELEMENT_FACTORY (feature), klass);
152 if (print && sinkcaps)
153 print =
154 gst_element_factory_can_sink_any_caps (GST_ELEMENT_FACTORY
155 (feature), sinkcaps);
156
157 if (print)
158 g_print ("%s ", gst_plugin_feature_get_name (feature));
159 }
160
161 next:
162 features = g_list_next (features);
163 }
164
165 gst_plugin_feature_list_free (orig_features);
166 }
167
168 g_list_free (caps_list);
169 g_print ("\n");
170 gst_plugin_list_free (orig_plugins);
171 }
172
173 static void
174 _print_element_properties_info (GstElement * element)
175 {
176 GParamSpec **property_specs;
177 guint num_properties, i;
178
179 property_specs = g_object_class_list_properties
180 (G_OBJECT_GET_CLASS (element), &num_properties);
181
182 for (i = 0; i < num_properties; i++) {
183 GParamSpec *param = property_specs[i];
184
185 if (param->flags & G_PARAM_WRITABLE) {
186 g_print ("%s= ", g_param_spec_get_name (param));
187 }
188 }
189
190 g_free (property_specs);
191 }
192
193 static void
194 _list_element_properties (const gchar * factory_name)
195 {
196 GstElement *element = gst_element_factory_make (factory_name, NULL);
197
198 _print_element_properties_info (element);
199 }
200
201 int
202 main (int argc, char *argv[])
203 {
204 gboolean list_features = FALSE;
205 gchar *compatible_with = NULL;
206 gchar *element = NULL;
207 gchar *klass = NULL;
208 gchar *caps_str = NULL;
209 GstCaps *sinkcaps = NULL;
210 gint exit_code = EXIT_SUCCESS;
211
212 GOptionEntry options[] = {
213 {"list-features", 'l', 0, G_OPTION_ARG_NONE, &list_features,
214 "list all the available features", NULL},
215 {"compatible-with", '\0', 0, G_OPTION_ARG_STRING, &compatible_with,
216 "Only print the elements that could be queued after this feature name",
217 NULL},
218 {"element-properties", '\0', 0, G_OPTION_ARG_STRING, &element,
219 "The element to list properties on", NULL},
220 {"klass", '\0', 0, G_OPTION_ARG_STRING, &klass,
221 "Only print the elements belonging to that klass", NULL},
222 {"sinkcaps", '\0', 0, G_OPTION_ARG_STRING, &caps_str,
223 "Only print the elements that can sink these caps", NULL},
224 {NULL}
225 };
226
227 GOptionContext *ctx;
228 GError *err = NULL;
229
230 ctx = g_option_context_new ("PIPELINE-DESCRIPTION");
231 g_option_context_add_main_entries (ctx, options, NULL);
232 g_option_context_add_group (ctx, gst_init_get_option_group ());
233 if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
234 if (err)
235 g_printerr ("Error initializing: %s\n", GST_STR_NULL (err->message));
236 else
237 g_printerr ("Error initializing: Unknown error!\n");
238 g_clear_error (&err);
239 g_option_context_free (ctx);
240 exit (1);
241 }
242 g_option_context_free (ctx);
243
244 if (caps_str) {
245 sinkcaps = gst_caps_from_string (caps_str);
246 if (!sinkcaps) {
247 exit_code = EXIT_FAILURE;
248 goto done;
249 }
250 }
251
252 if (compatible_with || klass || sinkcaps) {
253 _list_features (compatible_with, klass, sinkcaps);
254 goto done;
255 }
256
257 if (element) {
258 _list_element_properties (element);
259 goto done;
260 }
261
262 if (list_features) {
263 _list_features (NULL, NULL, NULL);
264 goto done;
265 }
266
267 done:
268 if (sinkcaps)
269 gst_caps_unref (sinkcaps);
270 exit (exit_code);
271 }