/* 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

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

 * All registries build the #GstRegistryPool.

 *

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

 *

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

 * with them. #GstPlugins are matched 1-1 with a file on disk, and may or may

 * not be loaded at a given time. There may be multiple #GstRegistry objects,

 * but the "default registry" is the only object that has any meaning to the

 * core.

 *

 * The registry.xml file is actually a cache of plugin information. This is

 * unlike versions prior to 0.10, where the registry file was the primary source

 * of plugin information, and was created by the gst-register command.

 *

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

 *

 * On startup, plugins are searched for in the plugin search path. This path can

 * be set directly using the %GST_PLUGIN_PATH environment variable. The registry

 * file is loaded from ~/.gstreamer-$GST_MAJORMINOR/registry-$ARCH.xml or the

 * file listed in the %GST_REGISTRY env var. The only 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:

 * <itemizedlist>

 *   <listitem>

 *     <para>the cache may not contain information about a given file.</para>

 *   </listitem>

 *   <listitem>

 *     <para>the cache may have stale information.</para>

 *   </listitem>

 *   <listitem>

 *     <para>the cache may have current information.</para>

 *   </listitem>

 * </itemizedlist>

 *

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

 *

 * <emphasis role="bold">Implementation notes:</emphasis>

 *

 * The "cache" and "default 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 intitialization.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#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>

#include "gstinfo.h"

#include "gstregistry.h"

#include "gstmarshal.h"

#include "gstfilter.h"

#ifdef __SYMBIAN32__

#include <glib_global.h>

#include "helpfile.h" 

#endif

#define GST_CAT_DEFAULT GST_CAT_REGISTRY

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

 * variable. */

static GStaticMutex _gst_registry_mutex = G_STATIC_MUTEX_INIT;

static GstRegistry *_gst_registry_default = NULL;

/* 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_locked (GstRegistry * registry,

    const char *filename);

G_DEFINE_TYPE (GstRegistry, gst_registry, GST_TYPE_OBJECT);

static GstObjectClass *parent_class = NULL;

static void

gst_registry_class_init (GstRegistryClass * klass)

{

  GObjectClass *gobject_class;

  gobject_class = (GObjectClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  /**

   * 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, G_STRUCT_OFFSET (GstRegistryClass, plugin_added), NULL,

      NULL, gst_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER);

  /**

   * 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, G_STRUCT_OFFSET (GstRegistryClass, feature_added),

      NULL, NULL, gst_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER);

  gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_registry_finalize);

}

static void

gst_registry_init (GstRegistry * registry)

{

  registry->feature_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->plugins;

  registry->plugins = NULL;

  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->features;

  registry->features = NULL;

  f = features;

  while (f) {

    GstPluginFeature *feature = f->data;

    if (feature) {

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

          feature, gst_plugin_feature_get_name (feature));

      gst_object_unref (feature);

    }

    f = g_list_next (f);

  }

  g_list_free (features);

  g_hash_table_destroy (registry->feature_hash);

  registry->feature_hash = NULL;

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

/**

 * gst_registry_get_default:

 *

 * Retrieves the default registry. The caller does not own a reference on the

 * registry, as it is alive as long as GStreamer is initialized.

 *

 * Returns: The default #GstRegistry.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstRegistry *

gst_registry_get_default (void)

{

  GstRegistry *registry;

  g_static_mutex_lock (&_gst_registry_mutex);

  if (G_UNLIKELY (!_gst_registry_default)) {

    _gst_registry_default = g_object_new (GST_TYPE_REGISTRY, NULL);

    gst_object_ref (GST_OBJECT_CAST (_gst_registry_default));

    gst_object_sink (GST_OBJECT_CAST (_gst_registry_default));

  }

  registry = _gst_registry_default;

  g_static_mutex_unlock (&_gst_registry_mutex);

  return registry;

}

/**

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

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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->paths, path, (GCompareFunc) strcmp))

    goto was_added;

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

  registry->paths = g_list_append (registry->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: A Glist of paths as strings. g_list_free after use.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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->paths);

  GST_OBJECT_UNLOCK (registry);

  return list;

}

/**

 * gst_registry_add_plugin:

 * @registry: the registry to add the plugin to

 * @plugin: the plugin to add

 *

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

 * This function will sink @plugin.

 *

 * Returns: TRUE on success.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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);

  existing_plugin = gst_registry_lookup_locked (registry, plugin->filename);

  if (G_UNLIKELY (existing_plugin)) {

    GST_DEBUG_OBJECT (registry,

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

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

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

    gst_object_unref (existing_plugin);

  }

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

      plugin, GST_STR_NULL (plugin->filename));

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

  gst_object_ref (plugin);

  gst_object_sink (plugin);

  GST_OBJECT_UNLOCK (registry);

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

      GST_STR_NULL (plugin->filename));

  g_signal_emit (G_OBJECT (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->features;

  while (f != NULL) {

    GList *next = g_list_next (f);

    GstPluginFeature *feature = f->data;

    if (feature && !strcmp (feature->plugin_name, gst_plugin_get_name (plugin))) {

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

          feature, gst_plugin_feature_get_name (feature),

          gst_plugin_get_name (plugin));

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

      g_hash_table_remove (registry->feature_hash, feature->name);

      gst_object_unref (feature);

    }

    f = next;

  }

}

/**

 * gst_registry_remove_plugin:

 * @registry: the registry to remove the plugin from

 * @plugin: the plugin to remove

 *

 * Remove the plugin from the registry.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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->plugins = g_list_remove (registry->plugins, plugin);

  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: the feature to add

 *

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

 * This function sinks @feature.

 *

 * Returns: TRUE on success.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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 (feature->name != NULL, FALSE);

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

  GST_OBJECT_LOCK (registry);

  existing_feature = gst_registry_lookup_feature_locked (registry,

      feature->name);

  if (G_UNLIKELY (existing_feature)) {

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

        existing_feature, feature->name);

    /* 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->features = g_list_remove (registry->features, existing_feature);

  }

  GST_DEBUG_OBJECT (registry, "adding feature %p (%s)", feature, feature->name);

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

  g_hash_table_replace (registry->feature_hash, feature->name, 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_unref (existing_feature);

  }

  gst_object_ref (feature);

  gst_object_sink (feature);

  GST_OBJECT_UNLOCK (registry);

  GST_LOG_OBJECT (registry, "emitting feature-added for %s", feature->name);

  g_signal_emit (G_OBJECT (registry), gst_registry_signals[FEATURE_ADDED], 0,

      feature);

  return TRUE;

}

/**

 * gst_registry_remove_feature:

 * @registry: the registry to remove the feature from

 * @feature: the feature to remove

 *

 * Remove the feature from the registry.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

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->features = g_list_remove (registry->features, feature);

  g_hash_table_remove (registry->feature_hash, feature->name);

  GST_OBJECT_UNLOCK (registry);