/* GStreamer

 * Copyright (C) <2003> David A. Schleef <ds@schleef.org>

 *

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

 * to GStreamer

 *

 *

 * Note that operations on the same GstValue (or GValue) from multiple

 * threads may lead to undefined behaviour. 

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <math.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include "gst_private.h"

#include "glib-compat-private.h"

#include <gst/gst.h>

#include <gobject/gvaluecollector.h>

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

typedef struct _GstValueUnionInfo GstValueUnionInfo;

struct _GstValueUnionInfo

{

  GType type1;

  GType type2;

  GstValueUnionFunc func;

};

typedef struct _GstValueIntersectInfo GstValueIntersectInfo;

struct _GstValueIntersectInfo

{

  GType type1;

  GType type2;

  GstValueIntersectFunc func;

};

typedef struct _GstValueSubtractInfo GstValueSubtractInfo;

struct _GstValueSubtractInfo

{

  GType minuend;

  GType subtrahend;

  GstValueSubtractFunc func;

};

static GArray *gst_value_table;

static GArray *gst_value_union_funcs;

static GArray *gst_value_intersect_funcs;

static GArray *gst_value_subtract_funcs;

/* Forward declarations */

static gint gst_greatest_common_divisor (gint a, gint b);

static gchar *gst_value_serialize_fraction (const GValue * value);

static GstValueCompareFunc gst_value_get_compare_func (const GValue * value1);

static gint gst_value_compare_with_func (const GValue * value1,

    const GValue * value2, GstValueCompareFunc compare);

/********

 * list *

 ********/

/* two helper functions to serialize/stringify any type of list

 * regular lists are done with { }, arrays with < >

 */

static gchar *

gst_value_serialize_any_list (const GValue * value, const gchar * begin,

    const gchar * end)

{

  guint i;

  GArray *array = value->data[0].v_pointer;

  GString *s;

  GValue *v;

  gchar *s_val;

  /* estimate minimum string length to minimise re-allocs in GString */

  g_string_append (s, begin);

    v = &g_array_index (array, GValue, i);

    s_val = gst_value_serialize (v);

    g_string_append (s, s_val);

    g_free (s_val);

      g_string_append_len (s, ", ", 2);

    }

  }

  g_string_append (s, end);

  return g_string_free (s, FALSE);

}

static void

gst_value_transform_any_list_string (const GValue * src_value,

    GValue * dest_value, const gchar * begin, const gchar * end)

{

  GValue *list_value;

  GArray *array;

  GString *s;

  guint i;

  gchar *list_s;

  array = src_value->data[0].v_pointer;

  /* estimate minimum string length to minimise re-allocs in GString */

  g_string_append (s, begin);

    list_value = &g_array_index (array, GValue, i);

    if (i != 0) {

      g_string_append_len (s, ", ", 2);

    }

    list_s = g_strdup_value_contents (list_value);

    g_string_append (s, list_s);

    g_free (list_s);

  }

  g_string_append (s, end);

  dest_value->data[0].v_pointer = g_string_free (s, FALSE);

}

/*

 * helper function to see if a type is fixed. Is used internally here and

 * there. Do not export, since it doesn't work for types where the content

 * decides the fixedness (e.g. GST_TYPE_ARRAY).

 */

static gboolean

gst_type_is_fixed (GType type)

{

    return TRUE;

  }

    return TRUE;

  }

  return FALSE;

}

/* GValue functions usable for both regular lists and arrays */

static void

gst_value_init_list_or_array (GValue * value)

{

  value->data[0].v_pointer = g_array_new (FALSE, TRUE, sizeof (GValue));

}

static GArray *

copy_garray_of_gstvalue (const GArray * src)

{

  GArray *dest;

    gst_value_init_and_copy (&g_array_index (dest, GValue, i),

        &g_array_index (src, GValue, i));

  }

  return dest;

}

static void

gst_value_copy_list_or_array (const GValue * src_value, GValue * dest_value)

{

  dest_value->data[0].v_pointer =

      copy_garray_of_gstvalue ((GArray *) src_value->data[0].v_pointer);

}

static void

gst_value_free_list_or_array (GValue * value)

{

  GArray *src = (GArray *) value->data[0].v_pointer;

  if ((value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS) == 0) {

      g_value_unset (&g_array_index (src, GValue, i));

    }

    g_array_free (src, TRUE);

  }

}

static gpointer

gst_value_list_or_array_peek_pointer (const GValue * value)

{

  return value->data[0].v_pointer;

}

static gchar *

gst_value_collect_list_or_array (GValue * value, guint n_collect_values,

    GTypeCValue * collect_values, guint collect_flags)

{

  if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

    value->data[0].v_pointer = collect_values[0].v_pointer;

    value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;

  } else {

    value->data[0].v_pointer =

        copy_garray_of_gstvalue ((GArray *) collect_values[0].v_pointer);

  }

  return NULL;

}

static gchar *

gst_value_lcopy_list_or_array (const GValue * value, guint n_collect_values,

    GTypeCValue * collect_values, guint collect_flags)

{

  GArray **dest = collect_values[0].v_pointer;

  if (!dest)

    return g_strdup_printf ("value location for `%s' passed as NULL",

        G_VALUE_TYPE_NAME (value));

  if (!value->data[0].v_pointer)

    return g_strdup_printf ("invalid value given for `%s'",

        G_VALUE_TYPE_NAME (value));

  if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

    *dest = (GArray *) value->data[0].v_pointer;

  } else {

    *dest = copy_garray_of_gstvalue ((GArray *) value->data[0].v_pointer);

  }

  return NULL;

}

/**

 * gst_value_list_append_value:

 * @value: a #GValue of type #GST_TYPE_LIST

 * @append_value: the value to append

 *

 * Appends @append_value to the GstValueList in @value.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_value_list_append_value (GValue * value, const GValue * append_value)

{

  GValue val = { 0, };

  g_return_if_fail (GST_VALUE_HOLDS_LIST (value));

  gst_value_init_and_copy (&val, append_value);

  g_array_append_vals ((GArray *) value->data[0].v_pointer, &val, 1);

}

/**

 * gst_value_list_prepend_value:

 * @value: a #GValue of type #GST_TYPE_LIST

 * @prepend_value: the value to prepend

 *

 * Prepends @prepend_value to the GstValueList in @value.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_value_list_prepend_value (GValue * value, const GValue * prepend_value)

{

  GValue val = { 0, };

  g_return_if_fail (GST_VALUE_HOLDS_LIST (value));

  gst_value_init_and_copy (&val, prepend_value);

  g_array_prepend_vals ((GArray *) value->data[0].v_pointer, &val, 1);

}

/**

 * gst_value_list_concat:

 * @dest: an uninitialized #GValue to take the result

 * @value1: a #GValue

 * @value2: a #GValue

 *

 * Concatenates copies of @value1 and @value2 into a list.  Values that are not

 * of type #GST_TYPE_LIST are treated as if they were lists of length 1.

 * @dest will be initialized to the type #GST_TYPE_LIST.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_value_list_concat (GValue * dest, const GValue * value1,

    const GValue * value2)

{

  guint i, value1_length, value2_length;

  GArray *array;

  g_return_if_fail (dest != NULL);

  g_return_if_fail (G_VALUE_TYPE (dest) == 0);

  g_return_if_fail (G_IS_VALUE (value1));

  g_return_if_fail (G_IS_VALUE (value2));

  value1_length =

      (GST_VALUE_HOLDS_LIST (value1) ? gst_value_list_get_size (value1) : 1);

  value2_length =

      (GST_VALUE_HOLDS_LIST (value2) ? gst_value_list_get_size (value2) : 1);

  g_value_init (dest, GST_TYPE_LIST);

  array = (GArray *) dest->data[0].v_pointer;

  g_array_set_size (array, value1_length + value2_length);

  if (GST_VALUE_HOLDS_LIST (value1)) {

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

      gst_value_init_and_copy (&g_array_index (array, GValue, i),

          gst_value_list_get_value (value1, i));

    }

  } else {

    gst_value_init_and_copy (&g_array_index (array, GValue, 0), value1);

  }

  if (GST_VALUE_HOLDS_LIST (value2)) {

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

      gst_value_init_and_copy (&g_array_index (array, GValue,

              i + value1_length), gst_value_list_get_value (value2, i));

    }

  } else {

    gst_value_init_and_copy (&g_array_index (array, GValue, value1_length),

        value2);

  }

}

/**

 * gst_value_list_get_size:

 * @value: a #GValue of type #GST_TYPE_LIST

 *

 * Gets the number of values contained in @value.

 *

 * Returns: the number of values

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

guint

gst_value_list_get_size (const GValue * value)

{

  g_return_val_if_fail (GST_VALUE_HOLDS_LIST (value), 0);

  return ((GArray *) value->data[0].v_pointer)->len;

}

/**

 * gst_value_list_get_value:

 * @value: a #GValue of type #GST_TYPE_LIST

 * @index: index of value to get from the list

 *

 * Gets the value that is a member of the list contained in @value and

 * has the index @index.

 *

 * Returns: the value at the given index

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

const GValue *

gst_value_list_get_value (const GValue * value, guint index)

{

  g_return_val_if_fail (GST_VALUE_HOLDS_LIST (value), NULL);

  g_return_val_if_fail (index < gst_value_list_get_size (value), NULL);

  return (const GValue *) &g_array_index ((GArray *) value->data[0].v_pointer,

      GValue, index);

}

/**

 * gst_value_array_append_value:

 * @value: a #GValue of type #GST_TYPE_ARRAY

 * @append_value: the value to append

 *

 * Appends @append_value to the GstValueArray in @value.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_value_array_append_value (GValue * value, const GValue * append_value)

{

  GValue val = { 0, };

  g_return_if_fail (GST_VALUE_HOLDS_ARRAY (value));

  gst_value_init_and_copy (&val, append_value);

  g_array_append_vals ((GArray *) value->data[0].v_pointer, &val, 1);

}

/**

 * gst_value_array_prepend_value:

 * @value: a #GValue of type #GST_TYPE_ARRAY

 * @prepend_value: the value to prepend

 *

 * Prepends @prepend_value to the GstValueArray in @value.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_value_array_prepend_value (GValue * value, const GValue * prepend_value)

{

  GValue val = { 0, };

  g_return_if_fail (GST_VALUE_HOLDS_ARRAY (value));

  gst_value_init_and_copy (&val, prepend_value);

  g_array_prepend_vals ((GArray *) value->data[0].v_pointer, &val, 1);

}

/**

 * gst_value_array_get_size:

 * @value: a #GValue of type #GST_TYPE_ARRAY

 *

 * Gets the number of values contained in @value.

 *

 * Returns: the number of values

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

guint

gst_value_array_get_size (const GValue * value)

{

  g_return_val_if_fail (GST_VALUE_HOLDS_ARRAY (value), 0);

  return ((GArray *) value->data[0].v_pointer)->len;

}

/**

 * gst_value_array_get_value:

 * @value: a #GValue of type #GST_TYPE_ARRAY

 * @index: index of value to get from the array

 *

 * Gets the value that is a member of the array contained in @value and

 * has the index @index.

 *

 * Returns: the value at the given index

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

const GValue *

gst_value_array_get_value (const GValue * value, guint index)

{

  g_return_val_if_fail (GST_VALUE_HOLDS_ARRAY (value), NULL);

  g_return_val_if_fail (index < gst_value_array_get_size (value), NULL);

  return (const GValue *) &g_array_index ((GArray *) value->data[0].v_pointer,

      GValue, index);

}

static void

gst_value_transform_list_string (const GValue * src_value, GValue * dest_value)

{

  gst_value_transform_any_list_string (src_value, dest_value, "{ ", " }");

}

static void

gst_value_transform_array_string (const GValue * src_value, GValue * dest_value)

{

  gst_value_transform_any_list_string (src_value, dest_value, "< ", " >");

}

/* Do an unordered compare of the contents of a list */

static int

gst_value_compare_list (const GValue * value1, const GValue * value2)

{

  guint i, j;

  GArray *array1 = value1->data[0].v_pointer;

  GArray *array2 = value2->data[0].v_pointer;

  GValue *v1;

  GValue *v2;

  gint len, to_remove;

  guint8 *removed;

  GstValueCompareFunc compare;

  /* get length and do initial length check. */

  len = array1->len;

  if (len != array2->len)

    return GST_VALUE_UNORDERED;

  /* place to mark removed value indices of array2 */

  removed = g_newa (guint8, len);

  memset (removed, 0, len);

  to_remove = len;

  /* loop over array1, all items should be in array2. When we find an

   * item in array2, remove it from array2 by marking it as removed */