int iterate_plugins_elements (GstElementFactory *factory, GHashTable *hashtable) { GstElement *element; const GList *pads; GstStaticPadTemplate *padtemplate; const GstCaps * caps; int i; factory = GST_ELEMENT_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE (factory))); if (!factory) { g_error ("element plugin couldn't be loaded"); return -1; } element = gst_element_factory_create (factory, NULL); if (!element) { g_error ("couldn't construct element for some reason"); return -1; } if (factory->numpadtemplates) { pads = factory->staticpadtemplates; while (pads) { padtemplate = (GstStaticPadTemplate *) (pads->data); pads = g_list_next (pads); if (padtemplate->direction == GST_PAD_SINK && padtemplate->presence == GST_PAD_ALWAYS && padtemplate->static_caps.string) { caps = gst_static_caps_get (&padtemplate->static_caps); if (caps != NULL && !gst_caps_is_any (caps) && !gst_caps_is_empty (caps)) { for (i = 0; i < gst_caps_get_size (caps); i++) { GstStructure *structure = gst_caps_get_structure (caps, i); const gchar *mime = gst_structure_get_name (structure); if (g_str_has_prefix (mime, "audio")) { g_hash_table_insert(hashtable, (gpointer)mime, (gpointer)&ONE); } } } } } } gst_object_unref (element); gst_object_unref (factory); return 0; }
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; }
static GstFlowReturn gst_type_find_element_chain (GstPad * pad, GstBuffer * buffer) { res = gst_type_find_element_chain_do_typefinding (typefind); { GstCaps *caps; caps = gst_type_find_helper_for_buffer (GST_OBJECT (typefind), typefind->store, &probability); // gstreamer/libs/gst/base/gsttypefindhelper.c // All available typefinders will be called on the data in order of rank. If // a typefinding function returns a probability of #GST_TYPE_FIND_MAXIMUM, // typefinding is stopped immediately and the found caps will be returned // right away. Otherwise, all available typefind functions will the tried, // and the caps with the highest probability will be returned { type_list = gst_type_find_factory_get_list (); type_list = g_list_sort (type_list, type_find_factory_rank_cmp); gst_type_find_factory_call_function (helper.factory, &find); { // find function from factory new_factory = GST_TYPE_FIND_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE (factory))); new_factory->function (find, new_factory->user_data); gst_object_unref (new_factory); } // gst_type_find_factory_call_function() } // gst_type_find_helper_for_buffer() /* probability is good enough too, so let's make it known ... */ g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE], 0, probability, caps); // stop typefind stop_typefinding (typefind); { // TODO: why set itself to NULL? gst_element_get_state (GST_ELEMENT (typefind), &state, NULL, 0); // reset state to normal typefind->mode = MODE_NORMAL; // send cache event and buffers gst_type_find_element_send_cached_events (typefind); gst_pad_push (typefind->src, typefind->store); } } // gst_type_find_element_chain_do_typefinding() }
/** * gst_type_find_factory_call_function: * @factory: A #GstTypeFindFactory * @find: (transfer none): a properly setup #GstTypeFind entry. The get_data * and suggest_type members must be set. * * Calls the #GstTypeFindFunction associated with this factory. */ void gst_type_find_factory_call_function (GstTypeFindFactory * factory, GstTypeFind * find) { GstTypeFindFactory *new_factory; g_return_if_fail (GST_IS_TYPE_FIND_FACTORY (factory)); g_return_if_fail (find != NULL); g_return_if_fail (find->peek != NULL); g_return_if_fail (find->suggest != NULL); new_factory = GST_TYPE_FIND_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE (factory))); if (new_factory) { if (new_factory->function) new_factory->function (find, new_factory->user_data); gst_object_unref (new_factory); } }
static GstElement * gst_auto_convert_get_or_make_element_from_factory (GstAutoConvert * autoconvert, GstElementFactory * factory) { GstElement *element = NULL; GstElementFactory *loaded_factory = GST_ELEMENT_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE (factory))); if (!loaded_factory) return NULL; element = gst_auto_convert_get_element_by_type (autoconvert, gst_element_factory_get_element_type (loaded_factory)); if (!element) { element = gst_auto_convert_add_element (autoconvert, loaded_factory); } gst_object_unref (loaded_factory); return element; }
/* Initialize the tracing system */ void _priv_gst_tracing_init (void) { const gchar *env = g_getenv ("GST_TRACER_PLUGINS"); if (env != NULL && *env != '\0') { GstRegistry *registry = gst_registry_get (); GstPluginFeature *feature; GstTracerFactory *factory; gchar **t = g_strsplit_set (env, ";", 0); gint i = 0; gchar *params; GST_INFO ("enabling tracers: '%s'", env); if (G_N_ELEMENTS (_quark_strings) != GST_TRACER_QUARK_MAX) g_warning ("the quark table is not consistent! %d != %d", (gint) G_N_ELEMENTS (_quark_strings), GST_TRACER_QUARK_MAX); for (i = 0; i < GST_TRACER_QUARK_MAX; i++) { _priv_gst_tracer_quark_table[i] = g_quark_from_static_string (_quark_strings[i]); } _priv_tracers = g_hash_table_new (NULL, NULL); i = 0; while (t[i]) { // check t[i] for params if ((params = strchr (t[i], '('))) { gchar *end = strchr (¶ms[1], ')'); *params = '\0'; params++; if (end) *end = '\0'; } else { params = NULL; } GST_INFO ("checking tracer: '%s'", t[i]); if ((feature = gst_registry_lookup_feature (registry, t[i]))) { factory = GST_TRACER_FACTORY (gst_plugin_feature_load (feature)); if (factory) { GST_INFO_OBJECT (factory, "creating tracer: type-id=%u", (guint) factory->type); /* tracers register them self to the hooks */ gst_object_unref (g_object_new (factory->type, "params", params, NULL)); } else { GST_WARNING_OBJECT (feature, "loading plugin containing feature %s failed!", t[i]); } } else { GST_WARNING ("no tracer named '%s'", t[i]); } i++; } g_strfreev (t); } }
/** * gst_element_factory_create: * @factory: factory to instantiate * @name: (allow-none): name of new element, or NULL to automatically create * a unique name * * Create a new element of the type defined by the given elementfactory. * It will be given the name supplied, since all elements require a name as * their first argument. * * Returns: (transfer full): new #GstElement or NULL if the element couldn't * be created */ GstElement * gst_element_factory_create (GstElementFactory * factory, const gchar * name) { GstElement *element; GstElementClass *oclass; GstElementFactory *newfactory; g_return_val_if_fail (factory != NULL, NULL); newfactory = GST_ELEMENT_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE (factory))); if (newfactory == NULL) goto load_failed; factory = newfactory; if (name) GST_INFO ("creating element \"%s\" named \"%s\"", GST_PLUGIN_FEATURE_NAME (factory), GST_STR_NULL (name)); else GST_INFO ("creating element \"%s\"", GST_PLUGIN_FEATURE_NAME (factory)); if (factory->type == 0) goto no_type; /* create an instance of the element, cast so we don't assert on NULL * also set name as early as we can */ if (name) element = GST_ELEMENT_CAST (g_object_new (factory->type, "name", name, NULL)); else element = GST_ELEMENT_CAST (g_object_newv (factory->type, 0, NULL)); if (G_UNLIKELY (element == NULL)) goto no_element; /* fill in the pointer to the factory in the element class. The * class will not be unreffed currently. * Be thread safe as there might be 2 threads creating the first instance of * an element at the same moment */ oclass = GST_ELEMENT_GET_CLASS (element); if (!G_ATOMIC_POINTER_COMPARE_AND_EXCHANGE (&oclass->elementfactory, NULL, factory)) gst_object_unref (factory); GST_DEBUG ("created element \"%s\"", GST_PLUGIN_FEATURE_NAME (factory)); return element; /* ERRORS */ load_failed: { GST_WARNING_OBJECT (factory, "loading plugin containing feature %s returned NULL!", name); return NULL; } no_type: { GST_WARNING_OBJECT (factory, "factory has no type"); gst_object_unref (factory); return NULL; } no_element: { GST_WARNING_OBJECT (factory, "could not create element"); gst_object_unref (factory); return NULL; } }
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); }
/** * gst_device_provider_factory_get: * @factory: factory to instantiate * * Returns the device provider of the type defined by the given device * providerfactory. * * Returns: (transfer full) (nullable): the #GstDeviceProvider or %NULL * if the device provider couldn't be created * * Since: 1.4 */ GstDeviceProvider * gst_device_provider_factory_get (GstDeviceProviderFactory * factory) { GstDeviceProvider *device_provider; GstDeviceProviderClass *oclass; GstDeviceProviderFactory *newfactory; g_return_val_if_fail (factory != NULL, NULL); newfactory = GST_DEVICE_PROVIDER_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE (factory))); if (newfactory == NULL) goto load_failed; factory = newfactory; GST_INFO ("getting device provider \"%s\"", GST_OBJECT_NAME (factory)); if (factory->type == 0) goto no_type; device_provider = g_atomic_pointer_get (&newfactory->provider); if (device_provider) return gst_object_ref (device_provider); /* create an instance of the device provider, cast so we don't assert on NULL * also set name as early as we can */ device_provider = GST_DEVICE_PROVIDER_CAST (g_object_newv (factory->type, 0, NULL)); if (G_UNLIKELY (device_provider == NULL)) goto no_device_provider; /* fill in the pointer to the factory in the device provider class. The * class will not be unreffed currently. * Be thread safe as there might be 2 threads creating the first instance of * an device provider at the same moment */ oclass = GST_DEVICE_PROVIDER_GET_CLASS (device_provider); if (!g_atomic_pointer_compare_and_exchange (&oclass->factory, NULL, factory)) gst_object_unref (factory); gst_object_ref_sink (device_provider); /* We use an atomic to make sure we don't create two in parallel */ if (!g_atomic_pointer_compare_and_exchange (&newfactory->provider, NULL, device_provider)) { gst_object_unref (device_provider); device_provider = g_atomic_pointer_get (&newfactory->provider); } GST_DEBUG ("created device provider \"%s\"", GST_OBJECT_NAME (factory)); return gst_object_ref (device_provider); /* ERRORS */ load_failed: { GST_WARNING_OBJECT (factory, "loading plugin containing feature %s returned NULL!", GST_OBJECT_NAME (factory)); return NULL; } no_type: { GST_WARNING_OBJECT (factory, "factory has no type"); gst_object_unref (factory); return NULL; } no_device_provider: { GST_WARNING_OBJECT (factory, "could not create device provider"); gst_object_unref (factory); return NULL; } }
/* Initialize the tracing system */ void _priv_gst_tracing_init (void) { gint i = 0; const gchar *env = g_getenv ("GST_TRACERS"); /* We initialize the tracer sub system even if the end * user did not activate it through the env variable * so that external tools can use it anyway */ GST_DEBUG ("Initializing GstTracer"); _priv_tracers = g_hash_table_new (NULL, NULL); if (G_N_ELEMENTS (_quark_strings) != GST_TRACER_QUARK_MAX) g_warning ("the quark table is not consistent! %d != %d", (gint) G_N_ELEMENTS (_quark_strings), GST_TRACER_QUARK_MAX); for (i = 0; i < GST_TRACER_QUARK_MAX; i++) { _priv_gst_tracer_quark_table[i] = g_quark_from_static_string (_quark_strings[i]); } if (env != NULL && *env != '\0') { GstRegistry *registry = gst_registry_get (); GstPluginFeature *feature; GstTracerFactory *factory; gchar **t = g_strsplit_set (env, ";", 0); gchar *params; GST_INFO ("enabling tracers: '%s'", env); i = 0; while (t[i]) { // check t[i] for params if ((params = strchr (t[i], '('))) { gchar *end = strchr (¶ms[1], ')'); *params = '\0'; params++; if (end) *end = '\0'; } else { params = NULL; } GST_INFO ("checking tracer: '%s'", t[i]); if ((feature = gst_registry_lookup_feature (registry, t[i]))) { factory = GST_TRACER_FACTORY (gst_plugin_feature_load (feature)); if (factory) { GstTracer *tracer; GST_INFO_OBJECT (factory, "creating tracer: type-id=%u", (guint) factory->type); tracer = g_object_new (factory->type, "params", params, NULL); /* Clear floating flag */ gst_object_ref_sink (tracer); /* tracers register them self to the hooks */ gst_object_unref (tracer); } else { GST_WARNING_OBJECT (feature, "loading plugin containing feature %s failed!", t[i]); } } else { GST_WARNING ("no tracer named '%s'", t[i]); } i++; } g_strfreev (t); } }