/* GStreamer TagXmpWriter

 * Copyright (C) 2010 Thiago Santos <thiago.sousa.santos@collabora.co.uk>

 *

 * 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:gsttagxmpwriter

 * @title: GstTagXmpWriter

 * @short_description: Interface for elements that provide XMP serialization

 *

 * This interface is implemented by elements that are able to do XMP serialization. Examples for

 * such elements are #jifmux and #qtmux.

 *

 * Applications can use this interface to configure which XMP schemas should be used when serializing

 * tags into XMP. Schemas are represented by their names, a full list of the supported schemas can be

 * obtained from gst_tag_xmp_list_schemas(). By default, all schemas are used.

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "xmpwriter.h"

#include <string.h>

#include <gst/tag/tag.h>

static GQuark tag_xmp_writer_key;

typedef struct

{

  GSList *schemas;

  GMutex lock;

} GstTagXmpWriterData;

#define GST_TAG_XMP_WRITER_DATA_LOCK(data) g_mutex_lock(&data->lock)

#define GST_TAG_XMP_WRITER_DATA_UNLOCK(data) g_mutex_unlock(&data->lock)

GType

gst_tag_xmp_writer_get_type (void)

{

  static volatile gsize xmp_config_type = 0;

  if (g_once_init_enter (&xmp_config_type)) {

    GType _type;

    static const GTypeInfo xmp_config_info = {

      sizeof (GstTagXmpWriterInterface),        /* class_size */

      NULL,                     /* base_init */

      NULL,                     /* base_finalize */

      NULL,

      NULL,                     /* class_finalize */

      NULL,                     /* class_data */

      0,

      0,

      NULL

    };

    _type = g_type_register_static (G_TYPE_INTERFACE, "GstTagXmpWriter",

        &xmp_config_info, 0);

    tag_xmp_writer_key = g_quark_from_static_string ("GST_TAG_XMP_WRITER");

    g_type_interface_add_prerequisite (_type, GST_TYPE_ELEMENT);

    g_once_init_leave (&xmp_config_type, _type);

  }

  return xmp_config_type;

}

static void

gst_tag_xmp_writer_data_add_schema_unlocked (GstTagXmpWriterData * data,

    const gchar * schema)

{

  if (!g_slist_find_custom (data->schemas, schema, (GCompareFunc) strcmp)) {

    data->schemas = g_slist_prepend (data->schemas, g_strdup (schema));

  }

}

static void

gst_tag_xmp_writer_data_add_all_schemas_unlocked (GstTagXmpWriterData * data)

{

  const gchar **schemas;

  gint i = 0;

  /* initialize it with all schemas */

  schemas = gst_tag_xmp_list_schemas ();

  while (schemas[i] != NULL) {

    gst_tag_xmp_writer_data_add_schema_unlocked (data, schemas[i]);

    i++;

  }

}

static void

gst_tag_xmp_writer_data_free (gpointer p)

{

  GstTagXmpWriterData *data = (GstTagXmpWriterData *) p;

  GSList *iter;

  if (data->schemas) {

    for (iter = data->schemas; iter; iter = g_slist_next (iter)) {

      g_free (iter->data);

    }

    g_slist_free (data->schemas);

  }

  g_mutex_clear (&data->lock);

  g_slice_free (GstTagXmpWriterData, data);

}

static GstTagXmpWriterData *

gst_tag_xmp_writer_get_data (GstTagXmpWriter * xmpconfig)

{

  GstTagXmpWriterData *data;

  data = g_object_get_qdata (G_OBJECT (xmpconfig), tag_xmp_writer_key);

  if (!data) {

    /* make sure no other thread is creating a GstTagData at the same time */

    static GMutex create_mutex; /* no initialisation required */

    g_mutex_lock (&create_mutex);

    data = g_object_get_qdata (G_OBJECT (xmpconfig), tag_xmp_writer_key);

    if (!data) {

      data = g_slice_new (GstTagXmpWriterData);

      g_mutex_init (&data->lock);

      data->schemas = NULL;

      gst_tag_xmp_writer_data_add_all_schemas_unlocked (data);

      g_object_set_qdata_full (G_OBJECT (xmpconfig), tag_xmp_writer_key, data,

          gst_tag_xmp_writer_data_free);

    }

    g_mutex_unlock (&create_mutex);

  }

  return data;

}

/**

 * gst_tag_xmp_writer_add_all_schemas:

 * @config: a #GstTagXmpWriter

 *

 * Adds all available XMP schemas to the configuration. Meaning that

 * all will be used.

 */

void

gst_tag_xmp_writer_add_all_schemas (GstTagXmpWriter * config)

{

  GstTagXmpWriterData *data;

  g_return_if_fail (GST_IS_TAG_XMP_WRITER (config));

  data = gst_tag_xmp_writer_get_data (config);

  GST_TAG_XMP_WRITER_DATA_LOCK (data);

  gst_tag_xmp_writer_data_add_all_schemas_unlocked (data);

  GST_TAG_XMP_WRITER_DATA_UNLOCK (data);

}

/**

 * gst_tag_xmp_writer_add_schema:

 * @config: a #GstTagXmpWriter

 * @schema: the schema to be added

 *

 * Adds @schema to the list schemas

 */

void

gst_tag_xmp_writer_add_schema (GstTagXmpWriter * config, const gchar * schema)

{

  GstTagXmpWriterData *data;

  g_return_if_fail (GST_IS_TAG_XMP_WRITER (config));

  data = gst_tag_xmp_writer_get_data (config);

  GST_TAG_XMP_WRITER_DATA_LOCK (data);

  gst_tag_xmp_writer_data_add_schema_unlocked (data, schema);

  GST_TAG_XMP_WRITER_DATA_UNLOCK (data);

}

/**

 * gst_tag_xmp_writer_has_schema:

 * @config: a #GstTagXmpWriter

 * @schema: the schema to test

 *

 * Checks if @schema is going to be used

 *

 * Returns: %TRUE if it is going to be used

 */

gboolean

gst_tag_xmp_writer_has_schema (GstTagXmpWriter * config, const gchar * schema)

{

  GstTagXmpWriterData *data;

  gboolean ret = FALSE;

  GSList *iter;

  g_return_val_if_fail (GST_IS_TAG_XMP_WRITER (config), FALSE);

  data = gst_tag_xmp_writer_get_data (config);

  GST_TAG_XMP_WRITER_DATA_LOCK (data);

  for (iter = data->schemas; iter; iter = g_slist_next (iter)) {

    if (strcmp ((const gchar *) iter->data, schema) == 0) {

      ret = TRUE;

      break;

    }

  }

  GST_TAG_XMP_WRITER_DATA_UNLOCK (data);

  return ret;

}

/**

 * gst_tag_xmp_writer_remove_schema:

 * @config: a #GstTagXmpWriter

 * @schema: the schema to remove

 *

 * Removes a schema from the list of schemas to use. Nothing is done if

 * the schema wasn't in the list

 */

void

gst_tag_xmp_writer_remove_schema (GstTagXmpWriter * config,

    const gchar * schema)

{

  GstTagXmpWriterData *data;

  GSList *iter = NULL;

  g_return_if_fail (GST_IS_TAG_XMP_WRITER (config));

  data = gst_tag_xmp_writer_get_data (config);

  GST_TAG_XMP_WRITER_DATA_LOCK (data);

  for (iter = data->schemas; iter; iter = g_slist_next (iter)) {

    if (strcmp ((const gchar *) iter->data, schema) == 0) {

      g_free (iter->data);

      data->schemas = g_slist_delete_link (data->schemas, iter);

      break;

    }

  }

  GST_TAG_XMP_WRITER_DATA_UNLOCK (data);

}

/**

 * gst_tag_xmp_writer_remove_all_schemas:

 * @config: a #GstTagXmpWriter

 *

 * Removes all schemas from the list of schemas to use. Meaning that no

 * XMP will be generated.

 */

void

gst_tag_xmp_writer_remove_all_schemas (GstTagXmpWriter * config)

{

  GstTagXmpWriterData *data;

  GSList *iter;

  g_return_if_fail (GST_IS_TAG_XMP_WRITER (config));

  data = gst_tag_xmp_writer_get_data (config);

  GST_TAG_XMP_WRITER_DATA_LOCK (data);

  if (data->schemas) {

    for (iter = data->schemas; iter; iter = g_slist_next (iter)) {

      g_free (iter->data);

    }

    g_slist_free (data->schemas);

  }

  data->schemas = NULL;

  GST_TAG_XMP_WRITER_DATA_UNLOCK (data);

}

GstBuffer *

gst_tag_xmp_writer_tag_list_to_xmp_buffer (GstTagXmpWriter * config,

    const GstTagList * taglist, gboolean read_only)

{

  GstTagXmpWriterData *data;

  GstBuffer *buf = NULL;

  gint i = 0;

  GSList *iter;

  g_return_val_if_fail (GST_IS_TAG_XMP_WRITER (config), NULL);

  data = gst_tag_xmp_writer_get_data (config);

  GST_TAG_XMP_WRITER_DATA_LOCK (data);

  if (data->schemas) {

    gchar **array = g_new0 (gchar *, g_slist_length (data->schemas) + 1);

    if (array) {

      for (iter = data->schemas; iter; iter = g_slist_next (iter)) {

        array[i++] = (gchar *) iter->data;

      }

      buf = gst_tag_list_to_xmp_buffer (taglist, read_only,

          (const gchar **) array);

      g_free (array);

    }

  }

  GST_TAG_XMP_WRITER_DATA_UNLOCK (data);

  return buf;

}