/**
* gst_plugin_load_by_name:
* @name: name of plugin to load
*
* Load the named plugin. Refs the plugin.
*
* Returns: A reference to a loaded plugin, or NULL on error.
*/
GstPlugin *
gst_plugin_load_by_name (const gchar * name)
{
GstPlugin *plugin, *newplugin;
GError *error = NULL;
GST_DEBUG ("looking up plugin %s in default registry", name);
plugin = gst_registry_find_plugin (gst_registry_get_default (), name);
if (plugin) {
GST_DEBUG ("loading plugin %s from file %s", name, plugin->filename);
newplugin = gst_plugin_load_file (plugin->filename, &error);
gst_object_unref (plugin);
if (!newplugin) {
GST_WARNING ("load_plugin error: %s", error->message);
g_error_free (error);
return NULL;
}
/* newplugin was reffed by load_file */
return newplugin;
}
GST_DEBUG ("Could not find plugin %s in registry", name);
return NULL;
}
/**
* gst_plugin_feature_check_version:
* @feature: a feature
* @min_major: minimum required major version
* @min_minor: minimum required minor version
* @min_micro: minimum required micro version
*
* Checks whether the given plugin feature is at least
* the required version
*
* Returns: #TRUE if the plugin feature has at least
* the required version, otherwise #FALSE.
*/
gboolean
gst_plugin_feature_check_version (GstPluginFeature * feature,
guint min_major, guint min_minor, guint min_micro)
{
GstRegistry *registry;
GstPlugin *plugin;
gboolean ret = FALSE;
g_return_val_if_fail (feature != NULL, FALSE);
g_return_val_if_fail (GST_IS_PLUGIN_FEATURE (feature), FALSE);
GST_DEBUG ("Looking up plugin '%s' containing plugin feature '%s'",
feature->plugin_name, GST_OBJECT_NAME (feature));
registry = gst_registry_get ();
plugin = gst_registry_find_plugin (registry, feature->plugin_name);
if (plugin) {
const gchar *ver_str;
guint major, minor, micro, nano;
gint nscan;
ver_str = gst_plugin_get_version (plugin);
g_return_val_if_fail (ver_str != NULL, FALSE);
nscan = sscanf (ver_str, "%u.%u.%u.%u", &major, &minor, µ, &nano);
GST_DEBUG ("version string '%s' parsed to %d values", ver_str, nscan);
if (nscan >= 3) {
if (major > min_major)
ret = TRUE;
else if (major < min_major)
ret = FALSE;
else if (minor > min_minor)
ret = TRUE;
else if (minor < min_minor)
ret = FALSE;
else if (micro > min_micro)
ret = TRUE;
/* micro is 1 smaller but we have a nano version, this is the upcoming
* release of the requested version and we're ok then */
else if (nscan == 4 && nano > 0 && (micro + 1 == min_micro))
ret = TRUE;
else
ret = (micro == min_micro);
GST_DEBUG ("Checking whether %u.%u.%u >= %u.%u.%u? %s", major, minor,
micro, min_major, min_minor, min_micro, (ret) ? "yes" : "no");
} else {
GST_WARNING ("Could not parse version string '%s' of plugin '%s'",
ver_str, feature->plugin_name);
}
gst_object_unref (plugin);
} else {
GST_DEBUG ("Could not find plugin '%s'", feature->plugin_name);
}
return ret;
}
/*
* Method: find_plugin(name)
* name: a plugin name.
*
* Finds the plugin with the given name in the registry.
*
* Returns: a reference to a Gst::Plugin object if found,
* otherwise returns nil.
*/
static VALUE
rb_gst_registry_find_plugin (VALUE self, VALUE name)
{
GstPlugin *plugin = gst_registry_find_plugin (RGST_REGISTRY (self),
RVAL2CSTR (name));
return plugin != NULL
? RGST_PLUGIN_NEW (plugin)
: Qnil;
}
static int
print_element_info (GstElementFactory * factory, gboolean print_names)
{
GstElement *element;
gint maxlevel = 0;
factory =
GST_ELEMENT_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE
(factory)));
if (!factory) {
g_print ("element plugin couldn't be loaded\n");
return -1;
}
element = gst_element_factory_create (factory, NULL);
if (!element) {
g_print ("couldn't construct element for some reason\n");
return -1;
}
if (print_names)
_name = g_strdup_printf ("%s: ", GST_PLUGIN_FEATURE (factory)->name);
else
_name = NULL;
print_factory_details_info (factory);
if (GST_PLUGIN_FEATURE (factory)->plugin_name) {
GstPlugin *plugin;
plugin = gst_registry_find_plugin (gst_registry_get_default (),
GST_PLUGIN_FEATURE (factory)->plugin_name);
if (plugin) {
print_plugin_info (plugin);
}
}
print_hierarchy (G_OBJECT_TYPE (element), 0, &maxlevel);
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);
gst_object_unref (element);
gst_object_unref (factory);
g_free (_name);
return 0;
}
EXPORT_C
#endif
gboolean
gst_plugin_feature_check_version (GstPluginFeature * feature,
guint min_major, guint min_minor, guint min_micro)
{
GstRegistry *registry;
GstPlugin *plugin;
gboolean ret = FALSE;
g_return_val_if_fail (feature != NULL, FALSE);
g_return_val_if_fail (GST_IS_PLUGIN_FEATURE (feature), FALSE);
GST_DEBUG ("Looking up plugin '%s' containing plugin feature '%s'",
feature->plugin_name, feature->name);
registry = gst_registry_get_default ();
plugin = gst_registry_find_plugin (registry, feature->plugin_name);
if (plugin) {
const gchar *ver_str;
guint major, minor, micro;
ver_str = gst_plugin_get_version (plugin);
g_return_val_if_fail (ver_str != NULL, FALSE);
if (sscanf (ver_str, "%u.%u.%u", &major, &minor, µ) == 3) {
if (major > min_major)
ret = TRUE;
else if (major < min_major)
ret = FALSE;
else if (minor > min_minor)
ret = TRUE;
else if (minor < min_minor)
ret = FALSE;
else if (micro > min_micro)
ret = TRUE;
else
ret = (micro == min_micro);
GST_DEBUG ("Checking whether %u.%u.%u >= %u.%u.%u? %s", major, minor,
micro, min_major, min_minor, min_micro, (ret) ? "yes" : "no");
} else {
GST_WARNING ("Could not parse version string '%s' of plugin '%s'",
ver_str, feature->plugin_name);
}
gst_object_unref (plugin);
} else {
GST_DEBUG ("Could not find plugin '%s'", feature->plugin_name);
}
return ret;
}
void test_find_plugin()
{
GstPlugin *plugin;
//xmlfile = "test_find_plugin";
std_log(LOG_FILENAME_LINE, "Test Started test_find_plugin");
plugin = gst_registry_find_plugin (gst_registry_get_default (),
"coreelements");
fail_if (plugin == NULL, "Failed to find coreelements plugin");
ASSERT_OBJECT_REFCOUNT (plugin, "plugin", 2);
fail_unless_equals_string (plugin->desc.version, VERSION);
fail_unless_equals_string (plugin->desc.license, "LGPL");
fail_unless_equals_string (plugin->desc.source, "gstreamer");
fail_unless_equals_string (plugin->desc.package, GST_PACKAGE_NAME);
fail_unless_equals_string (plugin->desc.origin, GST_PACKAGE_ORIGIN);
gst_object_unref (plugin);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
int
main (int argc, char *argv[])
{
gboolean print_all = FALSE;
gboolean do_print_blacklist = FALSE;
gboolean plugin_name = FALSE;
gboolean print_aii = FALSE;
gboolean uri_handlers = FALSE;
gboolean check_exists = FALSE;
gchar *min_version = NULL;
guint minver_maj = GST_VERSION_MAJOR;
guint minver_min = GST_VERSION_MINOR;
guint minver_micro = 0;
#ifndef GST_DISABLE_OPTION_PARSING
GOptionEntry options[] = {
{"print-all", 'a', 0, G_OPTION_ARG_NONE, &print_all,
N_("Print all elements"), NULL},
{"print-blacklist", 'b', 0, G_OPTION_ARG_NONE, &do_print_blacklist,
N_("Print list of blacklisted files"), NULL},
{"print-plugin-auto-install-info", '\0', 0, G_OPTION_ARG_NONE, &print_aii,
N_("Print a machine-parsable list of features the specified plugin "
"or all plugins provide.\n "
"Useful in connection with external automatic plugin "
"installation mechanisms"), NULL},
{"plugin", '\0', 0, G_OPTION_ARG_NONE, &plugin_name,
N_("List the plugin contents"), 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,
N_
("When checking if an element or plugin exists, also check that its "
"version is at least the version specified"), NULL},
{"uri-handlers", 'u', 0, G_OPTION_ARG_NONE, &uri_handlers,
N_
("Print supported URI schemes, with the elements that implement them"),
NULL},
GST_TOOLS_GOPTION_VERSION,
{NULL}
};
GOptionContext *ctx;
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
ctx = g_option_context_new ("[ELEMENT-NAME | PLUGIN-NAME]");
g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
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);
#else
gst_init (&argc, &argv);
#endif
gst_tools_print_version ();
if (print_all && argc > 1) {
g_printerr ("-a requires no extra arguments\n");
return -1;
}
if (uri_handlers && argc > 1) {
g_printerr ("-u requires no extra arguments\n");
return -1;
}
/* --atleast-version implies --exists */
if (min_version != NULL) {
if (sscanf (min_version, "%u.%u.%u", &minver_maj, &minver_min,
&minver_micro) < 2) {
g_printerr ("Can't parse version '%s' passed to --atleast-version\n",
min_version);
return -1;
}
check_exists = TRUE;
}
if (check_exists) {
int exit_code;
if (argc == 1) {
g_printerr ("--exists requires an extra command line argument\n");
exit_code = -1;
} else {
if (!plugin_name) {
GstPluginFeature *feature;
feature = gst_registry_lookup_feature (gst_registry_get (), argv[1]);
if (feature != NULL && gst_plugin_feature_check_version (feature,
minver_maj, minver_min, minver_micro)) {
exit_code = 0;
} else {
exit_code = 1;
}
} else {
/* FIXME: support checking for plugins too */
g_printerr ("Checking for plugins is not supported yet\n");
exit_code = -1;
}
}
return exit_code;
}
/* if no arguments, print out list of elements */
if (uri_handlers) {
print_all_uri_handlers ();
} else if (argc == 1 || print_all) {
if (do_print_blacklist)
print_blacklist ();
else {
if (print_aii)
print_all_plugin_automatic_install_info ();
else
print_element_list (print_all);
}
} else {
/* else we try to get a factory */
GstElementFactory *factory;
GstPlugin *plugin;
const char *arg = argv[argc - 1];
int retval;
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;
}
/* otherwise check if it's a plugin */
if (retval) {
plugin = gst_registry_find_plugin (gst_registry_get (), arg);
/* if there is such a plugin, print out info */
if (plugin) {
if (print_aii) {
print_plugin_automatic_install_info (plugin);
} else {
print_plugin_info (plugin);
print_plugin_features (plugin);
}
} else {
GError *error = NULL;
if (g_file_test (arg, G_FILE_TEST_EXISTS)) {
plugin = gst_plugin_load_file (arg, &error);
if (plugin) {
if (print_aii) {
print_plugin_automatic_install_info (plugin);
} else {
print_plugin_info (plugin);
print_plugin_features (plugin);
}
} else {
g_printerr (_("Could not load plugin file: %s\n"), error->message);
g_clear_error (&error);
return -1;
}
} else {
g_printerr (_("No such element or plugin '%s'\n"), arg);
return -1;
}
}
}
}
return 0;
}
int main(int argc, char *argv[])
{
GstElement *pipeline, *bin, *effect_element, *convert, *sink;
GstPad *pad, *ghost_pad;
char *pipeline_str;
GIOChannel *io_stdin = g_io_channel_unix_new(fileno(stdin));
CustomData data;
GstStateChangeReturn ret;
gboolean list_effects = FALSE;
gchar *effect_name = NULL;
GError *error = NULL;
GstPlugin *gaudiplugin;
gchar *props_str = NULL;
GOptionContext *context;
GOptionEntry options[] = {
{ "list-effects", 'l', 0, G_OPTION_ARG_NONE, &list_effects,
"list available effects and exits", NULL },
{ "effect", 'e', 0, G_OPTION_ARG_STRING, &effect_name,
"set the desired effect", NULL },
{ "props", 'p', 0, G_OPTION_ARG_STRING, &props_str,
"for property setting (-p \"silent,bool,true;adjustement,uint,150\")",
NULL },
{ NULL }
};
setlocale(LC_ALL, "fr_FR.utf8");
gst_init(&argc, &argv);
gaudiplugin = gst_registry_find_plugin(GET_PLUGIN_REGISTRY, "gaudieffects");
if (gaudiplugin == NULL) {
g_print("Pas de plugin “gaudieffects” trouvé !! :(\n");
return -1;
}
context = g_option_context_new("");
g_option_context_add_main_entries(context, options, "");
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_print("option parsing failed: %s\n", error->message);
return -1;
}
g_option_context_free(context);
if (list_effects == TRUE)
return list_gaudieffects_features();
if (argc > 1) {
if (g_str_has_prefix(argv[1], "http://") ||
g_str_has_prefix(argv[1], "ftp://"))
pipeline_str = g_strdup_printf("%s uri=\"%s\"", PLAYBIN, argv[1]);
else if (argv[1][0] == '~')
pipeline_str = g_strdup_printf("%s uri=\"file://%s%s\"", PLAYBIN,
g_get_home_dir(), argv[1]+1);
else if (g_file_test(argv[1], G_FILE_TEST_IS_REGULAR))
pipeline_str = g_strdup_printf("playbin uri=\"file://%s\"", argv[1]);
else
pipeline_str = g_strdup_printf("%s uri=%s", PLAYBIN, DEFAULT_URI);
} else
pipeline_str = g_strdup_printf("%s uri=%s", PLAYBIN, DEFAULT_URI);
g_io_add_watch(io_stdin, G_IO_IN, (GIOFunc)handle_keyboard, &data);
pipeline = gst_parse_launch(pipeline_str, NULL);
if (gst_plugin_is_loaded(gaudiplugin) == FALSE)
gst_plugin_load(gaudiplugin);
if (effect_name == NULL)
effect_name = "solarize";
effect_element = gst_element_factory_make(effect_name, effect_name);
convert = gst_element_factory_make("videoconvert", "convert");
sink = gst_element_factory_make("autovideosink", "video_sink");
if (!effect_element || !convert || !sink) {
g_printerr("Not all elements could be created.\n");
return -1;
}
bin = gst_bin_new("video_sink_bin");
gst_bin_add_many(GST_BIN(bin), effect_element, convert, sink, NULL);
gst_element_link_many(effect_element, convert, sink, NULL);
pad = gst_element_get_static_pad(effect_element, "sink");
ghost_pad = gst_ghost_pad_new("sink", pad);
gst_pad_set_active(ghost_pad, TRUE);
gst_element_add_pad(bin, ghost_pad);
gst_object_unref(pad);
g_object_set(GST_OBJECT(pipeline), "video-sink", bin, NULL);
if (props_str != NULL)
set_props(effect_element, props_str);
ret = gst_element_set_state(pipeline, GST_STATE_PLAYING);
if (ret == GST_STATE_CHANGE_FAILURE) {
g_printerr("Unable to set the pipeline to the playing state.\n");
gst_object_unref(pipeline);
return -1;
}
data.loop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(data.loop);
g_io_channel_unref(io_stdin);
gst_element_set_state(pipeline, GST_STATE_NULL);
gst_object_unref(pipeline);
return 0;
}
