/* NB: try to mirror decodebin behavior */ static gboolean swfdec_gst_feature_filter (GstPluginFeature *feature, gpointer caps, const gchar* klassname, gboolean autoplugonly) { const GList *walk; const gchar *klass; /* we only care about element factories */ if (!GST_IS_ELEMENT_FACTORY (feature)) return FALSE; /* only decoders are interesting */ klass = gst_element_factory_get_klass (GST_ELEMENT_FACTORY (feature)); if (strstr (klass, klassname) == NULL) return FALSE; /* only select elements with autoplugging rank */ if (autoplugonly && gst_plugin_feature_get_rank (feature) < GST_RANK_MARGINAL) return FALSE; /* only care about the right sink caps */ for (walk = gst_element_factory_get_static_pad_templates (GST_ELEMENT_FACTORY (feature)); walk; walk = walk->next) { GstStaticPadTemplate *template = walk->data;
/** * gst_element_factory_get_author: * @factory: a #GstElementFactory * * Gets the author for this factory. * * Returns: the author */ const gchar * gst_element_factory_get_author (GstElementFactory * factory) { g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), NULL); return factory->details.author; }
static gboolean cb_feature_filter (GstPluginFeature *feature, gpointer data) { const gchar *klass; guint rank; /* we only care about element factories */ if (!GST_IS_ELEMENT_FACTORY (feature)) return FALSE; /* only parsers, demuxers and decoders */ klass = gst_element_factory_get_klass (GST_ELEMENT_FACTORY (feature)); if (g_strrstr (klass, "Demux") == NULL && g_strrstr (klass, "Decoder") == NULL && g_strrstr (klass, "Parse") == NULL) return FALSE; /* only select elements with autoplugging rank */ rank = gst_plugin_feature_get_rank (feature); if (rank < GST_RANK_MARGINAL) return FALSE; return TRUE; }
/** * gst_element_factory_get_uri_type: * @factory: a #GstElementFactory * * Gets the type of URIs the element supports or #GST_URI_UNKNOWN if none. * * Returns: type of URIs this element supports */ gint gst_element_factory_get_uri_type (GstElementFactory * factory) { g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), GST_URI_UNKNOWN); return factory->uri_type; }
/** * gst_element_factory_get_description: * @factory: a #GstElementFactory * * Gets the description for this factory. * * Returns: the description */ const gchar * gst_element_factory_get_description (GstElementFactory * factory) { g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), NULL); return factory->details.description; }
/** * gst_element_factory_get_num_pad_templates: * @factory: a #GstElementFactory * * Gets the number of pad_templates in this factory. * * Returns: the number of pad_templates */ guint gst_element_factory_get_num_pad_templates (GstElementFactory * factory) { g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), 0); return factory->numpadtemplates; }
static gboolean match_element(GstPluginFeature *feature, gpointer gdata) { struct typeinfo *data = (struct typeinfo*)gdata; GstElementFactory *factory; const GList *list; if (!GST_IS_ELEMENT_FACTORY(feature)) return FALSE; factory = GST_ELEMENT_FACTORY(feature); if (!strstr(gst_element_factory_get_klass(factory), data->type)) return FALSE; for (list = gst_element_factory_get_static_pad_templates(factory); list; list = list->next) { GstStaticPadTemplate *pad = (GstStaticPadTemplate*)list->data; GstCaps *caps; gboolean ret; if (pad->direction != GST_PAD_SINK) continue; caps = gst_static_caps_get(&pad->static_caps); ret = gst_caps_is_always_compatible(caps, data->caps); gst_caps_unref(caps); if (ret) return TRUE; } return FALSE; }
/** * gst_element_factory_get_element_type: * @factory: factory to get managed #GType from * * Get the #GType for elements managed by this factory. The type can * only be retrieved if the element factory is loaded, which can be * assured with gst_plugin_feature_load(). * * Returns: the #GType for elements managed by this factory or 0 if * the factory is not loaded. */ GType gst_element_factory_get_element_type (GstElementFactory * factory) { g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), 0); return factory->type; }
/** * gst_element_factory_get_static_pad_templates: * @factory: a #GstElementFactory * * Gets the #GList of #GstStaticPadTemplate for this factory. * * Returns: (transfer none) (element-type Gst.StaticPadTemplate): the * static pad templates */ const GList * gst_element_factory_get_static_pad_templates (GstElementFactory * factory) { g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), NULL); return factory->staticpadtemplates; }
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); }
/* Return TRUE if this is a Visualization element */ static gboolean filter_vis_features(GstPluginFeature *feature, gpointer data) { GstElementFactory *factory; if (!GST_IS_ELEMENT_FACTORY(feature)) return FALSE; factory = GST_ELEMENT_FACTORY(feature); if (!g_strrstr(gst_element_factory_get_klass(factory), "Visualization")) return FALSE; return TRUE; }
/** * __gst_element_factory_add_interface: * @elementfactory: The elementfactory to add the interface to * @interfacename: Name of the interface * * Adds the given interfacename to the list of implemented interfaces of the * element. */ void __gst_element_factory_add_interface (GstElementFactory * elementfactory, const gchar * interfacename) { g_return_if_fail (GST_IS_ELEMENT_FACTORY (elementfactory)); g_return_if_fail (interfacename != NULL); g_return_if_fail (interfacename[0] != '\0'); /* no empty string */ elementfactory->interfaces = g_list_prepend (elementfactory->interfaces, (gpointer) g_intern_string (interfacename)); }
static gboolean element_filter (GstPluginFeature * feature, FilterData * data) { gboolean res; /* we only care about element factories */ if (!GST_IS_ELEMENT_FACTORY (feature)) return FALSE; res = gst_factory_list_is_type (GST_ELEMENT_FACTORY (feature), data->type); return res; }
static gboolean filter_parsers (GstElementFactory * factory, gpointer user_data) { if (GST_IS_ELEMENT_FACTORY (factory) == FALSE) return FALSE; if (g_strrstr (gst_element_factory_get_klass (factory), "Parser")) { if (gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory)) >= GST_RANK_PRIMARY) return TRUE; } return FALSE; }
static gboolean element_filter (GstPluginFeature * feature, FilterData * data) { gboolean res; /* we only care about element factories */ if (G_UNLIKELY (!GST_IS_ELEMENT_FACTORY (feature))) return FALSE; res = (gst_plugin_feature_get_rank (feature) >= data->minrank) && gst_element_factory_list_is_type (GST_ELEMENT_FACTORY_CAST (feature), data->type); return res; }
/** * gst_element_factory_has_interface: * @factory: a #GstElementFactory * @interfacename: an interface name * * Check if @factory implements the interface with name @interfacename. * * Returns: #TRUE when @factory implement the interface. * * Since: 0.10.14 */ gboolean gst_element_factory_has_interface (GstElementFactory * factory, const gchar * interfacename) { GList *walk; g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), FALSE); for (walk = factory->interfaces; walk; walk = g_list_next (walk)) { gchar *iname = (gchar *) walk->data; if (!strcmp (iname, interfacename)) return TRUE; } return FALSE; }
static gboolean FactoryFilter(GstPluginFeature *aFeature, gpointer) { if (!GST_IS_ELEMENT_FACTORY(aFeature)) { return FALSE; } // TODO _get_klass doesn't exist in 1.0 const gchar *className = gst_element_factory_get_klass(GST_ELEMENT_FACTORY_CAST(aFeature)); if (!strstr(className, "Decoder") && !strstr(className, "Demux")) { return FALSE; } return gst_plugin_feature_get_rank(aFeature) >= GST_RANK_MARGINAL; }
void iterate_plugins (GHashTable *hashtable) { GList *plugins, *orig_plugins; orig_plugins = plugins = gst_default_registry_get_plugin_list (); while (plugins) { GList *features, *orig_features; GstPlugin *plugin; plugin = (GstPlugin *) (plugins->data); plugins = g_list_next (plugins); if (plugin->flags & GST_PLUGIN_FLAG_BLACKLISTED) { continue; } orig_features = features = gst_registry_get_feature_list_by_plugin (gst_registry_get_default (), plugin->desc.name); while (features) { GstPluginFeature *feature; if (G_UNLIKELY (features->data == NULL)) goto next; feature = GST_PLUGIN_FEATURE (features->data); if (GST_IS_ELEMENT_FACTORY (feature)) { GstElementFactory *factory; factory = GST_ELEMENT_FACTORY (feature); iterate_plugins_elements (factory, hashtable); } next: features = g_list_next (features); } gst_plugin_feature_list_free (orig_features); } gst_plugin_list_free (orig_plugins); }
static gboolean FactoryFilter(GstPluginFeature *aFeature, gpointer) { if (!GST_IS_ELEMENT_FACTORY(aFeature)) { return FALSE; } const gchar *className = gst_element_factory_get_klass(GST_ELEMENT_FACTORY_CAST(aFeature)); if (!strstr(className, "Decoder") && !strstr(className, "Demux") && !strstr(className, "Parser")) { return FALSE; } return gst_plugin_feature_get_rank(aFeature) >= GST_RANK_MARGINAL && !GStreamerFormatHelper::IsPluginFeatureBlacklisted(aFeature); }
static gboolean FactoryFilter(GstPluginFeature *aFeature, gpointer) { if (!GST_IS_ELEMENT_FACTORY(aFeature)) { return FALSE; } const gchar *className = gst_element_factory_get_klass(GST_ELEMENT_FACTORY_CAST(aFeature)); // NB: We skip filtering parsers here, because adding them to // the list can give false decoder positives to canPlayType(). if (!strstr(className, "Decoder") && !strstr(className, "Demux")) { return FALSE; } return gst_plugin_feature_get_rank(aFeature) >= GST_RANK_MARGINAL && !GStreamerFormatHelper::IsPluginFeatureBlocked(aFeature); }
gboolean sink_factory_filter(GstPluginFeature* feature, gpointer data) { GstCaps* caps = (GstCaps*)data; if (!GST_IS_ELEMENT_FACTORY(feature)) return FALSE; const GList* static_pads = gst_element_factory_get_static_pad_templates(GST_ELEMENT_FACTORY(feature)); int not_any_number = 0; for (GList* item = (GList*)static_pads; item; item = item->next) { GstStaticPadTemplate* padTemplate = (GstStaticPadTemplate*)item->data; GstPadTemplate* pad = gst_static_pad_template_get(padTemplate); GstCaps* padCaps = gst_pad_template_get_caps(pad); if (!gst_caps_is_any(padCaps)) not_any_number++; } if (not_any_number == 0) return FALSE; if (!gst_element_factory_list_is_type(GST_ELEMENT_FACTORY(feature), GST_ELEMENT_FACTORY_TYPE_DECODABLE)) return FALSE; if (!gst_element_factory_can_sink_all_caps(GST_ELEMENT_FACTORY(feature), caps)) return FALSE; return TRUE; }
static gboolean gst_auto_video_convert_element_filter (GstPluginFeature * feature, GstAutoVideoConvert * autovideoconvert) { const gchar *klass; /* we only care about element factories */ if (G_UNLIKELY (!GST_IS_ELEMENT_FACTORY (feature))) return FALSE; klass = gst_element_factory_get_metadata (GST_ELEMENT_FACTORY_CAST (feature), GST_ELEMENT_METADATA_KLASS); /* only select color space converter */ if (strstr (klass, "Filter") && strstr (klass, "Converter") && strstr (klass, "Video")) { GST_DEBUG_OBJECT (autovideoconvert, "gst_auto_video_convert_element_filter found %s\n", gst_plugin_feature_get_name (GST_PLUGIN_FEATURE_CAST (feature))); return TRUE; } return FALSE; }
static gboolean gst_rtsp_ext_list_filter (GstPluginFeature * feature, gpointer user_data) { GstElementFactory *factory; guint rank; /* we only care about element factories */ if (!GST_IS_ELEMENT_FACTORY (feature)) return FALSE; factory = GST_ELEMENT_FACTORY (feature); if (!gst_element_factory_has_interface (factory, "GstRTSPExtension")) return FALSE; /* only select elements with autoplugging rank */ rank = gst_plugin_feature_get_rank (feature); if (rank < GST_RANK_MARGINAL) return FALSE; return TRUE; }
static gboolean gst_auto_video_src_factory_filter (GstPluginFeature * feature, gpointer data) { guint rank; const gchar *klass; /* we only care about element factories */ if (!GST_IS_ELEMENT_FACTORY (feature)) return FALSE; /* video sources */ klass = gst_element_factory_get_klass (GST_ELEMENT_FACTORY (feature)); if (!(strstr (klass, "Source") && strstr (klass, "Video"))) return FALSE; /* only select elements with autoplugging rank */ rank = gst_plugin_feature_get_rank (feature); if (rank < GST_RANK_MARGINAL) return FALSE; return TRUE; }
/** * gst_element_factory_get_documentation_uri: * @factory: a #GstElementFactory * * Gets documentation uri for this factory if set. * * Since: 0.10.31 * * Returns: the documentation uri */ const gchar * gst_element_factory_get_documentation_uri (GstElementFactory * factory) { g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), NULL); return gst_element_factory_get_meta_data (factory, "doc-uri"); }
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 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_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 gboolean rsndec_factory_filter (GstPluginFeature * feature, RsnDecFactoryFilterCtx * ctx) { GstElementFactory *factory; guint rank; const gchar *klass; const GList *templates; GList *walk; gboolean can_sink = FALSE; /* we only care about element factories */ if (!GST_IS_ELEMENT_FACTORY (feature)) return FALSE; factory = GST_ELEMENT_FACTORY (feature); klass = gst_element_factory_get_klass (factory); /* only decoders can play */ if (strstr (klass, "Decoder") == NULL) return FALSE; /* only select elements with autoplugging rank */ rank = gst_plugin_feature_get_rank (feature); if (rank < GST_RANK_MARGINAL) return FALSE; /* See if the element has a sink pad that can possibly sink this caps */ /* get the templates from the element factory */ templates = gst_element_factory_get_static_pad_templates (factory); for (walk = (GList *) templates; walk && !can_sink; walk = g_list_next (walk)) { GstStaticPadTemplate *templ = walk->data; /* we only care about the sink templates */ if (templ->direction == GST_PAD_SINK) { GstCaps *intersect; GstCaps *tmpl_caps; /* try to intersect the caps with the caps of the template */ tmpl_caps = gst_static_caps_get (&templ->static_caps); intersect = gst_caps_intersect (ctx->desired_caps, tmpl_caps); gst_caps_unref (tmpl_caps); /* check if the intersection is empty */ if (!gst_caps_is_empty (intersect)) { /* non empty intersection, we can use this element */ can_sink = TRUE; ctx->decoder_caps = gst_caps_merge (ctx->decoder_caps, intersect); } else gst_caps_unref (intersect); } } if (can_sink) { GST_DEBUG ("Found decoder element %s (%s)", gst_element_factory_get_longname (factory), gst_plugin_feature_get_name (feature)); } return can_sink; }
/** * gst_element_factory_get_icon_name: * @factory: a #GstElementFactory * * Gets icon name for this factory if set. * * Since: 0.10.31 * * Returns: the icon name */ const gchar * gst_element_factory_get_icon_name (GstElementFactory * factory) { g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), NULL); return gst_element_factory_get_meta_data (factory, "icon-name"); }