static gint plugin_name_cmp (GstPlugin * a, GstPlugin * b) { const gchar *name_a = gst_plugin_get_name (a); const gchar *name_b = gst_plugin_get_name (b); return strcmp (name_a, name_b); }
static void print_plugin_automatic_install_info (GstPlugin * plugin) { const gchar *plugin_name; GList *features, *l; plugin_name = gst_plugin_get_name (plugin); /* not interested in typefind factories, only element factories */ features = gst_registry_get_feature_list (gst_registry_get_default (), GST_TYPE_ELEMENT_FACTORY); for (l = features; l != NULL; l = l->next) { GstPluginFeature *feature; feature = GST_PLUGIN_FEATURE (l->data); /* only interested in the ones that are in the plugin we just loaded */ if (g_str_equal (plugin_name, feature->plugin_name)) { GstElementFactory *factory; g_print ("element-%s\n", gst_plugin_feature_get_name (feature)); factory = GST_ELEMENT_FACTORY (feature); print_plugin_automatic_install_info_protocols (factory); print_plugin_automatic_install_info_codecs (factory); } } g_list_foreach (features, (GFunc) gst_object_unref, NULL); g_list_free (features); }
static void setup (void) { GList *features, *f; GList *plugins, *p; gchar **ignorelist = NULL; const gchar *STATE_IGNORE_ELEMENTS = NULL; GstRegistry *def; GST_DEBUG ("getting elements for package %s", PACKAGE); STATE_IGNORE_ELEMENTS = g_getenv ("GST_STATE_IGNORE_ELEMENTS"); if (!g_getenv ("GST_NO_STATE_IGNORE_ELEMENTS") && STATE_IGNORE_ELEMENTS) { GST_DEBUG ("Will ignore element factories: '%s'", STATE_IGNORE_ELEMENTS); ignorelist = g_strsplit (STATE_IGNORE_ELEMENTS, " ", 0); } def = gst_registry_get (); plugins = gst_registry_get_plugin_list (def); for (p = plugins; p; p = p->next) { GstPlugin *plugin = p->data; if (strcmp (gst_plugin_get_source (plugin), PACKAGE) != 0) continue; features = gst_registry_get_feature_list_by_plugin (def, gst_plugin_get_name (plugin)); for (f = features; f; f = f->next) { GstPluginFeature *feature = f->data; const gchar *name = gst_plugin_feature_get_name (feature); gboolean ignore = FALSE; if (!GST_IS_ELEMENT_FACTORY (feature)) continue; if (ignorelist) { gchar **s; for (s = ignorelist; s && *s; ++s) { if (g_str_has_prefix (name, *s)) { GST_DEBUG ("ignoring element %s", name); ignore = TRUE; } } if (ignore) continue; } GST_DEBUG ("adding element %s", name); elements = g_list_prepend (elements, (gpointer) g_strdup (name)); } gst_plugin_feature_list_free (features); } gst_plugin_list_free (plugins); g_strfreev (ignorelist); }
/** * gst_plugin_feature_get_plugin_name: * @feature: a feature * * Get the name of the plugin that provides this feature. * * Returns: the name of the plugin that provides this feature, or %NULL if * the feature is not associated with a plugin. * * Since: 1.2.0 */ const gchar * gst_plugin_feature_get_plugin_name (GstPluginFeature * feature) { g_return_val_if_fail (GST_IS_PLUGIN_FEATURE (feature), NULL); if (feature->plugin == NULL) return NULL; return gst_plugin_get_name (feature->plugin); }
// // STARTUP /////////////////////////////////////////////////////////////////////////////// // (static) super-initialization - called once at application startup bool LLMediaImplGStreamer::startup (LLMediaManagerData* init_data) { static bool done_init = false; if (!done_init) { // Init the glib type system - we need it. g_type_init(); set_gst_plugin_path(); // Protect against GStreamer resetting the locale, yuck. static std::string saved_locale; saved_locale = setlocale(LC_ALL, NULL); if (0 == gst_init_check(NULL, NULL, NULL)) { LL_WARNS("MediaImpl") << "GStreamer library failed to initialize and load standard plugins." << LL_ENDL; setlocale(LC_ALL, saved_locale.c_str() ); return false; } setlocale(LC_ALL, saved_locale.c_str() ); // Set up logging facilities gst_debug_remove_log_function( gst_debug_log_default ); gst_debug_add_log_function( gstreamer_log, NULL ); // Init our custom plugins - only really need do this once. gst_slvideo_init_class(); // List the plugins GStreamer can find LL_DEBUGS("MediaImpl") << "Found GStreamer plugins:" << LL_ENDL; GList *list; GstRegistry *registry = gst_registry_get_default(); std::string loaded = ""; for (list = gst_registry_get_plugin_list(registry); list != NULL; list = g_list_next(list)) { GstPlugin *list_plugin = (GstPlugin *)list->data; (bool)gst_plugin_is_loaded(list_plugin) ? loaded = "Yes" : loaded = "No"; LL_DEBUGS("MediaImpl") << gst_plugin_get_name(list_plugin) << ", loaded? " << loaded << LL_ENDL; } gst_plugin_list_free(list); done_init = true; } return true; }
GList * gst_validate_plugin_get_config (GstPlugin * plugin) { GList *structures = NULL, *tmp, *plugin_conf = NULL; const gchar *config = g_getenv ("GST_VALIDATE_CONFIG"); if ((plugin_conf = g_object_get_data (G_OBJECT (plugin), GST_VALIDATE_PLUGIN_CONFIG))) return plugin_conf; if (config) structures = gst_validate_utils_structs_parse_from_filename (config); for (tmp = structures; tmp; tmp = tmp->next) { if (gst_structure_has_name (tmp->data, gst_plugin_get_name (plugin))) plugin_conf = g_list_append (plugin_conf, tmp->data); } g_object_set_data_full (G_OBJECT (plugin), GST_VALIDATE_PLUGIN_CONFIG, plugin_conf, _free_plugin_config); return plugin_conf; }
static void print_plugin (const gchar * marker, GstRegistry * registry, GstPlugin * plugin) { const gchar *name; GList *features, *f; name = gst_plugin_get_name (plugin); GST_DEBUG ("%s: plugin %p %d %s file: %s", marker, plugin, GST_OBJECT_REFCOUNT (plugin), name, GST_STR_NULL (gst_plugin_get_filename (plugin))); features = gst_registry_get_feature_list_by_plugin (registry, name); for (f = features; f != NULL; f = f->next) { GstPluginFeature *feature; feature = GST_PLUGIN_FEATURE (f->data); GST_LOG ("%s: feature: %p %s", marker, feature, GST_OBJECT_NAME (feature)); } gst_plugin_feature_list_free (features); }
static void 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)); 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) */ str = g_strdup (release_date); sep = strstr (str, "T"); if (sep != NULL) { *sep = ' '; sep = strstr (sep + 1, "Z"); if (sep != NULL) *sep = ' '; } else { tz = ""; } n_print (" %-25s%s%s\n", "Source release date", str, tz); 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 ("\n"); }
static void print_blacklist (void) { GList *plugins, *cur; gint count = 0; g_print ("%s\n", _("Blacklisted files:")); plugins = gst_registry_get_plugin_list (gst_registry_get ()); for (cur = plugins; cur != NULL; cur = g_list_next (cur)) { GstPlugin *plugin = (GstPlugin *) (cur->data); if (GST_OBJECT_FLAG_IS_SET (plugin, GST_PLUGIN_FLAG_BLACKLISTED)) { g_print (" %s\n", gst_plugin_get_name (plugin)); count++; } } g_print ("\n"); g_print (_("Total count: ")); g_print (ngettext ("%d blacklisted file", "%d blacklisted files", count), count); g_print ("\n"); gst_plugin_list_free (plugins); }
static void print_element_list (gboolean print_all) { int plugincount = 0, featurecount = 0, blacklistcount = 0; GList *plugins, *orig_plugins; orig_plugins = plugins = gst_registry_get_plugin_list (gst_registry_get ()); while (plugins) { GList *features, *orig_features; GstPlugin *plugin; plugin = (GstPlugin *) (plugins->data); plugins = g_list_next (plugins); plugincount++; if (GST_OBJECT_FLAG_IS_SET (plugin, GST_PLUGIN_FLAG_BLACKLISTED)) { blacklistcount++; continue; } orig_features = features = gst_registry_get_feature_list_by_plugin (gst_registry_get (), gst_plugin_get_name (plugin)); while (features) { GstPluginFeature *feature; if (G_UNLIKELY (features->data == NULL)) goto next; feature = GST_PLUGIN_FEATURE (features->data); featurecount++; if (GST_IS_ELEMENT_FACTORY (feature)) { GstElementFactory *factory; factory = GST_ELEMENT_FACTORY (feature); if (print_all) print_element_info (factory, TRUE); else g_print ("%s: %s: %s\n", gst_plugin_get_name (plugin), GST_OBJECT_NAME (factory), gst_element_factory_get_metadata (factory, GST_ELEMENT_METADATA_LONGNAME)); } else if (GST_IS_TYPE_FIND_FACTORY (feature)) { GstTypeFindFactory *factory; const gchar *const *extensions; factory = GST_TYPE_FIND_FACTORY (feature); if (!print_all) g_print ("%s: %s: ", gst_plugin_get_name (plugin), gst_plugin_feature_get_name (feature)); 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) g_print ("\n"); } else { if (!print_all) g_print ("no extensions\n"); } } else { 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))); } next: features = g_list_next (features); } gst_plugin_feature_list_free (orig_features); } gst_plugin_list_free (orig_plugins); g_print ("\n"); g_print (_("Total count: ")); g_print (ngettext ("%d plugin", "%d plugins", plugincount), plugincount); if (blacklistcount) { g_print (" ("); g_print (ngettext ("%d blacklist entry", "%d blacklist entries", blacklistcount), blacklistcount); g_print (" not shown)"); } g_print (", "); g_print (ngettext ("%d feature", "%d features", featurecount), featurecount); g_print ("\n"); }
static void 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_devproviders = 0; gint num_other = 0; origlist = features = gst_registry_get_feature_list_by_plugin (gst_registry_get (), gst_plugin_get_name (plugin)); while (features) { GstPluginFeature *feature; feature = GST_PLUGIN_FEATURE (features->data); if (GST_IS_ELEMENT_FACTORY (feature)) { GstElementFactory *factory; factory = GST_ELEMENT_FACTORY (feature); n_print (" %s: %s\n", GST_OBJECT_NAME (factory), gst_element_factory_get_metadata (factory, GST_ELEMENT_METADATA_LONGNAME)); num_elements++; } else if (GST_IS_TYPE_FIND_FACTORY (feature)) { GstTypeFindFactory *factory; const gchar *const *extensions; 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 ("\n"); } else g_print (" %s: %s: no extensions\n", gst_plugin_get_name (plugin), gst_plugin_feature_get_name (feature)); num_typefinders++; } else if (GST_IS_DEVICE_PROVIDER_FACTORY (feature)) { GstDeviceProviderFactory *factory; factory = GST_DEVICE_PROVIDER_FACTORY (feature); n_print (" %s: %s\n", GST_OBJECT_NAME (factory), gst_device_provider_factory_get_metadata (factory, GST_ELEMENT_METADATA_LONGNAME)); num_devproviders++; } else if (GST_IS_TRACER_FACTORY (feature)) { n_print (" %s (%s)\n", gst_object_get_name (GST_OBJECT (feature)), g_type_name (G_OBJECT_TYPE (feature))); num_tracers++; } else if (feature) { n_print (" %s (%s)\n", gst_object_get_name (GST_OBJECT (feature)), g_type_name (G_OBJECT_TYPE (feature))); num_other++; } num_features++; features = g_list_next (features); } gst_plugin_feature_list_free (origlist); n_print ("\n"); n_print (" %d features:\n", num_features); if (num_elements > 0) n_print (" +-- %d elements\n", num_elements); if (num_typefinders > 0) n_print (" +-- %d typefinders\n", num_typefinders); if (num_devproviders > 0) n_print (" +-- %d device providers\n", num_devproviders); if (num_tracers > 0) n_print (" +-- %d tracers\n", num_tracers); if (num_other > 0) n_print (" +-- %d other objects\n", num_other); n_print ("\n"); }
static void print_all_uri_handlers (void) { GList *plugins, *p, *features, *f; plugins = gst_registry_get_plugin_list (gst_registry_get ()); for (p = plugins; p; p = p->next) { GstPlugin *plugin = (GstPlugin *) (p->data); features = gst_registry_get_feature_list_by_plugin (gst_registry_get (), gst_plugin_get_name (plugin)); for (f = features; f; f = f->next) { GstPluginFeature *feature = GST_PLUGIN_FEATURE (f->data); if (GST_IS_ELEMENT_FACTORY (feature)) { GstElementFactory *factory; GstElement *element; factory = GST_ELEMENT_FACTORY (gst_plugin_feature_load (feature)); if (!factory) { g_print ("element plugin %s couldn't be loaded\n", gst_plugin_get_name (plugin)); continue; } element = gst_element_factory_create (factory, NULL); if (!element) { g_print ("couldn't construct element for %s for some reason\n", GST_OBJECT_NAME (factory)); gst_object_unref (factory); continue; } if (GST_IS_URI_HANDLER (element)) { const gchar *const *uri_protocols; const gchar *dir; gchar *joined; switch (gst_uri_handler_get_uri_type (GST_URI_HANDLER (element))) { case GST_URI_SRC: dir = "read"; break; case GST_URI_SINK: dir = "write"; break; default: dir = "unknown"; 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, gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory)), joined); g_free (joined); } gst_object_unref (element); gst_object_unref (factory); } } gst_plugin_feature_list_free (features); } gst_plugin_list_free (plugins); }
//static bool MediaPluginGStreamer010::startup() { // first - check if GStreamer is explicitly disabled if (NULL != getenv("LL_DISABLE_GSTREAMER")) return false; // only do global GStreamer initialization once. if (!mDoneInit) { g_thread_init(NULL); // Init the glib type system - we need it. g_type_init(); set_gst_plugin_path(); /* // Get symbols! #if LL_DARWIN if (! grab_gst_syms("libgstreamer-0.10.dylib", "libgstvideo-0.10.dylib") ) #elseif LL_WINDOWS if (! grab_gst_syms("libgstreamer-0.10.dll", "libgstvideo-0.10.dll") ) #else // linux or other ELFy unixoid if (! grab_gst_syms("libgstreamer-0.10.so.0", "libgstvideo-0.10.so.0") ) #endif { writeToLog("Couldn't find suitable GStreamer 0.10 support on this system - video playback disabled."); return false; } */ // if (gst_segtrap_set_enabled) // { gst_segtrap_set_enabled(FALSE); // } // else // { // writeToLog("gst_segtrap_set_enabled() is not available; plugin crashes won't be caught."); // } /* #if LL_LINUX // Gstreamer tries a fork during init, waitpid-ing on it, // which conflicts with any installed SIGCHLD handler... struct sigaction tmpact, oldact; if (gst_registry_fork_set_enabled) { // if we can disable SIGCHLD-using forking behaviour, // do it. gst_registry_fork_set_enabled(false); } else { // else temporarily install default SIGCHLD handler // while GStreamer initialises tmpact.sa_handler = SIG_DFL; sigemptyset( &tmpact.sa_mask ); tmpact.sa_flags = SA_SIGINFO; sigaction(SIGCHLD, &tmpact, &oldact); } #endif // LL_LINUX */ // Protect against GStreamer resetting the locale, yuck. static std::string saved_locale; saved_locale = setlocale(LC_ALL, NULL); // finally, try to initialize GStreamer! GError *err = NULL; gboolean init_gst_success = gst_init_check(NULL, NULL, &err); // restore old locale setlocale(LC_ALL, saved_locale.c_str() ); /* #if LL_LINUX // restore old SIGCHLD handler if (!gst_registry_fork_set_enabled) sigaction(SIGCHLD, &oldact, NULL); #endif // LL_LINUX */ if (!init_gst_success) // fail { if (err) { writeToLog("GST init failed: %s", err->message); g_error_free(err); } else { writeToLog("GST init failed for unspecified reason."); } return false; } // Set up logging facilities gst_debug_remove_log_function( gst_debug_log_default ); // gst_debug_add_log_function( gstreamer_log, NULL ); // Init our custom plugins - only really need do this once. gst_slvideo_init_class(); // List the plugins GStreamer can find writeToLog("Found GStreamer plugins:"); GList *list; GstRegistry *registry = gst_registry_get_default(); std::string loaded = "No"; for (list = gst_registry_get_plugin_list(registry); list != NULL; list = g_list_next(list)) { GstPlugin *list_plugin = (GstPlugin *)list->data; if (gst_plugin_is_loaded(list_plugin)) loaded = "Yes"; writeToLog("%s, loaded? %s", gst_plugin_get_name(list_plugin), loaded.c_str()); } gst_plugin_list_free(list); mDoneInit = true; } return true; }
/* Method: name * Returns: the unique name of the plugin. */ static VALUE rb_gst_plugin_get_name (VALUE self) { return CSTR2RVAL (gst_plugin_get_name (RGST_PLUGIN (self))); }