/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2000 Wim Taymans <wtay@chello.be>

 *                    2005 David A. Schleef <ds@schleef.org>

 *

 * gstregistry.c: handle registry

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstregistry

 * @title: GstRegistry

 * @short_description: Abstract base class for management of #GstPlugin objects

 * @see_also: #GstPlugin, #GstPluginFeature

 *

 * One registry holds the metadata of a set of plugins.

 *

 * <emphasis role="bold">Design:</emphasis>

 *

 * The #GstRegistry object is a list of plugins and some functions for dealing

 * with them. Each #GstPlugin is matched 1-1 with a file on disk, and may or may

 * not be loaded at a given time.

 *

 * The primary source, at all times, of plugin information is each plugin file

 * itself. Thus, if an application wants information about a particular plugin,

 * or wants to search for a feature that satisfies given criteria, the primary

 * means of doing so is to load every plugin and look at the resulting

 * information that is gathered in the default registry. Clearly, this is a time

 * consuming process, so we cache information in the registry file. The format

 * and location of the cache file is internal to gstreamer.

 *

 * On startup, plugins are searched for in the plugin search path. The following

 * locations are checked in this order:

 *

 * * location from --gst-plugin-path commandline option.

 * * the GST_PLUGIN_PATH environment variable.

 * * the GST_PLUGIN_SYSTEM_PATH environment variable.

 * * default locations (if GST_PLUGIN_SYSTEM_PATH is not set).

 *   Those default locations are:

 *   `$XDG_DATA_HOME/gstreamer-$GST_API_VERSION/plugins/`

 *   and `$prefix/libs/gstreamer-$GST_API_VERSION/`.

 *   [$XDG_DATA_HOME](http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html) defaults to

 *   `$HOME/.local/share`.

 *

 * The registry cache file is loaded from

 * `$XDG_CACHE_HOME/gstreamer-$GST_API_VERSION/registry-$ARCH.bin`

 * (where $XDG_CACHE_HOME defaults to `$HOME/.cache`) or the file listed in the `GST_REGISTRY`

 * env var. One reason to change the registry location is for testing.

 *

 * For each plugin that is found in the plugin search path, there could be 3

 * possibilities for cached information:

 *

 *   * the cache may not contain information about a given file.

 *   * the cache may have stale information.

 *   * the cache may have current information.

 *

 * In the first two cases, the plugin is loaded and the cache updated. In

 * addition to these cases, the cache may have entries for plugins that are not

 * relevant to the current process. These are marked as not available to the

 * current process. If the cache is updated for whatever reason, it is marked

 * dirty.

 *

 * A dirty cache is written out at the end of initialization. Each entry is

 * checked to make sure the information is minimally valid. If not, the entry is

 * simply dropped.

 *

 * ## Implementation notes:

 *

 * The "cache" and "registry" are different concepts and can represent

 * different sets of plugins. For various reasons, at init time, the cache is

 * stored in the default registry, and plugins not relevant to the current

 * process are marked with the %GST_PLUGIN_FLAG_CACHED bit. These plugins are

 * removed at the end of initialization.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gstconfig.h"

#include "gst_private.h"

#include <glib.h>

#include <sys/types.h>

#include <sys/stat.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <errno.h>

#include <stdio.h>

#include <string.h>

/* For g_stat () */

#include <glib/gstdio.h>

#include "gstinfo.h"

#include "gsterror.h"

#include "gstregistry.h"

#include "gstdeviceproviderfactory.h"

#include "gstpluginloader.h"

#include "gst-i18n-lib.h"

#include "gst.h"

#include "glib-compat-private.h"

#ifdef G_OS_WIN32

#include <windows.h>

extern HMODULE _priv_gst_dll_handle;

#endif

#define GST_CAT_DEFAULT GST_CAT_REGISTRY

struct _GstRegistryPrivate

{

  GList *plugins;

  GList *features;

  guint n_plugins;

#if 0

  GList *paths;

#endif

  int cache_file;

  /* hash to speedup _lookup_feature_locked() */

  GHashTable *feature_hash;

  /* hash to speedup _lookup */

  GHashTable *basename_hash;

  /* updated whenever the feature list changes */

  guint32 cookie;

  /* speedup for searching features */

  GList *element_factory_list;

  guint32 efl_cookie;

  GList *typefind_factory_list;

  guint32 tfl_cookie;

  GList *device_provider_factory_list;

  guint32 dmfl_cookie;

};

/* the one instance of the default registry and the mutex protecting the

 * variable. */

static GMutex _gst_registry_mutex;

static GstRegistry *_gst_registry_default = NULL;

/* defaults */

#define DEFAULT_FORK TRUE

/* control the behaviour of registry rebuild */

static gboolean _gst_enable_registry_fork = DEFAULT_FORK;

/* List of plugins that need preloading/reloading after scanning registry */

extern GSList *_priv_gst_preload_plugins;

#ifndef GST_DISABLE_REGISTRY

/* Set to TRUE to disable registry, behaves similar to GST_DISABLE_REGISTRY */

gboolean _priv_gst_disable_registry = FALSE;

/*set to TRUE when registry needn't to be updated */

gboolean _priv_gst_disable_registry_update = FALSE;

extern GList *_priv_gst_plugin_paths;

/* Set to TRUE when the registry cache should be disabled */

gboolean _gst_disable_registry_cache = FALSE;

static gboolean __registry_reuse_plugin_scanner = TRUE;

#endif

/* Element signals and args */

enum

{

  PLUGIN_ADDED,

  FEATURE_ADDED,

  LAST_SIGNAL

};

static void gst_registry_finalize (GObject * object);

static guint gst_registry_signals[LAST_SIGNAL] = { 0 };

static GstPluginFeature *gst_registry_lookup_feature_locked (GstRegistry *

    registry, const char *name);

static GstPlugin *gst_registry_lookup_bn_locked (GstRegistry * registry,

    const char *basename);

#define gst_registry_parent_class parent_class

G_DEFINE_TYPE (GstRegistry, gst_registry, GST_TYPE_OBJECT);

static void

gst_registry_class_init (GstRegistryClass * klass)

{

  GObjectClass *gobject_class;

  gobject_class = (GObjectClass *) klass;

  g_type_class_add_private (klass, sizeof (GstRegistryPrivate));

  /**

   * GstRegistry::plugin-added:

   * @registry: the registry that emitted the signal

   * @plugin: the plugin that has been added

   *

   * Signals that a plugin has been added to the registry (possibly

   * replacing a previously-added one by the same name)

   */

  gst_registry_signals[PLUGIN_ADDED] =

      g_signal_new ("plugin-added", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,

      G_TYPE_NONE, 1, GST_TYPE_PLUGIN);

  /**

   * GstRegistry::feature-added:

   * @registry: the registry that emitted the signal

   * @feature: the feature that has been added

   *

   * Signals that a feature has been added to the registry (possibly

   * replacing a previously-added one by the same name)

   */

  gst_registry_signals[FEATURE_ADDED] =

      g_signal_new ("feature-added", G_TYPE_FROM_CLASS (klass),

      G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,

      G_TYPE_NONE, 1, GST_TYPE_PLUGIN_FEATURE);

  gobject_class->finalize = gst_registry_finalize;

}

static void

gst_registry_init (GstRegistry * registry)

{

  registry->priv =

      G_TYPE_INSTANCE_GET_PRIVATE (registry, GST_TYPE_REGISTRY,

      GstRegistryPrivate);

  registry->priv->feature_hash = g_hash_table_new (g_str_hash, g_str_equal);

  registry->priv->basename_hash = g_hash_table_new (g_str_hash, g_str_equal);

}

static void

gst_registry_finalize (GObject * object)

{

  GstRegistry *registry = GST_REGISTRY (object);

  GList *plugins, *p;

  GList *features, *f;

  plugins = registry->priv->plugins;

  registry->priv->plugins = NULL;

  registry->priv->n_plugins = 0;

  GST_DEBUG_OBJECT (registry, "registry finalize");

  p = plugins;

  while (p) {

    GstPlugin *plugin = p->data;

    if (plugin) {

      GST_LOG_OBJECT (registry, "removing plugin %s",

          gst_plugin_get_name (plugin));

      gst_object_unref (plugin);

    }

    p = g_list_next (p);

  }

  g_list_free (plugins);

  features = registry->priv->features;

  registry->priv->features = NULL;

  f = features;

  while (f) {

    GstPluginFeature *feature = f->data;

    if (feature) {

      GST_LOG_OBJECT (registry, "removing feature %p (%s)", feature,

          GST_OBJECT_NAME (feature));

      gst_object_unparent (GST_OBJECT_CAST (feature));

    }

    f = g_list_next (f);

  }

  g_list_free (features);

  g_hash_table_destroy (registry->priv->feature_hash);

  registry->priv->feature_hash = NULL;

  g_hash_table_destroy (registry->priv->basename_hash);

  registry->priv->basename_hash = NULL;

  if (registry->priv->element_factory_list) {

    GST_DEBUG_OBJECT (registry, "Cleaning up cached element factory list");

    gst_plugin_feature_list_free (registry->priv->element_factory_list);

  }

  if (registry->priv->typefind_factory_list) {

    GST_DEBUG_OBJECT (registry, "Cleaning up cached typefind factory list");

    gst_plugin_feature_list_free (registry->priv->typefind_factory_list);

  }

  if (registry->priv->device_provider_factory_list) {

    GST_DEBUG_OBJECT (registry,

        "Cleaning up cached device provider factory list");

    gst_plugin_feature_list_free (registry->priv->device_provider_factory_list);

  }

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

/**

 * 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.

 *

 * Returns: (transfer none): the #GstRegistry.

 */

GstRegistry *

gst_registry_get (void)

{

  GstRegistry *registry;

  g_mutex_lock (&_gst_registry_mutex);

  if (G_UNLIKELY (!_gst_registry_default)) {

    _gst_registry_default = g_object_new (GST_TYPE_REGISTRY, NULL);

    gst_object_ref_sink (GST_OBJECT_CAST (_gst_registry_default));

  }

  registry = _gst_registry_default;

  g_mutex_unlock (&_gst_registry_mutex);

  return registry;

}

#if 0

/**

 * gst_registry_add_path:

 * @registry: the registry to add the path to

 * @path: the path to add to the registry

 *

 * Add the given path to the registry. The syntax of the

 * path is specific to the registry. If the path has already been

 * added, do nothing.

 */

void

gst_registry_add_path (GstRegistry * registry, const gchar * path)

{

  g_return_if_fail (GST_IS_REGISTRY (registry));

  g_return_if_fail (path != NULL);

  if (strlen (path) == 0)

    goto empty_path;

  GST_OBJECT_LOCK (registry);

  if (g_list_find_custom (registry->priv->paths, path, (GCompareFunc) strcmp))

    goto was_added;

  GST_INFO ("Adding plugin path: \"%s\"", path);

  registry->priv->paths =

      g_list_append (registry->priv->paths, g_strdup (path));

  GST_OBJECT_UNLOCK (registry);

  return;

empty_path:

  {

    GST_INFO ("Ignoring empty plugin path");

    return;

  }

was_added:

  {

    g_warning ("path %s already added to registry", path);

    GST_OBJECT_UNLOCK (registry);

    return;

  }

}

/**

 * gst_registry_get_path_list:

 * @registry: the registry to get the pathlist of

 *

 * Get the list of paths for the given registry.

 *

 * Returns: (transfer container) (element-type char*): A #GList of paths as

 *     strings. g_list_free after use.

 *

 * MT safe.

 */

GList *

gst_registry_get_path_list (GstRegistry * registry)

{

  GList *list;

  g_return_val_if_fail (GST_IS_REGISTRY (registry), NULL);

  GST_OBJECT_LOCK (registry);

  /* We don't need to copy the strings, because they won't be deleted

   * as long as the GstRegistry is around */

  list = g_list_copy (registry->priv->paths);

  GST_OBJECT_UNLOCK (registry);

  return list;

}

#endif

/**

 * gst_registry_add_plugin:

 * @registry: the registry to add the plugin to

 * @plugin: (transfer floating): the plugin to add

 *

 * 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())

 *

 * Returns: %TRUE on success.

 *

 * MT safe.

 */

gboolean

gst_registry_add_plugin (GstRegistry * registry, GstPlugin * plugin)

{

  GstPlugin *existing_plugin;

  g_return_val_if_fail (GST_IS_REGISTRY (registry), FALSE);

  g_return_val_if_fail (GST_IS_PLUGIN (plugin), FALSE);

  GST_OBJECT_LOCK (registry);

  if (G_LIKELY (plugin->basename)) {

    /* we have a basename, see if we find the plugin */

    existing_plugin =

        gst_registry_lookup_bn_locked (registry, plugin->basename);

    if (existing_plugin) {

      GST_DEBUG_OBJECT (registry,

          "Replacing existing plugin \"%s\" %p with new plugin %p for filename \"%s\"",

          GST_STR_NULL (existing_plugin->filename), existing_plugin, plugin,

          GST_STR_NULL (plugin->filename));

      /* If the new plugin is blacklisted and the existing one isn't cached, do not

       * accept if it's from a different location than the existing one */

      if (GST_OBJECT_FLAG_IS_SET (plugin, GST_PLUGIN_FLAG_BLACKLISTED) &&

          strcmp (plugin->filename, existing_plugin->filename)) {

        GST_WARNING_OBJECT (registry,

            "Not replacing plugin because new one (%s) is blacklisted but for a different location than existing one (%s)",

            plugin->filename, existing_plugin->filename);

        /* Keep reference counting consistent */

        gst_object_ref_sink (plugin);

        gst_object_unref (plugin);

        GST_OBJECT_UNLOCK (registry);

        return FALSE;

      }

      registry->priv->plugins =

          g_list_remove (registry->priv->plugins, existing_plugin);

      --registry->priv->n_plugins;

      if (G_LIKELY (existing_plugin->basename))

        g_hash_table_remove (registry->priv->basename_hash,

            existing_plugin->basename);

      gst_object_unref (existing_plugin);

    }

  }

  GST_DEBUG_OBJECT (registry, "adding plugin %p for filename \"%s\"",

      plugin, GST_STR_NULL (plugin->filename));

  registry->priv->plugins = g_list_prepend (registry->priv->plugins, plugin);

  ++registry->priv->n_plugins;

  if (G_LIKELY (plugin->basename))

    g_hash_table_replace (registry->priv->basename_hash, plugin->basename,

        plugin);

  gst_object_ref_sink (plugin);

  GST_OBJECT_UNLOCK (registry);

  GST_LOG_OBJECT (registry, "emitting plugin-added for filename \"%s\"",

      GST_STR_NULL (plugin->filename));

  g_signal_emit (registry, gst_registry_signals[PLUGIN_ADDED], 0, plugin);

  return TRUE;

}

static void

gst_registry_remove_features_for_plugin_unlocked (GstRegistry * registry,

    GstPlugin * plugin)

{

  GList *f;

  g_return_if_fail (GST_IS_REGISTRY (registry));

  g_return_if_fail (GST_IS_PLUGIN (plugin));

  /* Remove all features for this plugin */

  f = registry->priv->features;

  while (f != NULL) {

    GList *next = g_list_next (f);

    GstPluginFeature *feature = f->data;

    if (G_UNLIKELY (feature && feature->plugin == plugin)) {

      GST_DEBUG_OBJECT (registry, "removing feature %p (%s) for plugin %p (%s)",

          feature, gst_plugin_feature_get_name (feature), plugin,

          plugin->desc.name);

      registry->priv->features =

          g_list_delete_link (registry->priv->features, f);

      g_hash_table_remove (registry->priv->feature_hash,

          GST_OBJECT_NAME (feature));

      gst_object_unparent (GST_OBJECT_CAST (feature));

    }

    f = next;

  }

  registry->priv->cookie++;

}

/**

 * gst_registry_remove_plugin:

 * @registry: the registry to remove the plugin from

 * @plugin: (transfer none): the plugin to remove

 *

 * Remove the plugin from the registry.

 *

 * MT safe.

 */

void

gst_registry_remove_plugin (GstRegistry * registry, GstPlugin * plugin)

{

  g_return_if_fail (GST_IS_REGISTRY (registry));

  g_return_if_fail (GST_IS_PLUGIN (plugin));

  GST_DEBUG_OBJECT (registry, "removing plugin %p (%s)",

      plugin, gst_plugin_get_name (plugin));

  GST_OBJECT_LOCK (registry);

  registry->priv->plugins = g_list_remove (registry->priv->plugins, plugin);

  --registry->priv->n_plugins;

  if (G_LIKELY (plugin->basename))

    g_hash_table_remove (registry->priv->basename_hash, plugin->basename);

  gst_registry_remove_features_for_plugin_unlocked (registry, plugin);

  GST_OBJECT_UNLOCK (registry);

  gst_object_unref (plugin);

}

/**

 * gst_registry_add_feature:

 * @registry: the registry to add the plugin to

 * @feature: (transfer floating): the feature to add

 *

 * 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())

 *

 * Returns: %TRUE on success.

 *

 * MT safe.

 */

gboolean

gst_registry_add_feature (GstRegistry * registry, GstPluginFeature * feature)

{

  GstPluginFeature *existing_feature;

  g_return_val_if_fail (GST_IS_REGISTRY (registry), FALSE);

  g_return_val_if_fail (GST_IS_PLUGIN_FEATURE (feature), FALSE);

  g_return_val_if_fail (GST_OBJECT_NAME (feature) != NULL, FALSE);

  g_return_val_if_fail (feature->plugin_name != NULL, FALSE);

  GST_OBJECT_LOCK (registry);

  existing_feature = gst_registry_lookup_feature_locked (registry,

      GST_OBJECT_NAME (feature));

  if (G_UNLIKELY (existing_feature)) {

    GST_DEBUG_OBJECT (registry, "replacing existing feature %p (%s)",

        existing_feature, GST_OBJECT_NAME (feature));

    /* Remove the existing feature from the list now, before we insert the new

     * one, but don't unref yet because the hash is still storing a reference to

     * it. */

    registry->priv->features =

        g_list_remove (registry->priv->features, existing_feature);

  }

  GST_DEBUG_OBJECT (registry, "adding feature %p (%s)", feature,

      GST_OBJECT_NAME (feature));

  registry->priv->features = g_list_prepend (registry->priv->features, feature);

  g_hash_table_replace (registry->priv->feature_hash, GST_OBJECT_NAME (feature),

      feature);

  if (G_UNLIKELY (existing_feature)) {

    /* We unref now. No need to remove the feature name from the hash table, it

     * got replaced by the new feature */

    gst_object_unparent (GST_OBJECT_CAST (existing_feature));

  }

  gst_object_set_parent (GST_OBJECT_CAST (feature), GST_OBJECT_CAST (registry));

  registry->priv->cookie++;

  GST_OBJECT_UNLOCK (registry);

  GST_LOG_OBJECT (registry, "emitting feature-added for %s",

      GST_OBJECT_NAME (feature));

  g_signal_emit (registry, gst_registry_signals[FEATURE_ADDED], 0, feature);

  return TRUE;

}

/**

 * gst_registry_remove_feature:

 * @registry: the registry to remove the feature from

 * @feature: (transfer none): the feature to remove

 *

 * Remove the feature from the registry.

 *

 * MT safe.

 */

void

gst_registry_remove_feature (GstRegistry * registry, GstPluginFeature * feature)

{

  g_return_if_fail (GST_IS_REGISTRY (registry));

  g_return_if_fail (GST_IS_PLUGIN_FEATURE (feature));

  GST_DEBUG_OBJECT (registry, "removing feature %p (%s)",

      feature, gst_plugin_feature_get_name (feature));

  GST_OBJECT_LOCK (registry);

  registry->priv->features = g_list_remove (registry->priv->features, feature);

  g_hash_table_remove (registry->priv->feature_hash, GST_OBJECT_NAME (feature));

  registry->priv->cookie++;

  GST_OBJECT_UNLOCK (registry);

  gst_object_unparent ((GstObject *) feature);

}

/**

 * gst_registry_plugin_filter:

 * @registry: registry to query

 * @filter: (scope call): the filter to use

 * @first: only return first match

 * @user_data: (closure): user data passed to the filter function

 *

 * Runs a filter against all 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).

 * Every plugin is reffed; use gst_plugin_list_free() after use, which

 * will unref again.

 *

 * Returns: (transfer full) (element-type Gst.Plugin): a #GList of #GstPlugin.

 *     Use gst_plugin_list_free() after usage.

 *

 * MT safe.

 */

GList *

gst_registry_plugin_filter (GstRegistry * registry,

    GstPluginFilter filter, gboolean first, gpointer user_data)

{

  GstPlugin **plugins;

  GList *walk, *list = NULL;

  guint n_plugins, i;

  g_return_val_if_fail (GST_IS_REGISTRY (registry), NULL);

  GST_OBJECT_LOCK (registry);

  n_plugins = registry->priv->n_plugins;

  plugins = g_newa (GstPlugin *, n_plugins + 1);

  for (walk = registry->priv->plugins, i = 0; walk != NULL; walk = walk->next)

    plugins[i++] = gst_object_ref (walk->data);

  GST_OBJECT_UNLOCK (registry);

  for (i = 0; i < n_plugins; ++i) {

    if (filter == NULL || filter (plugins[i], user_data)) {

      list = g_list_prepend (list, gst_object_ref (plugins[i]));

      if (first)

        break;

    }

  }

  for (i = 0; i < n_plugins; ++i)

    gst_object_unref (plugins[i]);

  return list;

}

typedef struct

{

  const gchar *name;

  GType type;

} GstTypeNameData;

static gboolean

gst_plugin_feature_type_name_filter (GstPluginFeature * feature,

    GstTypeNameData * data)

{

  g_assert (GST_IS_PLUGIN_FEATURE (feature));

  return ((data->type == 0 || data->type == G_OBJECT_TYPE (feature)) &&

      (data->name == NULL || !strcmp (data->name, GST_OBJECT_NAME (feature))));

}

/* returns TRUE if the list was changed

 *

 * Must be called with the object lock taken */

static gboolean

gst_registry_get_feature_list_or_create (GstRegistry * registry,

    GList ** previous, guint32 * cookie, GType type)

{

  gboolean res = FALSE;

  GstRegistryPrivate *priv = registry->priv;

  if (G_UNLIKELY (!*previous || priv->cookie != *cookie)) {

    GstTypeNameData data;

    const GList *walk;

    if (*previous) {

      gst_plugin_feature_list_free (*previous);

      *previous = NULL;

    }

    data.type = type;

    data.name = NULL;

    for (walk = registry->priv->features; walk != NULL; walk = walk->next) {

      GstPluginFeature *feature = walk->data;

      if (gst_plugin_feature_type_name_filter (feature, &data)) {

        *previous = g_list_prepend (*previous, gst_object_ref (feature));

      }

    }

    *cookie = priv->cookie;

    res = TRUE;

  }

  return res;

}

static gint

type_find_factory_rank_cmp (const GstPluginFeature * fac1,

    const GstPluginFeature * fac2)

{

  if (G_LIKELY (fac1->rank != fac2->rank))

    return fac2->rank - fac1->rank;

  /* to make the order in which things happen more deterministic,

   * sort by name when the ranks are the same. */

  return strcmp (GST_OBJECT_NAME (fac1), GST_OBJECT_NAME (fac2));

}

static GList *

gst_registry_get_element_factory_list (GstRegistry * registry)

{

  GList *list;

  GST_OBJECT_LOCK (registry);

  gst_registry_get_feature_list_or_create (registry,

      &registry->priv->element_factory_list, &registry->priv->efl_cookie,

      GST_TYPE_ELEMENT_FACTORY);

  /* Return reffed copy */

  list = gst_plugin_feature_list_copy (registry->priv->element_factory_list);

  GST_OBJECT_UNLOCK (registry);

  return list;

}

static GList *

gst_registry_get_typefind_factory_list (GstRegistry * registry)

{

  GList *list;

  GST_OBJECT_LOCK (registry);

  if (G_UNLIKELY (gst_registry_get_feature_list_or_create (registry,

              &registry->priv->typefind_factory_list,

              &registry->priv->tfl_cookie, GST_TYPE_TYPE_FIND_FACTORY)))

    registry->priv->typefind_factory_list =

        g_list_sort (registry->priv->typefind_factory_list,

        (GCompareFunc) type_find_factory_rank_cmp);

  /* Return reffed copy */

  list = gst_plugin_feature_list_copy (registry->priv->typefind_factory_list);

  GST_OBJECT_UNLOCK (registry);

  return list;

}

static GList *

gst_registry_get_device_provider_factory_list (GstRegistry * registry)

{

  GList *list;

  GST_OBJECT_LOCK (registry);

  gst_registry_get_feature_list_or_create (registry,

      &registry->priv->device_provider_factory_list,

      &registry->priv->dmfl_cookie, GST_TYPE_DEVICE_PROVIDER_FACTORY);

  /* Return reffed copy */

  list =

      gst_plugin_feature_list_copy (registry->

      priv->device_provider_factory_list);

  GST_OBJECT_UNLOCK (registry);

  return list;

}

/**

 * gst_registry_feature_filter:

 * @registry: registry to query

 * @filter: (scope call): the filter to use

 * @first: only return first match

 * @user_data: (closure): user data passed to the filter function

 *

 * 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).

 *

 * Returns: (transfer full) (element-type Gst.PluginFeature): a #GList of

 *     #GstPluginFeature. Use gst_plugin_feature_list_free() after usage.

 *

 * MT safe.

 */

GList *

gst_registry_feature_filter (GstRegistry * registry,

    GstPluginFeatureFilter filter, gboolean first, gpointer user_data)

{

  GstPluginFeature **features;

  GList *walk, *list = NULL;

  guint n_features, i;

  g_return_val_if_fail (GST_IS_REGISTRY (registry), NULL);

  GST_OBJECT_LOCK (registry);

  n_features = g_hash_table_size (registry->priv->feature_hash);

  features = g_newa (GstPluginFeature *, n_features + 1);

  for (walk = registry->priv->features, i = 0; walk != NULL; walk = walk->next)

    features[i++] = gst_object_ref (walk->data);

  GST_OBJECT_UNLOCK (registry);

  for (i = 0; i < n_features; ++i) {

    if (filter == NULL || filter (features[i], user_data)) {

      list = g_list_prepend (list, gst_object_ref (features[i]));

      if (first)

        break;

    }

  }

  for (i = 0; i < n_features; ++i)

    gst_object_unref (features[i]);

  return list;

}

static gboolean

gst_registry_plugin_name_filter (GstPlugin * plugin, const gchar * name)

{

  return (plugin->desc.name && !strcmp (plugin->desc.name, name));

}

/**

 * gst_registry_find_plugin:

 * @registry: the registry to search

 * @name: the plugin name to find

 *

 * Find the plugin with the given name in the registry.

 * The plugin will be reffed; caller is responsible for unreffing.

 *

 * Returns: (transfer full) (nullable): the plugin with the given name

 *     or %NULL if the plugin was not found. gst_object_unref() after

 *     usage.

 *

 * MT safe.

 */

GstPlugin *