/* GStreamer

 * Copyright (C) 2006 Josep Torra <josep@fluendo.com>

 *               2006 Mathieu Garcia <matthieu@fluendo.com>

 *               2006,2007 Stefan Kost <ensonic@users.sf.net>

 *

 * gstregistrybinary.c: GstRegistryBinary object, support routines

 *

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

 */

/* FIXME:

 * - keep registry binary blob and reference strings

 *     - free at gst_deinit() / _priv_gst_registry_cleanup() ?

 *   - GstPlugin:

 *     - GST_PLUGIN_FLAG_CONST

 *     - needs Flags (GST_PLUGIN_FEATURE_FLAG_CONST)

 *     - can we turn loaded into flag?

 * - why do we collect a list of binary chunks and not write immediately

 *   - because we need to process subchunks, before we can set e.g. nr_of_items

 *     in parent chunk

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <errno.h>

#include <stdio.h>

#if defined (_MSC_VER) && _MSC_VER >= 1400

#include <io.h>

#endif

#include <gst/gst_private.h>

#include <gst/gstconfig.h>

#include <gst/gstelement.h>

#include <gst/gsttypefind.h>

#include <gst/gsttypefindfactory.h>

#include <gst/gsturi.h>

#include <gst/gstinfo.h>

#include <gst/gstenumtypes.h>

#include <gst/gstpadtemplate.h>

#include <gst/gstregistrybinary.h>

#include <glib/gstdio.h>        /* for g_stat(), g_mapped_file(), ... */

#include "glib-compat-private.h"

#define GST_CAT_DEFAULT GST_CAT_REGISTRY

/* Registry saving */

/*

 *

 * Write from a memory location to the registry cache file

 *

 * Returns: %TRUE for success

 */

inline static gboolean

    const gssize size, unsigned long *file_position, gboolean align)

{

  int padsize = 0;

  /* Padding to insert the struct that requiere word alignment */

      GST_ERROR ("Failed to write binary registry padder");

      return FALSE;

    }

  }

    GST_ERROR ("Failed to write binary registry element");

    return FALSE;

  }

  return TRUE;

}

/*

 * gst_registry_binary_initialize_magic:

 *

 * Initialize the GstBinaryRegistryMagic, setting both our magic number and

 * gstreamer major/minor version

 */

inline static gboolean

gst_registry_binary_initialize_magic (GstBinaryRegistryMagic * m)

{

  if (!strncpy (m->magic, GST_MAGIC_BINARY_REGISTRY_STR,

          GST_MAGIC_BINARY_REGISTRY_LEN)

    GST_ERROR ("Failed to write magic to the registry magic structure");

    return FALSE;

  }

  return TRUE;

}

/*

 * gst_registry_binary_save_const_string:

 *

 * Store a const string in a binary chunk.

 *

 * Returns: %TRUE for success

 */

inline static gboolean

gst_registry_binary_save_const_string (GList ** list, const gchar * str)

{

  GstBinaryChunk *chunk;

  chunk = g_malloc (sizeof (GstBinaryChunk));

  chunk->data = (gpointer) str;

  chunk->size = strlen ((gchar *) chunk->data) + 1;

  chunk->flags = GST_BINARY_REGISTRY_FLAG_CONST;

  chunk->align = FALSE;

  *list = g_list_prepend (*list, chunk);

  return TRUE;

}

/*

 * gst_registry_binary_save_string:

 *

 * Store a string in a binary chunk.

 *

 * Returns: %TRUE for success

 */

inline static gboolean

gst_registry_binary_save_string (GList ** list, gchar * str)

{

  GstBinaryChunk *chunk;

  chunk = g_malloc (sizeof (GstBinaryChunk));

  chunk->data = str;

  chunk->size = strlen ((gchar *) chunk->data) + 1;

  chunk->flags = GST_BINARY_REGISTRY_FLAG_NONE;

  chunk->align = FALSE;

  *list = g_list_prepend (*list, chunk);

  return TRUE;

}

/*

 * gst_registry_binary_save_data:

 *

 * Store some data in a binary chunk.

 *

 * Returns: the initialized chunk

 */

inline static GstBinaryChunk *

gst_registry_binary_make_data (gpointer data, gulong size)

{

  GstBinaryChunk *chunk;

  chunk = g_malloc (sizeof (GstBinaryChunk));

  chunk->data = data;

  chunk->size = size;

  chunk->flags = GST_BINARY_REGISTRY_FLAG_NONE;

  chunk->align = TRUE;

  return chunk;

}

/*

 * gst_registry_binary_save_pad_template:

 *

 * Store pad_templates in binary chunks.

 *

 * Returns: %TRUE for success

 */

static gboolean

gst_registry_binary_save_pad_template (GList ** list,

    GstStaticPadTemplate * template)

{

  GstBinaryPadTemplate *pt;

  GstBinaryChunk *chk;

  chk = gst_registry_binary_make_data (pt, sizeof (GstBinaryPadTemplate));

  pt->presence = template->presence;

  pt->direction = template->direction;

  /* pack pad template strings */

  gst_registry_binary_save_const_string (list,

      (gchar *) (template->static_caps.string));

  gst_registry_binary_save_const_string (list, template->name_template);

  *list = g_list_prepend (*list, chk);

  return TRUE;

}

/*

 * gst_registry_binary_save_feature:

 *

 * Store features in binary chunks.

 *

 * Returns: %TRUE for success

 */

static gboolean

gst_registry_binary_save_feature (GList ** list, GstPluginFeature * feature)

{

  const gchar *type_name = g_type_name (G_OBJECT_TYPE (feature));

  GstBinaryPluginFeature *pf = NULL;

  GstBinaryChunk *chk = NULL;

  GList *walk;

  if (!type_name) {

    GST_ERROR ("NULL feature type_name, aborting.");

    return FALSE;

  }

  if (GST_IS_ELEMENT_FACTORY (feature)) {

    GstBinaryElementFactory *ef;

    GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);

    chk = gst_registry_binary_make_data (ef, sizeof (GstBinaryElementFactory));

    ef->npadtemplates = ef->ninterfaces = ef->nuriprotocols = 0;

    pf = (GstBinaryPluginFeature *) ef;

    /* save interfaces */

    for (walk = factory->interfaces; walk;

        walk = g_list_next (walk), ef->ninterfaces++) {

      gst_registry_binary_save_const_string (list, (gchar *) walk->data);

    }

    GST_DEBUG ("Saved %d Interfaces", ef->ninterfaces);

    /* save uritypes */

    if (GST_URI_TYPE_IS_VALID (factory->uri_type)) {

        GstBinaryChunk *subchk;

        gchar **protocol;

        subchk =

            gst_registry_binary_make_data (&factory->uri_type,

            sizeof (factory->uri_type));

        subchk->flags = GST_BINARY_REGISTRY_FLAG_CONST;

        protocol = factory->uri_protocols;

        while (*protocol) {

          gst_registry_binary_save_const_string (list, *protocol++);

          ef->nuriprotocols++;

        }

        *list = g_list_prepend (*list, subchk);

        GST_DEBUG ("Saved %d UriTypes", ef->nuriprotocols);

      } else {

        g_warning ("GStreamer feature '%s' is URI handler but does not provide"

            " any protocols it can handle", feature->name);

      }

    }

    /* save pad-templates */

    for (walk = factory->staticpadtemplates; walk;

        walk = g_list_next (walk), ef->npadtemplates++) {

      GstStaticPadTemplate *template = walk->data;

      if (!gst_registry_binary_save_pad_template (list, template)) {

        GST_ERROR ("Can't fill pad template, aborting.");

        goto fail;

      }

    }

    /* pack element factory strings */

    gst_registry_binary_save_const_string (list, factory->details.author);

    gst_registry_binary_save_const_string (list, factory->details.description);

    gst_registry_binary_save_const_string (list, factory->details.klass);

    gst_registry_binary_save_const_string (list, factory->details.longname);

  } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {

    GstBinaryTypeFindFactory *tff;

    GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);

    chk =

        gst_registry_binary_make_data (tff, sizeof (GstBinaryTypeFindFactory));

    tff->nextensions = 0;

    pf = (GstBinaryPluginFeature *) tff;

    /* save extensions */

    if (factory->extensions) {

      while (factory->extensions[tff->nextensions]) {

        gst_registry_binary_save_const_string (list,

            factory->extensions[tff->nextensions++]);

      }

    }

    /* save caps */

    GstIndexFactory *factory = GST_INDEX_FACTORY (feature);

    chk = gst_registry_binary_make_data (pf, sizeof (GstBinaryPluginFeature));

    pf->rank = feature->rank;

    /* pack element factory strings */

    gst_registry_binary_save_const_string (list, factory->longdesc);

    GST_WARNING ("unhandled feature type '%s'", type_name);

  }

  if (pf) {

    pf->rank = feature->rank;

    *list = g_list_prepend (*list, chk);

    /* pack plugin feature strings */

    gst_registry_binary_save_const_string (list, feature->name);

    gst_registry_binary_save_const_string (list, (gchar *) type_name);

    return TRUE;

  }

  /* Errors */

fail:

  g_free (chk);

  g_free (pf);

  return FALSE;

}

/*

 * gst_registry_binary_save_plugin:

 *

 * Adapt a GstPlugin to our GstBinaryPluginElement structure, and write it to

 * the registry file.

 */

static gboolean

gst_registry_binary_save_plugin (GList ** list, GstRegistry * registry,

    GstPlugin * plugin)

{

  GstBinaryPluginElement *pe;

  GstBinaryChunk *chk;

  GList *plugin_features = NULL;

  GList *walk;

  chk = gst_registry_binary_make_data (pe, sizeof (GstBinaryPluginElement));

  pe->file_size = plugin->file_size;

  pe->file_mtime = plugin->file_mtime;

  pe->nfeatures = 0;

  /* pack plugin features */

  plugin_features =

      gst_registry_get_feature_list_by_plugin (registry, plugin->desc.name);

  for (walk = plugin_features; walk; walk = g_list_next (walk), pe->nfeatures++) {

    GstPluginFeature *feature = GST_PLUGIN_FEATURE (walk->data);

    if (!gst_registry_binary_save_feature (list, feature)) {

      GST_ERROR ("Can't fill plugin feature, aborting.");

      goto fail;

    }

  }

      pe->nfeatures);

  gst_plugin_feature_list_free (plugin_features);

  /* pack plugin element strings */

  gst_registry_binary_save_const_string (list, plugin->desc.origin);

  gst_registry_binary_save_const_string (list, plugin->desc.package);

  gst_registry_binary_save_const_string (list, plugin->desc.source);

  gst_registry_binary_save_const_string (list, plugin->desc.license);

  gst_registry_binary_save_const_string (list, plugin->desc.version);

  gst_registry_binary_save_const_string (list, plugin->filename);

  gst_registry_binary_save_const_string (list, plugin->desc.description);

  gst_registry_binary_save_const_string (list, plugin->desc.name);

  *list = g_list_prepend (*list, chk);

  GST_DEBUG ("Found %d features in plugin \"%s\"", pe->nfeatures,

      plugin->desc.name);

  return TRUE;

  /* Errors */

fail:

  gst_plugin_feature_list_free (plugin_features);

  g_free (chk);

  g_free (pe);

  return FALSE;

}

/**

 * gst_registry_binary_write_cache:

 * @registry: a #GstRegistry

 * @location: a filename

 *

 * Write the @registry to a cache to file at given @location.

 * 

 * Returns: %TRUE on success.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_registry_binary_write_cache (GstRegistry * registry, const char *location)

{

  GList *walk;

  GList *to_write = NULL;

  unsigned long file_position = 0;

  GST_INFO ("Building binary registry cache image");

  g_return_val_if_fail (GST_IS_REGISTRY (registry), FALSE);

    goto fail;

  /* iterate trough the list of plugins and fit them into binary structures */

  for (walk = registry->plugins; walk; walk = g_list_next (walk)) {

    GstPlugin *plugin = GST_PLUGIN (walk->data);

    if (!plugin->filename)

      continue;

    if (plugin->flags & GST_PLUGIN_FLAG_CACHED) {