GstRegistry

Gst.Registry

GObject.Object
    ╰──GObject.InitiallyUnowned
        ╰──Gst.Object
            ╰──Gst.Registry

Gst.Registry.prototype.add_feature

function Gst.Registry.prototype.add_feature(feature: Gst.PluginFeature): {
    // javascript wrapper for 'gst_registry_add_feature'
}

Add the feature to the registry. The feature-added signal will be emitted.

feature's reference count will be incremented, and any floating reference will be removed (see gst_object_ref_sink (not introspectable))

Gst.Registry.prototype.add_plugin

function Gst.Registry.prototype.add_plugin(plugin: Gst.Plugin): {
    // javascript wrapper for 'gst_registry_add_plugin'
}

Add the plugin to the registry. The plugin-added signal will be emitted.

plugin's reference count will be incremented, and any floating reference will be removed (see gst_object_ref_sink (not introspectable))

Gst.Registry.prototype.check_feature_version

function Gst.Registry.prototype.check_feature_version(feature_name: String, min_major: Number, min_minor: Number, min_micro: Number): {
    // javascript wrapper for 'gst_registry_check_feature_version'
}

Checks whether a plugin feature by the given name exists in registry and whether its version is at least the version required.

Gst.Registry.prototype.feature_filter

function Gst.Registry.prototype.feature_filter(filter: Gst.PluginFeatureFilter, first: Number, user_data: Object): {
    // javascript wrapper for 'gst_registry_feature_filter'
}

Runs a filter against all features of the plugins in the registry and returns a GList with the results. If the first flag is set, only the first match is returned (as a list with a single object).

Gst.Registry.prototype.find_feature

function Gst.Registry.prototype.find_feature(name: String, type: GObject.Type): {
    // javascript wrapper for 'gst_registry_find_feature'
}

Find the pluginfeature with the given name and type in the registry.

Gst.Registry.prototype.find_plugin

function Gst.Registry.prototype.find_plugin(name: String): {
    // javascript wrapper for 'gst_registry_find_plugin'
}

Find the plugin with the given name in the registry. The plugin will be reffed; caller is responsible for unreffing.

Gst.Registry.prototype.get_feature_list

function Gst.Registry.prototype.get_feature_list(type: GObject.Type): {
    // javascript wrapper for 'gst_registry_get_feature_list'
}

Retrieves a GLib.List of Gst.PluginFeature of type.

Gst.Registry.prototype.get_feature_list_by_plugin

function Gst.Registry.prototype.get_feature_list_by_plugin(name: String): {
    // javascript wrapper for 'gst_registry_get_feature_list_by_plugin'
}

Retrieves a GLib.List of features of the plugin with name name.

Gst.Registry.prototype.get_feature_list_cookie

function Gst.Registry.prototype.get_feature_list_cookie(): {
    // javascript wrapper for 'gst_registry_get_feature_list_cookie'
}

Returns the registry's feature list cookie. This changes every time a feature is added or removed from the registry.

Gst.Registry.prototype.get_plugin_list

function Gst.Registry.prototype.get_plugin_list(): {
    // javascript wrapper for 'gst_registry_get_plugin_list'
}

Get a copy of all plugins registered in the given registry. The refcount of each element in the list in incremented.

Gst.Registry.prototype.lookup

function Gst.Registry.prototype.lookup(filename: String): {
    // javascript wrapper for 'gst_registry_lookup'
}

Look up a plugin in the given registry with the given filename. If found, plugin is reffed.

Gst.Registry.prototype.lookup_feature

function Gst.Registry.prototype.lookup_feature(name: String): {
    // javascript wrapper for 'gst_registry_lookup_feature'
}

Find a Gst.PluginFeature with name in registry.

Gst.Registry.prototype.plugin_filter

function Gst.Registry.prototype.plugin_filter(filter: Gst.PluginFilter, first: Number, user_data: Object): {
    // javascript wrapper for 'gst_registry_plugin_filter'
}

Runs a filter against all plugins in the registry and returns a GLib.List with the results. If the first flag is set, only the first match is returned (as a list with a single object). Every plugin is reffed; use Gst.Plugin.prototype.list_free after use, which will unref again.

Gst.Registry.prototype.remove_feature

function Gst.Registry.prototype.remove_feature(feature: Gst.PluginFeature): {
    // javascript wrapper for 'gst_registry_remove_feature'
}

Remove the feature from the registry.

MT safe.

Gst.Registry.prototype.remove_plugin

function Gst.Registry.prototype.remove_plugin(plugin: Gst.Plugin): {
    // javascript wrapper for 'gst_registry_remove_plugin'
}

Remove the plugin from the registry.

MT safe.

Gst.Registry.prototype.scan_path

function Gst.Registry.prototype.scan_path(path: filename): {
    // javascript wrapper for 'gst_registry_scan_path'
}

Scan the given path for plugins to add to the registry. The syntax of the path is specific to the registry.

Gst.Registry.prototype.fork_is_enabled

function Gst.Registry.prototype.fork_is_enabled(): {
    // javascript wrapper for 'gst_registry_fork_is_enabled'
}

By default GStreamer will perform scanning and rebuilding of the registry file using a helper child process.

Applications might want to disable this behaviour with the Gst.Registry.prototype.fork_set_enabled function, in which case new plugins are scanned (and loaded) into the application process.

Gst.Registry.prototype.fork_set_enabled

function Gst.Registry.prototype.fork_set_enabled(enabled: Number): {
    // javascript wrapper for 'gst_registry_fork_set_enabled'
}

Applications might want to disable/enable spawning of a child helper process when rebuilding the registry. See Gst.Registry.prototype.fork_is_enabled for more information.

Gst.Registry.prototype.get

function Gst.Registry.prototype.get(): {
    // javascript wrapper for 'gst_registry_get'
}

Retrieves the singleton plugin registry. The caller does not own a reference on the registry, as it is alive as long as GStreamer is initialized.

feature-added

function feature_added_callback(self: Gst.Registry, feature: Gst.PluginFeature, user_data: Object): {
    // javascript callback for the 'feature-added' signal
}

Signals that a feature has been added to the registry (possibly replacing a previously-added one by the same name)

Flags: Run Last

plugin-added

function plugin_added_callback(self: Gst.Registry, plugin: Gst.Plugin, user_data: Object): {
    // javascript callback for the 'plugin-added' signal
}

Signals that a plugin has been added to the registry (possibly replacing a previously-added one by the same name)

Flags: Run Last

Gst.prototype.update_registry

function Gst.prototype.update_registry(): {
    // javascript wrapper for 'gst_update_registry'
}

Forces GStreamer to re-scan its plugin paths and update the default plugin registry.

Applications will almost never need to call this function, it is only useful if the application knows new plugins have been installed (or old ones removed) since the start of the application (or, to be precise, the first call to Gst.prototype.init) and the application wants to make use of any newly-installed plugins without restarting the application.

Applications should assume that the registry update is neither atomic nor thread-safe and should therefore not have any dynamic pipelines running (including the playbin and decodebin elements) and should also not create any elements or access the GStreamer registry while the update is in progress.

Note that this function may block for a significant amount of time.