mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-25 09:40:37 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/gstvalue.c
Tim-Philipp Müller 5a6be2201d datetime: fix compare function 
Take into account that not all fields might be valid (though they
are valid in the GDateTime structure). But we should just return
unordered if the set fields don't match. Also, don't check
microseconds when comparing datetimes, since we don't serialise
those by default if they're available. This ensures date times are
still regarded as equal after serialising+deserialising.
2012-06-27 13:51:33 +01:00

6011 lines
166 KiB
C
Raw Blame History

/* 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
* @short_description: GValue implementations specific
* to GStreamer
*
* GValue implementations specific to GStreamer.
*
* Note that operations on the same #GValue from multiple threads may lead to
* undefined behaviour.
*
* Last reviewed on 2008-03-11 (0.10.18)
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <math.h>
#include <stdio.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>
#include "gstutils.h"
/* GstValueUnionFunc:
* @dest: a #GValue for the result
* @value1: a #GValue operand
* @value2: a #GValue operand
*
* Used by gst_value_union() to perform unification for a specific #GValue
* type. Register a new implementation with gst_value_register_union_func().
*
* Returns: %TRUE if a union was successful
*/
typedef gboolean (*GstValueUnionFunc) (GValue * dest,
const GValue * value1, const GValue * value2);
/* GstValueIntersectFunc:
* @dest: (out caller-allocates): a #GValue for the result
* @value1: a #GValue operand
* @value2: a #GValue operand
*
* Used by gst_value_intersect() to perform intersection for a specific #GValue
* type. If the intersection is non-empty, the result is
* placed in @dest and TRUE is returned. If the intersection is
* empty, @dest is unmodified and FALSE is returned.
* Register a new implementation with gst_value_register_intersect_func().
*
* Returns: %TRUE if the values can intersect
*/
typedef gboolean (*GstValueIntersectFunc) (GValue * dest,
const GValue * value1, const GValue * value2);
/* GstValueSubtractFunc:
* @dest: (out caller-allocates): a #GValue for the result
* @minuend: a #GValue operand
* @subtrahend: a #GValue operand
*
* Used by gst_value_subtract() to perform subtraction for a specific #GValue
* type. Register a new implementation with gst_value_register_subtract_func().
*
* Returns: %TRUE if the subtraction is not empty
*/
typedef gboolean (*GstValueSubtractFunc) (GValue * dest,
const GValue * minuend, const GValue * subtrahend);
static void gst_value_register_union_func (GType type1,
GType type2, GstValueUnionFunc func);
static void gst_value_register_intersect_func (GType type1,
GType type2, GstValueIntersectFunc func);
static void gst_value_register_subtract_func (GType minuend_type,
GType subtrahend_type, GstValueSubtractFunc func);
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;
};
#define FUNDAMENTAL_TYPE_ID_MAX \
(G_TYPE_FUNDAMENTAL_MAX >> G_TYPE_FUNDAMENTAL_SHIFT)
#define FUNDAMENTAL_TYPE_ID(type) \
((type) >> G_TYPE_FUNDAMENTAL_SHIFT)
#define VALUE_LIST_SIZE(v) (((GArray *) (v)->data[0].v_pointer)->len)
#define VALUE_LIST_GET_VALUE(v, index) ((const GValue *) &g_array_index ((GArray *) (v)->data[0].v_pointer, GValue, (index)))
static GArray *gst_value_table;
static GHashTable *gst_value_hash;
static GstValueTable *gst_value_tables_fundamental[FUNDAMENTAL_TYPE_ID_MAX + 1];
static GArray *gst_value_union_funcs;
static GArray *gst_value_intersect_funcs;
static GArray *gst_value_subtract_funcs;
/* Forward declarations */
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);
static gchar *gst_string_wrap (const gchar * s);
static gchar *gst_string_take_and_wrap (gchar * s);
static gchar *gst_string_unwrap (const gchar * s);
static inline GstValueTable *
gst_value_hash_lookup_type (GType type)
{
if (G_LIKELY (G_TYPE_IS_FUNDAMENTAL (type)))
return gst_value_tables_fundamental[FUNDAMENTAL_TYPE_ID (type)];
else
return g_hash_table_lookup (gst_value_hash, (gpointer) type);
}
static void
gst_value_hash_add_type (GType type, const GstValueTable * table)
{
if (G_TYPE_IS_FUNDAMENTAL (type))
gst_value_tables_fundamental[FUNDAMENTAL_TYPE_ID (type)] = (gpointer) table;
g_hash_table_insert (gst_value_hash, (gpointer) type, (gpointer) table);
}
/********
* 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;
guint alen = array->len;
/* estimate minimum string length to minimise re-allocs in GString */
s = g_string_sized_new (2 + (6 * alen) + 2);
g_string_append (s, begin);
for (i = 0; i < alen; i++) {
v = &g_array_index (array, GValue, i);
s_val = gst_value_serialize (v);
g_string_append (s, s_val);
g_free (s_val);
if (i < alen - 1) {
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;
guint alen;
array = src_value->data[0].v_pointer;
alen = array->len;
/* estimate minimum string length to minimise re-allocs in GString */
s = g_string_sized_new (2 + (10 * alen) + 2);
g_string_append (s, begin);
for (i = 0; i < alen; i++) {
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)
{
/* the basic int, string, double types */
if (type <= G_TYPE_MAKE_FUNDAMENTAL (G_TYPE_RESERVED_GLIB_LAST)) {
return TRUE;
}
/* our fundamental types that are certainly not fixed */
if (type == GST_TYPE_INT_RANGE || type == GST_TYPE_DOUBLE_RANGE ||
type == GST_TYPE_INT64_RANGE ||
type == GST_TYPE_LIST || type == GST_TYPE_FRACTION_RANGE) {
return FALSE;
}
/* other (boxed) types that are fixed */
if (type == GST_TYPE_BUFFER) {
return TRUE;
}
/* heavy checks */
if (G_TYPE_IS_FUNDAMENTAL (type) || G_TYPE_FUNDAMENTAL (type) <=
G_TYPE_MAKE_FUNDAMENTAL (G_TYPE_RESERVED_GLIB_LAST)) {
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;
guint i, len;
len = src->len;
dest = g_array_sized_new (FALSE, TRUE, sizeof (GValue), len);
g_array_set_size (dest, len);
for (i = 0; i < len; i++) {
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)
{
guint i, len;
GArray *src = (GArray *) value->data[0].v_pointer;
len = src->len;
if ((value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS) == 0) {
for (i = 0; i < len; i++) {
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;
}
static gboolean
gst_value_list_or_array_get_basic_type (const GValue * value, GType * type)
{
if (G_UNLIKELY (value == NULL))
return FALSE;
if (GST_VALUE_HOLDS_LIST (value)) {
if (VALUE_LIST_SIZE (value) == 0)
return FALSE;
return gst_value_list_or_array_get_basic_type (VALUE_LIST_GET_VALUE (value,
0), type);
}
if (GST_VALUE_HOLDS_ARRAY (value)) {
const GArray *array = (const GArray *) value->data[0].v_pointer;
if (array->len == 0)
return FALSE;
return gst_value_list_or_array_get_basic_type (&g_array_index (array,
GValue, 0), type);
}
*type = G_VALUE_TYPE (value);
return TRUE;
}
#define IS_RANGE_COMPAT(type1,type2,t1,t2) \
(((t1) == (type1) && (t2) == (type2)) || ((t2) == (type1) && (t1) == (type2)))
static gboolean
gst_value_list_or_array_are_compatible (const GValue * value1,
const GValue * value2)
{
GType basic_type1, basic_type2;
/* empty or same type is OK */
if (!gst_value_list_or_array_get_basic_type (value1, &basic_type1) ||
!gst_value_list_or_array_get_basic_type (value2, &basic_type2) ||
basic_type1 == basic_type2)
return TRUE;
/* ranges are distinct types for each bound type... */
if (IS_RANGE_COMPAT (G_TYPE_INT, GST_TYPE_INT_RANGE, basic_type1,
basic_type2))
return TRUE;
if (IS_RANGE_COMPAT (G_TYPE_INT64, GST_TYPE_INT64_RANGE, basic_type1,
basic_type2))
return TRUE;
if (IS_RANGE_COMPAT (G_TYPE_DOUBLE, GST_TYPE_DOUBLE_RANGE, basic_type1,
basic_type2))
return TRUE;
if (IS_RANGE_COMPAT (GST_TYPE_FRACTION, GST_TYPE_FRACTION_RANGE, basic_type1,
basic_type2))
return TRUE;
return FALSE;
}
/**
* 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.
*/
void
gst_value_list_append_value (GValue * value, const GValue * append_value)
{
GValue val = { 0, };
g_return_if_fail (GST_VALUE_HOLDS_LIST (value));
g_return_if_fail (G_IS_VALUE (append_value));
g_return_if_fail (gst_value_list_or_array_are_compatible (value,
append_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.
*/
void
gst_value_list_prepend_value (GValue * value, const GValue * prepend_value)
{
GValue val = { 0, };
g_return_if_fail (GST_VALUE_HOLDS_LIST (value));
g_return_if_fail (G_IS_VALUE (prepend_value));
g_return_if_fail (gst_value_list_or_array_are_compatible (value,
prepend_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: (out caller-allocates): 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.
*/
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));
g_return_if_fail (gst_value_list_or_array_are_compatible (value1, value2));
value1_length =
(GST_VALUE_HOLDS_LIST (value1) ? VALUE_LIST_SIZE (value1) : 1);
value2_length =
(GST_VALUE_HOLDS_LIST (value2) ? VALUE_LIST_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),
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), VALUE_LIST_GET_VALUE (value2, i));
}
} else {
gst_value_init_and_copy (&g_array_index (array, GValue, value1_length),
value2);
}
}
/**
* gst_value_list_merge:
* @dest: (out caller-allocates): an uninitialized #GValue to take the result
* @value1: a #GValue
* @value2: a #GValue
*
* Merges copies of @value1 and @value2. Values that are not
* of type #GST_TYPE_LIST are treated as if they were lists of length 1.
*
* The result will be put into @dest and will either be a list that will not
* contain any duplicates, or a non-list type (if @value1 and @value2
* were equal).
*
* Since: 0.10.32
*/
void
gst_value_list_merge (GValue * dest, const GValue * value1,
const GValue * value2)
{
guint i, j, k, value1_length, value2_length, skipped;
const GValue *src;
gboolean skip;
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));
g_return_if_fail (gst_value_list_or_array_are_compatible (value1, value2));
value1_length =
(GST_VALUE_HOLDS_LIST (value1) ? VALUE_LIST_SIZE (value1) : 1);
value2_length =
(GST_VALUE_HOLDS_LIST (value2) ? VALUE_LIST_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),
VALUE_LIST_GET_VALUE (value1, i));
}
} else {
gst_value_init_and_copy (&g_array_index (array, GValue, 0), value1);
}
j = value1_length;
skipped = 0;
if (GST_VALUE_HOLDS_LIST (value2)) {
for (i = 0; i < value2_length; i++) {
skip = FALSE;
src = VALUE_LIST_GET_VALUE (value2, i);
for (k = 0; k < value1_length; k++) {
if (gst_value_compare (&g_array_index (array, GValue, k),
src) == GST_VALUE_EQUAL) {
skip = TRUE;
skipped++;
break;
}
}
if (!skip) {
gst_value_init_and_copy (&g_array_index (array, GValue, j), src);
j++;
}
}
} else {
skip = FALSE;
for (k = 0; k < value1_length; k++) {
if (gst_value_compare (&g_array_index (array, GValue, k),
value2) == GST_VALUE_EQUAL) {
skip = TRUE;
skipped++;
break;
}
}
if (!skip) {
gst_value_init_and_copy (&g_array_index (array, GValue, j), value2);
}
}
if (skipped) {
guint new_size = value1_length + (value2_length - skipped);
if (new_size > 1) {
/* shrink list */
g_array_set_size (array, new_size);
} else {
GValue single_dest;
/* size is 1, take single value in list and make it new dest */
single_dest = g_array_index (array, GValue, 0);
/* clean up old value allocations: must set array size to 0, because
* allocated values are not inited meaning g_value_unset() will not
* work on them */
g_array_set_size (array, 0);
g_value_unset (dest);
/* the single value is our new result */
*dest = single_dest;
}
}
}
/**
* 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
*/
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: (transfer none): the value at the given index
*/
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 < VALUE_LIST_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.
*/
void
gst_value_array_append_value (GValue * value, const GValue * append_value)
{
GValue val = { 0, };
g_return_if_fail (GST_VALUE_HOLDS_ARRAY (value));
g_return_if_fail (G_IS_VALUE (append_value));
g_return_if_fail (gst_value_list_or_array_are_compatible (value,
append_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.
*/
void
gst_value_array_prepend_value (GValue * value, const GValue * prepend_value)
{
GValue val = { 0, };
g_return_if_fail (GST_VALUE_HOLDS_ARRAY (value));
g_return_if_fail (G_IS_VALUE (prepend_value));
g_return_if_fail (gst_value_list_or_array_are_compatible (value,
prepend_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
*/
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: (transfer none): the value at the given index
*/
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 gint
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 */
for (i = 0; i < len; i++) {
v1 = &g_array_index (array1, GValue, i);
if ((compare = gst_value_get_compare_func (v1))) {
for (j = 0; j < len; j++) {
/* item is removed, we can skip it */
if (removed[j])
continue;
v2 = &g_array_index (array2, GValue, j);
if (gst_value_compare_with_func (v1, v2, compare) == GST_VALUE_EQUAL) {
/* mark item as removed now that we found it in array2 and
* decrement the number of remaining items in array2. */
removed[j] = 1;
to_remove--;
break;
}
}
/* item in array1 and not in array2, UNORDERED */
if (j == len)
return GST_VALUE_UNORDERED;
} else
return GST_VALUE_UNORDERED;
}
/* if not all items were removed, array2 contained something not in array1 */
if (to_remove != 0)
return GST_VALUE_UNORDERED;
/* arrays are equal */
return GST_VALUE_EQUAL;
}
/* Perform an ordered comparison of the contents of an array */
static gint
gst_value_compare_array (const GValue * value1, const GValue * value2)
{
guint i;
GArray *array1 = value1->data[0].v_pointer;
GArray *array2 = value2->data[0].v_pointer;
guint len = array1->len;
GValue *v1;
GValue *v2;
if (len != array2->len)
return GST_VALUE_UNORDERED;
for (i = 0; i < len; i++) {
v1 = &g_array_index (array1, GValue, i);
v2 = &g_array_index (array2, GValue, i);
if (gst_value_compare (v1, v2) != GST_VALUE_EQUAL)
return GST_VALUE_UNORDERED;
}
return GST_VALUE_EQUAL;
}
static gchar *
gst_value_serialize_list (const GValue * value)
{
return gst_value_serialize_any_list (value, "{ ", " }");
}
static gboolean
gst_value_deserialize_list (GValue * dest, const gchar * s)
{
g_warning ("gst_value_deserialize_list: unimplemented");
return FALSE;
}
static gchar *
gst_value_serialize_array (const GValue * value)
{
return gst_value_serialize_any_list (value, "< ", " >");
}
static gboolean
gst_value_deserialize_array (GValue * dest, const gchar * s)
{
g_warning ("gst_value_deserialize_array: unimplemented");
return FALSE;
}
/*************
* int range *
*
* Values in the range are defined as any value greater or equal
* to min*step, AND lesser or equal to max*step.
* For step == 1, this falls back to the traditional range semantics.
*************/
#define INT_RANGE_MIN(v) (((gint *)((v)->data[0].v_pointer))[0])
#define INT_RANGE_MAX(v) (((gint *)((v)->data[0].v_pointer))[1])
#define INT_RANGE_STEP(v) (((gint *)((v)->data[0].v_pointer))[2])
static void
gst_value_init_int_range (GValue * value)
{
gint *vals = g_slice_alloc0 (3 * sizeof (gint));
value->data[0].v_pointer = vals;
INT_RANGE_MIN (value) = 0;
INT_RANGE_MAX (value) = 0;
INT_RANGE_STEP (value) = 1;
}
static void
gst_value_free_int_range (GValue * value)
{
g_return_if_fail (GST_VALUE_HOLDS_INT_RANGE (value));
g_slice_free1 (3 * sizeof (gint), value->data[0].v_pointer);
value->data[0].v_pointer = NULL;
}
static void
gst_value_copy_int_range (const GValue * src_value, GValue * dest_value)
{
gint *vals = (gint *) dest_value->data[0].v_pointer;
gint *src_vals = (gint *) src_value->data[0].v_pointer;
if (vals == NULL) {
gst_value_init_int_range (dest_value);
}
if (src_vals != NULL) {
INT_RANGE_MIN (dest_value) = INT_RANGE_MIN (src_value);
INT_RANGE_MAX (dest_value) = INT_RANGE_MAX (src_value);
INT_RANGE_STEP (dest_value) = INT_RANGE_STEP (src_value);
}
}
static gchar *
gst_value_collect_int_range (GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
gint *vals = value->data[0].v_pointer;
if (n_collect_values != 2)
return g_strdup_printf ("not enough value locations for `%s' passed",
G_VALUE_TYPE_NAME (value));
if (collect_values[0].v_int >= collect_values[1].v_int)
return g_strdup_printf ("range start is not smaller than end for `%s'",
G_VALUE_TYPE_NAME (value));
if (vals == NULL) {
gst_value_init_int_range (value);
}
gst_value_set_int_range_step (value, collect_values[0].v_int,
collect_values[1].v_int, 1);
return NULL;
}
static gchar *
gst_value_lcopy_int_range (const GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
guint32 *int_range_start = collect_values[0].v_pointer;
guint32 *int_range_end = collect_values[1].v_pointer;
guint32 *int_range_step = collect_values[2].v_pointer;
gint *vals = (gint *) value->data[0].v_pointer;
if (!int_range_start)
return g_strdup_printf ("start value location for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
if (!int_range_end)
return g_strdup_printf ("end value location for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
if (!int_range_step)
return g_strdup_printf ("step value location for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
if (G_UNLIKELY (vals == NULL)) {
return g_strdup_printf ("Uninitialised `%s' passed",
G_VALUE_TYPE_NAME (value));
}
*int_range_start = INT_RANGE_MIN (value);
*int_range_end = INT_RANGE_MAX (value);
*int_range_step = INT_RANGE_STEP (value);
return NULL;
}
/**
* gst_value_set_int_range_step:
* @value: a GValue initialized to GST_TYPE_INT_RANGE
* @start: the start of the range
* @end: the end of the range
* @step: the step of the range
*
* Sets @value to the range specified by @start, @end and @step.
*/
void
gst_value_set_int_range_step (GValue * value, gint start, gint end, gint step)
{
g_return_if_fail (GST_VALUE_HOLDS_INT_RANGE (value));
g_return_if_fail (start < end);
g_return_if_fail (step > 0);
g_return_if_fail (start % step == 0);
g_return_if_fail (end % step == 0);
INT_RANGE_MIN (value) = start / step;
INT_RANGE_MAX (value) = end / step;
INT_RANGE_STEP (value) = step;
}
/**
* gst_value_set_int_range:
* @value: a GValue initialized to GST_TYPE_INT_RANGE
* @start: the start of the range
* @end: the end of the range
*
* Sets @value to the range specified by @start and @end.
*/
void
gst_value_set_int_range (GValue * value, gint start, gint end)
{
gst_value_set_int_range_step (value, start, end, 1);
}
/**
* gst_value_get_int_range_min:
* @value: a GValue initialized to GST_TYPE_INT_RANGE
*
* Gets the minimum of the range specified by @value.
*
* Returns: the minimum of the range
*/
gint
gst_value_get_int_range_min (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_INT_RANGE (value), 0);
return INT_RANGE_MIN (value) * INT_RANGE_STEP (value);
}
/**
* gst_value_get_int_range_max:
* @value: a GValue initialized to GST_TYPE_INT_RANGE
*
* Gets the maximum of the range specified by @value.
*
* Returns: the maxumum of the range
*/
gint
gst_value_get_int_range_max (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_INT_RANGE (value), 0);
return INT_RANGE_MAX (value) * INT_RANGE_STEP (value);
}
/**
* gst_value_get_int_range_step:
* @value: a GValue initialized to GST_TYPE_INT_RANGE
*
* Gets the step of the range specified by @value.
*
* Returns: the step of the range
*/
gint
gst_value_get_int_range_step (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_INT_RANGE (value), 0);
return INT_RANGE_STEP (value);
}
static void
gst_value_transform_int_range_string (const GValue * src_value,
GValue * dest_value)
{
if (INT_RANGE_STEP (src_value) == 1)
dest_value->data[0].v_pointer = g_strdup_printf ("[%d,%d]",
INT_RANGE_MIN (src_value), INT_RANGE_MAX (src_value));
else
dest_value->data[0].v_pointer = g_strdup_printf ("[%d,%d,%d]",
INT_RANGE_MIN (src_value) * INT_RANGE_STEP (src_value),
INT_RANGE_MAX (src_value) * INT_RANGE_STEP (src_value),
INT_RANGE_STEP (src_value));
}
static gint
gst_value_compare_int_range (const GValue * value1, const GValue * value2)
{
/* calculate the number of values in each range */
gint n1 = INT_RANGE_MAX (value1) - INT_RANGE_MIN (value1) + 1;
gint n2 = INT_RANGE_MAX (value2) - INT_RANGE_MIN (value2) + 1;
/* they must be equal */
if (n1 != n2)
return GST_VALUE_UNORDERED;
/* if empty, equal */
if (n1 == 0)
return GST_VALUE_EQUAL;
/* if more than one value, then it is only equal if the step is equal
and bounds lie on the same value */
if (n1 > 1) {
if (INT_RANGE_STEP (value1) == INT_RANGE_STEP (value2) &&
INT_RANGE_STEP (value1) == INT_RANGE_STEP (value2) &&
INT_RANGE_STEP (value1) == INT_RANGE_STEP (value2)) {
return GST_VALUE_EQUAL;
}
return GST_VALUE_UNORDERED;
} else {
/* if just one, only if the value is equal */
if (INT_RANGE_MIN (value1) == INT_RANGE_MIN (value2))
return GST_VALUE_EQUAL;
return GST_VALUE_UNORDERED;
}
}
static gchar *
gst_value_serialize_int_range (const GValue * value)
{
if (INT_RANGE_STEP (value) == 1)
return g_strdup_printf ("[ %d, %d ]", INT_RANGE_MIN (value),
INT_RANGE_MAX (value));
else
return g_strdup_printf ("[ %d, %d, %d ]",
INT_RANGE_MIN (value) * INT_RANGE_STEP (value),
INT_RANGE_MAX (value) * INT_RANGE_STEP (value), INT_RANGE_STEP (value));
}
static gboolean
gst_value_deserialize_int_range (GValue * dest, const gchar * s)
{
g_warning ("unimplemented");
return FALSE;
}
/***************
* int64 range *
*
* Values in the range are defined as any value greater or equal
* to min*step, AND lesser or equal to max*step.
* For step == 1, this falls back to the traditional range semantics.
***************/
#define INT64_RANGE_MIN(v) (((gint64 *)((v)->data[0].v_pointer))[0])
#define INT64_RANGE_MAX(v) (((gint64 *)((v)->data[0].v_pointer))[1])
#define INT64_RANGE_STEP(v) (((gint64 *)((v)->data[0].v_pointer))[2])
static void
gst_value_init_int64_range (GValue * value)
{
gint64 *vals = g_slice_alloc0 (3 * sizeof (gint64));
value->data[0].v_pointer = vals;
INT64_RANGE_MIN (value) = 0;
INT64_RANGE_MAX (value) = 0;
INT64_RANGE_STEP (value) = 1;
}
static void
gst_value_free_int64_range (GValue * value)
{
g_return_if_fail (GST_VALUE_HOLDS_INT64_RANGE (value));
g_slice_free1 (3 * sizeof (gint64), value->data[0].v_pointer);
value->data[0].v_pointer = NULL;
}
static void
gst_value_copy_int64_range (const GValue * src_value, GValue * dest_value)
{
gint64 *vals = (gint64 *) dest_value->data[0].v_pointer;
gint64 *src_vals = (gint64 *) src_value->data[0].v_pointer;
if (vals == NULL) {
gst_value_init_int64_range (dest_value);
}
if (src_vals != NULL) {
INT64_RANGE_MIN (dest_value) = INT64_RANGE_MIN (src_value);
INT64_RANGE_MAX (dest_value) = INT64_RANGE_MAX (src_value);
INT64_RANGE_STEP (dest_value) = INT64_RANGE_STEP (src_value);
}
}
static gchar *
gst_value_collect_int64_range (GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
gint64 *vals = value->data[0].v_pointer;
if (n_collect_values != 2)
return g_strdup_printf ("not enough value locations for `%s' passed",
G_VALUE_TYPE_NAME (value));
if (collect_values[0].v_int64 >= collect_values[1].v_int64)
return g_strdup_printf ("range start is not smaller than end for `%s'",
G_VALUE_TYPE_NAME (value));
if (vals == NULL) {
gst_value_init_int64_range (value);
}
gst_value_set_int64_range_step (value, collect_values[0].v_int64,
collect_values[1].v_int64, 1);
return NULL;
}
static gchar *
gst_value_lcopy_int64_range (const GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
guint64 *int_range_start = collect_values[0].v_pointer;
guint64 *int_range_end = collect_values[1].v_pointer;
guint64 *int_range_step = collect_values[2].v_pointer;
gint64 *vals = (gint64 *) value->data[0].v_pointer;
if (!int_range_start)
return g_strdup_printf ("start value location for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
if (!int_range_end)
return g_strdup_printf ("end value location for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
if (!int_range_step)
return g_strdup_printf ("step value location for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
if (G_UNLIKELY (vals == NULL)) {
return g_strdup_printf ("Uninitialised `%s' passed",
G_VALUE_TYPE_NAME (value));
}
*int_range_start = INT64_RANGE_MIN (value);
*int_range_end = INT64_RANGE_MAX (value);
*int_range_step = INT64_RANGE_STEP (value);
return NULL;
}
/**
* gst_value_set_int64_range_step:
* @value: a GValue initialized to GST_TYPE_INT64_RANGE
* @start: the start of the range
* @end: the end of the range
* @step: the step of the range
*
* Sets @value to the range specified by @start, @end and @step.
*
* Since: 0.11.0
*/
void
gst_value_set_int64_range_step (GValue * value, gint64 start, gint64 end,
gint64 step)
{
g_return_if_fail (GST_VALUE_HOLDS_INT64_RANGE (value));
g_return_if_fail (start < end);
g_return_if_fail (step > 0);
g_return_if_fail (start % step == 0);
g_return_if_fail (end % step == 0);
INT64_RANGE_MIN (value) = start / step;
INT64_RANGE_MAX (value) = end / step;
INT64_RANGE_STEP (value) = step;
}
/**
* gst_value_set_int64_range:
* @value: a GValue initialized to GST_TYPE_INT64_RANGE
* @start: the start of the range
* @end: the end of the range
*
* Sets @value to the range specified by @start and @end.
*
* Since: 0.10.31
*/
void
gst_value_set_int64_range (GValue * value, gint64 start, gint64 end)
{
gst_value_set_int64_range_step (value, start, end, 1);
}
/**
* gst_value_get_int64_range_min:
* @value: a GValue initialized to GST_TYPE_INT64_RANGE
*
* Gets the minimum of the range specified by @value.
*
* Returns: the minimum of the range
*
* Since: 0.10.31
*/
gint64
gst_value_get_int64_range_min (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_INT64_RANGE (value), 0);
return INT64_RANGE_MIN (value) * INT64_RANGE_STEP (value);
}
/**
* gst_value_get_int64_range_max:
* @value: a GValue initialized to GST_TYPE_INT64_RANGE
*
* Gets the maximum of the range specified by @value.
*
* Returns: the maxumum of the range
*
* Since: 0.10.31
*/
gint64
gst_value_get_int64_range_max (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_INT64_RANGE (value), 0);
return INT64_RANGE_MAX (value) * INT64_RANGE_STEP (value);
}
/**
* gst_value_get_int64_range_step:
* @value: a GValue initialized to GST_TYPE_INT64_RANGE
*
* Gets the step of the range specified by @value.
*
* Returns: the step of the range
*
* Since: 0.11.0
*/
gint64
gst_value_get_int64_range_step (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_INT64_RANGE (value), 0);
return INT64_RANGE_STEP (value);
}
static void
gst_value_transform_int64_range_string (const GValue * src_value,
GValue * dest_value)
{
if (INT64_RANGE_STEP (src_value) == 1)
dest_value->data[0].v_pointer =
g_strdup_printf ("(gint64)[%" G_GINT64_FORMAT ",%" G_GINT64_FORMAT "]",
INT64_RANGE_MIN (src_value), INT64_RANGE_MAX (src_value));
else
dest_value->data[0].v_pointer =
g_strdup_printf ("(gint64)[%" G_GINT64_FORMAT ",%" G_GINT64_FORMAT
",%" G_GINT64_FORMAT "]",
INT64_RANGE_MIN (src_value) * INT64_RANGE_STEP (src_value),
INT64_RANGE_MAX (src_value) * INT64_RANGE_STEP (src_value),
INT64_RANGE_STEP (src_value));
}
static gint
gst_value_compare_int64_range (const GValue * value1, const GValue * value2)
{
/* calculate the number of values in each range */
gint64 n1 = INT64_RANGE_MAX (value1) - INT64_RANGE_MIN (value1) + 1;
gint64 n2 = INT64_RANGE_MAX (value2) - INT64_RANGE_MIN (value2) + 1;
/* they must be equal */
if (n1 != n2)
return GST_VALUE_UNORDERED;
/* if empty, equal */
if (n1 == 0)
return GST_VALUE_EQUAL;
/* if more than one value, then it is only equal if the step is equal
and bounds lie on the same value */
if (n1 > 1) {
if (INT64_RANGE_STEP (value1) == INT64_RANGE_STEP (value2) &&
INT64_RANGE_STEP (value1) == INT64_RANGE_STEP (value2) &&
INT64_RANGE_STEP (value1) == INT64_RANGE_STEP (value2)) {
return GST_VALUE_EQUAL;
}
return GST_VALUE_UNORDERED;
} else {
/* if just one, only if the value is equal */
if (INT64_RANGE_MIN (value1) == INT64_RANGE_MIN (value2))
return GST_VALUE_EQUAL;
return GST_VALUE_UNORDERED;
}
}
static gchar *
gst_value_serialize_int64_range (const GValue * value)
{
if (INT64_RANGE_STEP (value) == 1)
return g_strdup_printf ("[ %" G_GINT64_FORMAT ", %" G_GINT64_FORMAT " ]",
INT64_RANGE_MIN (value), INT64_RANGE_MAX (value));
else
return g_strdup_printf ("[ %" G_GINT64_FORMAT ", %" G_GINT64_FORMAT ", %"
G_GINT64_FORMAT " ]",
INT64_RANGE_MIN (value) * INT64_RANGE_STEP (value),
INT64_RANGE_MAX (value) * INT64_RANGE_STEP (value),
INT64_RANGE_STEP (value));
}
static gboolean
gst_value_deserialize_int64_range (GValue * dest, const gchar * s)
{
g_warning ("unimplemented");
return FALSE;
}
/****************
* double range *
****************/
static void
gst_value_init_double_range (GValue * value)
{
value->data[0].v_double = 0;
value->data[1].v_double = 0;
}
static void
gst_value_copy_double_range (const GValue * src_value, GValue * dest_value)
{
dest_value->data[0].v_double = src_value->data[0].v_double;
dest_value->data[1].v_double = src_value->data[1].v_double;
}
static gchar *
gst_value_collect_double_range (GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
if (n_collect_values != 2)
return g_strdup_printf ("not enough value locations for `%s' passed",
G_VALUE_TYPE_NAME (value));
if (collect_values[0].v_double >= collect_values[1].v_double)
return g_strdup_printf ("range start is not smaller than end for `%s'",
G_VALUE_TYPE_NAME (value));
value->data[0].v_double = collect_values[0].v_double;
value->data[1].v_double = collect_values[1].v_double;
return NULL;
}
static gchar *
gst_value_lcopy_double_range (const GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
gdouble *double_range_start = collect_values[0].v_pointer;
gdouble *double_range_end = collect_values[1].v_pointer;
if (!double_range_start)
return g_strdup_printf ("start value location for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
if (!double_range_end)
return g_strdup_printf ("end value location for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
*double_range_start = value->data[0].v_double;
*double_range_end = value->data[1].v_double;
return NULL;
}
/**
* gst_value_set_double_range:
* @value: a GValue initialized to GST_TYPE_DOUBLE_RANGE
* @start: the start of the range
* @end: the end of the range
*
* Sets @value to the range specified by @start and @end.
*/
void
gst_value_set_double_range (GValue * value, gdouble start, gdouble end)
{
g_return_if_fail (GST_VALUE_HOLDS_DOUBLE_RANGE (value));
g_return_if_fail (start < end);
value->data[0].v_double = start;
value->data[1].v_double = end;
}
/**
* gst_value_get_double_range_min:
* @value: a GValue initialized to GST_TYPE_DOUBLE_RANGE
*
* Gets the minimum of the range specified by @value.
*
* Returns: the minimum of the range
*/
gdouble
gst_value_get_double_range_min (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_DOUBLE_RANGE (value), 0);
return value->data[0].v_double;
}
/**
* gst_value_get_double_range_max:
* @value: a GValue initialized to GST_TYPE_DOUBLE_RANGE
*
* Gets the maximum of the range specified by @value.
*
* Returns: the maxumum of the range
*/
gdouble
gst_value_get_double_range_max (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_DOUBLE_RANGE (value), 0);
return value->data[1].v_double;
}
static void
gst_value_transform_double_range_string (const GValue * src_value,
GValue * dest_value)
{
gchar s1[G_ASCII_DTOSTR_BUF_SIZE], s2[G_ASCII_DTOSTR_BUF_SIZE];
dest_value->data[0].v_pointer = g_strdup_printf ("[%s,%s]",
g_ascii_dtostr (s1, G_ASCII_DTOSTR_BUF_SIZE,
src_value->data[0].v_double),
g_ascii_dtostr (s2, G_ASCII_DTOSTR_BUF_SIZE,
src_value->data[1].v_double));
}
static gint
gst_value_compare_double_range (const GValue * value1, const GValue * value2)
{
if (value2->data[0].v_double == value1->data[0].v_double &&
value2->data[0].v_double == value1->data[0].v_double)
return GST_VALUE_EQUAL;
return GST_VALUE_UNORDERED;
}
static gchar *
gst_value_serialize_double_range (const GValue * value)
{
gchar d1[G_ASCII_DTOSTR_BUF_SIZE];
gchar d2[G_ASCII_DTOSTR_BUF_SIZE];
g_ascii_dtostr (d1, G_ASCII_DTOSTR_BUF_SIZE, value->data[0].v_double);
g_ascii_dtostr (d2, G_ASCII_DTOSTR_BUF_SIZE, value->data[1].v_double);
return g_strdup_printf ("[ %s, %s ]", d1, d2);
}
static gboolean
gst_value_deserialize_double_range (GValue * dest, const gchar * s)
{
g_warning ("unimplemented");
return FALSE;
}
/****************
* fraction range *
****************/
static void
gst_value_init_fraction_range (GValue * value)
{
GValue *vals;
GType ftype;
ftype = GST_TYPE_FRACTION;
value->data[0].v_pointer = vals = g_slice_alloc0 (2 * sizeof (GValue));
g_value_init (&vals[0], ftype);
g_value_init (&vals[1], ftype);
}
static void
gst_value_free_fraction_range (GValue * value)
{
GValue *vals = (GValue *) value->data[0].v_pointer;
if (vals != NULL) {
/* we know the two values contain fractions without internal allocs */
/* g_value_unset (&vals[0]); */
/* g_value_unset (&vals[1]); */
g_slice_free1 (2 * sizeof (GValue), vals);
value->data[0].v_pointer = NULL;
}
}
static void
gst_value_copy_fraction_range (const GValue * src_value, GValue * dest_value)
{
GValue *vals = (GValue *) dest_value->data[0].v_pointer;
GValue *src_vals = (GValue *) src_value->data[0].v_pointer;
if (vals == NULL) {
gst_value_init_fraction_range (dest_value);
vals = dest_value->data[0].v_pointer;
}
if (src_vals != NULL) {
g_value_copy (&src_vals[0], &vals[0]);
g_value_copy (&src_vals[1], &vals[1]);
}
}
static gchar *
gst_value_collect_fraction_range (GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
GValue *vals = (GValue *) value->data[0].v_pointer;
if (n_collect_values != 4)
return g_strdup_printf ("not enough value locations for `%s' passed",
G_VALUE_TYPE_NAME (value));
if (collect_values[1].v_int == 0)
return g_strdup_printf ("passed '0' as first denominator for `%s'",
G_VALUE_TYPE_NAME (value));
if (collect_values[3].v_int == 0)
return g_strdup_printf ("passed '0' as second denominator for `%s'",
G_VALUE_TYPE_NAME (value));
if (gst_util_fraction_compare (collect_values[0].v_int,
collect_values[1].v_int, collect_values[2].v_int,
collect_values[3].v_int) >= 0)
return g_strdup_printf ("range start is not smaller than end for `%s'",
G_VALUE_TYPE_NAME (value));
if (vals == NULL) {
gst_value_init_fraction_range (value);
vals = value->data[0].v_pointer;
}
gst_value_set_fraction (&vals[0], collect_values[0].v_int,
collect_values[1].v_int);
gst_value_set_fraction (&vals[1], collect_values[2].v_int,
collect_values[3].v_int);
return NULL;
}
static gchar *
gst_value_lcopy_fraction_range (const GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
gint i;
gint *dest_values[4];
GValue *vals = (GValue *) value->data[0].v_pointer;
if (G_UNLIKELY (n_collect_values != 4))
return g_strdup_printf ("not enough value locations for `%s' passed",
G_VALUE_TYPE_NAME (value));
for (i = 0; i < 4; i++) {
if (G_UNLIKELY (collect_values[i].v_pointer == NULL)) {
return g_strdup_printf ("value location for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
}
dest_values[i] = collect_values[i].v_pointer;
}
if (G_UNLIKELY (vals == NULL)) {
return g_strdup_printf ("Uninitialised `%s' passed",
G_VALUE_TYPE_NAME (value));
}
dest_values[0][0] = gst_value_get_fraction_numerator (&vals[0]);
dest_values[1][0] = gst_value_get_fraction_denominator (&vals[0]);
dest_values[2][0] = gst_value_get_fraction_numerator (&vals[1]);
dest_values[3][0] = gst_value_get_fraction_denominator (&vals[1]);
return NULL;
}
/**
* gst_value_set_fraction_range:
* @value: a GValue initialized to GST_TYPE_FRACTION_RANGE
* @start: the start of the range (a GST_TYPE_FRACTION GValue)
* @end: the end of the range (a GST_TYPE_FRACTION GValue)
*
* Sets @value to the range specified by @start and @end.
*/
void
gst_value_set_fraction_range (GValue * value, const GValue * start,
const GValue * end)
{
GValue *vals;
g_return_if_fail (GST_VALUE_HOLDS_FRACTION_RANGE (value));
g_return_if_fail (GST_VALUE_HOLDS_FRACTION (start));
g_return_if_fail (GST_VALUE_HOLDS_FRACTION (end));
g_return_if_fail (gst_util_fraction_compare (start->data[0].v_int,
start->data[1].v_int, end->data[0].v_int, end->data[1].v_int) < 0);
vals = (GValue *) value->data[0].v_pointer;
if (vals == NULL) {
gst_value_init_fraction_range (value);
vals = value->data[0].v_pointer;
}
g_value_copy (start, &vals[0]);
g_value_copy (end, &vals[1]);
}
/**
* gst_value_set_fraction_range_full:
* @value: a GValue initialized to GST_TYPE_FRACTION_RANGE
* @numerator_start: the numerator start of the range
* @denominator_start: the denominator start of the range
* @numerator_end: the numerator end of the range
* @denominator_end: the denominator end of the range
*
* Sets @value to the range specified by @numerator_start/@denominator_start
* and @numerator_end/@denominator_end.
*/
void
gst_value_set_fraction_range_full (GValue * value,
gint numerator_start, gint denominator_start,
gint numerator_end, gint denominator_end)
{
GValue start = { 0 };
GValue end = { 0 };
g_return_if_fail (value != NULL);
g_return_if_fail (denominator_start != 0);
g_return_if_fail (denominator_end != 0);
g_return_if_fail (gst_util_fraction_compare (numerator_start,
denominator_start, numerator_end, denominator_end) < 0);
g_value_init (&start, GST_TYPE_FRACTION);
g_value_init (&end, GST_TYPE_FRACTION);
gst_value_set_fraction (&start, numerator_start, denominator_start);
gst_value_set_fraction (&end, numerator_end, denominator_end);
gst_value_set_fraction_range (value, &start, &end);
/* we know the two values contain fractions without internal allocs */
/* g_value_unset (&start); */
/* g_value_unset (&end); */
}
/**
* gst_value_get_fraction_range_min:
* @value: a GValue initialized to GST_TYPE_FRACTION_RANGE
*
* Gets the minimum of the range specified by @value.
*
* Returns: the minimum of the range
*/
const GValue *
gst_value_get_fraction_range_min (const GValue * value)
{
GValue *vals;
g_return_val_if_fail (GST_VALUE_HOLDS_FRACTION_RANGE (value), NULL);
vals = (GValue *) value->data[0].v_pointer;
if (vals != NULL) {
return &vals[0];
}
return NULL;
}
/**
* gst_value_get_fraction_range_max:
* @value: a GValue initialized to GST_TYPE_FRACTION_RANGE
*
* Gets the maximum of the range specified by @value.
*
* Returns: the maximum of the range
*/
const GValue *
gst_value_get_fraction_range_max (const GValue * value)
{
GValue *vals;
g_return_val_if_fail (GST_VALUE_HOLDS_FRACTION_RANGE (value), NULL);
vals = (GValue *) value->data[0].v_pointer;
if (vals != NULL) {
return &vals[1];
}
return NULL;
}
static gchar *
gst_value_serialize_fraction_range (const GValue * value)
{
GValue *vals = (GValue *) value->data[0].v_pointer;
gchar *retval;
if (vals == NULL) {
retval = g_strdup ("[ 0/1, 0/1 ]");
} else {
gchar *start, *end;
start = gst_value_serialize_fraction (&vals[0]);
end = gst_value_serialize_fraction (&vals[1]);
retval = g_strdup_printf ("[ %s, %s ]", start, end);
g_free (start);
g_free (end);
}
return retval;
}
static void
gst_value_transform_fraction_range_string (const GValue * src_value,
GValue * dest_value)
{
dest_value->data[0].v_pointer =
gst_value_serialize_fraction_range (src_value);
}
static gint
gst_value_compare_fraction_range (const GValue * value1, const GValue * value2)
{
GValue *vals1, *vals2;
GstValueCompareFunc compare;
if (value2->data[0].v_pointer == value1->data[0].v_pointer)
return GST_VALUE_EQUAL; /* Only possible if both are NULL */
if (value2->data[0].v_pointer == NULL || value1->data[0].v_pointer == NULL)
return GST_VALUE_UNORDERED;
vals1 = (GValue *) value1->data[0].v_pointer;
vals2 = (GValue *) value2->data[0].v_pointer;
if ((compare = gst_value_get_compare_func (&vals1[0]))) {
if (gst_value_compare_with_func (&vals1[0], &vals2[0], compare) ==
GST_VALUE_EQUAL &&
gst_value_compare_with_func (&vals1[1], &vals2[1], compare) ==
GST_VALUE_EQUAL)
return GST_VALUE_EQUAL;
}
return GST_VALUE_UNORDERED;
}
static gboolean
gst_value_deserialize_fraction_range (GValue * dest, const gchar * s)
{
g_warning ("unimplemented");
return FALSE;
}
/***********
* GstCaps *
***********/
/**
* gst_value_set_caps:
* @value: a GValue initialized to GST_TYPE_CAPS
* @caps: (transfer none): the caps to set the value to
*
* Sets the contents of @value to @caps. A reference to the
* provided @caps will be taken by the @value.
*/
void
gst_value_set_caps (GValue * value, const GstCaps * caps)
{
g_return_if_fail (G_IS_VALUE (value));
g_return_if_fail (G_VALUE_TYPE (value) == GST_TYPE_CAPS);
g_return_if_fail (caps == NULL || GST_IS_CAPS (caps));
g_value_set_boxed (value, caps);
}
/**
* gst_value_get_caps:
* @value: a GValue initialized to GST_TYPE_CAPS
*
* Gets the contents of @value. The reference count of the returned
* #GstCaps will not be modified, therefore the caller must take one
* before getting rid of the @value.
*
* Returns: (transfer none): the contents of @value
*/
const GstCaps *
gst_value_get_caps (const GValue * value)
{
g_return_val_if_fail (G_IS_VALUE (value), NULL);
g_return_val_if_fail (G_VALUE_TYPE (value) == GST_TYPE_CAPS, NULL);
return (GstCaps *) g_value_get_boxed (value);
}
static gchar *
gst_value_serialize_caps (const GValue * value)
{
GstCaps *caps = g_value_get_boxed (value);
return gst_caps_to_string (caps);
}
static gboolean
gst_value_deserialize_caps (GValue * dest, const gchar * s)
{
GstCaps *caps;
caps = gst_caps_from_string (s);
if (caps) {
g_value_take_boxed (dest, caps);
return TRUE;
}
return FALSE;
}
/**************
* GstSegment *
**************/
static gchar *
gst_value_serialize_segment (const GValue * value)
{
GstSegment *seg = g_value_get_boxed (value);
gchar *t, *res;
GstStructure *s;
s = gst_structure_new ("GstSegment",
"flags", GST_TYPE_SEGMENT_FLAGS, seg->flags,
"rate", G_TYPE_DOUBLE, seg->rate,
"applied-rate", G_TYPE_DOUBLE, seg->applied_rate,
"format", GST_TYPE_FORMAT, seg->format,
"base", G_TYPE_UINT64, seg->base,
"start", G_TYPE_UINT64, seg->start,
"stop", G_TYPE_UINT64, seg->stop,
"time", G_TYPE_UINT64, seg->time,
"position", G_TYPE_UINT64, seg->position,
"duration", G_TYPE_UINT64, seg->duration, NULL);
t = gst_structure_to_string (s);
res = g_strdup_printf ("\"%s\"", t);
g_free (t);
gst_structure_free (s);
return res;
}
static gboolean
gst_value_deserialize_segment (GValue * dest, const gchar * s)
{
GstStructure *str;
GstSegment seg;
gboolean res;
str = gst_structure_from_string (s, NULL);
if (str == NULL)
return FALSE;
res = gst_structure_get (str,
"flags", GST_TYPE_SEGMENT_FLAGS, &seg.flags,
"rate", G_TYPE_DOUBLE, &seg.rate,
"applied-rate", G_TYPE_DOUBLE, &seg.applied_rate,
"format", GST_TYPE_FORMAT, &seg.format,
"base", G_TYPE_UINT64, &seg.base,
"start", G_TYPE_UINT64, &seg.start,
"stop", G_TYPE_UINT64, &seg.stop,
"time", G_TYPE_UINT64, &seg.time,
"position", G_TYPE_UINT64, &seg.position,
"duration", G_TYPE_UINT64, &seg.duration, NULL);
gst_structure_free (str);
if (res)
g_value_set_boxed (dest, &seg);
return res;
}
/****************
* GstStructure *
****************/
/**
* gst_value_set_structure:
* @value: a GValue initialized to GST_TYPE_STRUCTURE
* @structure: the structure to set the value to
*
* Sets the contents of @value to @structure. The actual
*
* Since: 0.10.15
*/
void
gst_value_set_structure (GValue * value, const GstStructure * structure)
{
g_return_if_fail (G_IS_VALUE (value));
g_return_if_fail (G_VALUE_TYPE (value) == GST_TYPE_STRUCTURE);
g_return_if_fail (structure == NULL || GST_IS_STRUCTURE (structure));
g_value_set_boxed (value, structure);
}
/**
* gst_value_get_structure:
* @value: a GValue initialized to GST_TYPE_STRUCTURE
*
* Gets the contents of @value.
*
* Returns: (transfer none): the contents of @value
*
* Since: 0.10.15
*/
const GstStructure *
gst_value_get_structure (const GValue * value)
{
g_return_val_if_fail (G_IS_VALUE (value), NULL);
g_return_val_if_fail (G_VALUE_TYPE (value) == GST_TYPE_STRUCTURE, NULL);
return (GstStructure *) g_value_get_boxed (value);
}
static gchar *
gst_value_serialize_structure (const GValue * value)
{
GstStructure *structure = g_value_get_boxed (value);
return gst_string_take_and_wrap (gst_structure_to_string (structure));
}
static gboolean
gst_value_deserialize_structure (GValue * dest, const gchar * s)
{
GstStructure *structure;
if (*s != '"') {
structure = gst_structure_from_string (s, NULL);
} else {
gchar *str = gst_string_unwrap (s);
if (G_UNLIKELY (!str))
return FALSE;
structure = gst_structure_from_string (str, NULL);
g_free (str);
}
if (G_LIKELY (structure)) {
g_value_take_boxed (dest, structure);
return TRUE;
}
return FALSE;
}
/*************
* GstBuffer *
*************/
static gint
compare_buffer (GstBuffer * buf1, GstBuffer * buf2)
{
gsize size1, size2;
GstMapInfo info1, info2;
gint result, mret;
if (buf1 == buf2)
return GST_VALUE_EQUAL;
size1 = gst_buffer_get_size (buf1);
size2 = gst_buffer_get_size (buf2);
if (size1 != size2)
return GST_VALUE_UNORDERED;
if (size1 == 0)
return GST_VALUE_EQUAL;
if (!gst_buffer_map (buf1, &info1, GST_MAP_READ))
return GST_VALUE_UNORDERED;
if (!gst_buffer_map (buf2, &info2, GST_MAP_READ)) {
gst_buffer_unmap (buf1, &info1);
return GST_VALUE_UNORDERED;
}
mret = memcmp (info1.data, info2.data, info1.size);
if (mret == 0)
result = GST_VALUE_EQUAL;
else if (mret < 0)
result = GST_VALUE_LESS_THAN;
else
result = GST_VALUE_GREATER_THAN;
gst_buffer_unmap (buf1, &info1);
gst_buffer_unmap (buf2, &info2);
return result;
}
static gint
gst_value_compare_buffer (const GValue * value1, const GValue * value2)
{
GstBuffer *buf1 = gst_value_get_buffer (value1);
GstBuffer *buf2 = gst_value_get_buffer (value2);
return compare_buffer (buf1, buf2);
}
static gchar *
gst_value_serialize_buffer (const GValue * value)
{
GstMapInfo info;
guint8 *data;
gint i;
gchar *string;
GstBuffer *buffer;
buffer = gst_value_get_buffer (value);
if (buffer == NULL)
return NULL;
if (!gst_buffer_map (buffer, &info, GST_MAP_READ))
return NULL;
data = info.data;
string = g_malloc (info.size * 2 + 1);
for (i = 0; i < info.size; i++) {
sprintf (string + i * 2, "%02x", data[i]);
}
string[info.size * 2] = 0;
gst_buffer_unmap (buffer, &info);
return string;
}
static gboolean
gst_value_deserialize_buffer (GValue * dest, const gchar * s)
{
GstBuffer *buffer;
gint len;
gchar ts[3];
GstMapInfo info;
guint8 *data;
gint i;
len = strlen (s);
if (len & 1)
goto wrong_length;
buffer = gst_buffer_new_allocate (NULL, len / 2, NULL);
if (!gst_buffer_map (buffer, &info, GST_MAP_WRITE))
goto map_failed;
data = info.data;
for (i = 0; i < len / 2; i++) {
if (!isxdigit ((int) s[i * 2]) || !isxdigit ((int) s[i * 2 + 1]))
goto wrong_char;
ts[0] = s[i * 2 + 0];
ts[1] = s[i * 2 + 1];
ts[2] = 0;
data[i] = (guint8) strtoul (ts, NULL, 16);
}
gst_buffer_unmap (buffer, &info);
gst_value_take_buffer (dest, buffer);
return TRUE;
/* ERRORS */
wrong_length:
{
return FALSE;
}
map_failed:
{
return FALSE;
}
wrong_char:
{
gst_buffer_unref (buffer);
gst_buffer_unmap (buffer, &info);
return FALSE;
}
}
/*************
* GstSample *
*************/
/* This function is mostly used for comparing image/buffer tags in taglists */
static gint
gst_value_compare_sample (const GValue * value1, const GValue * value2)
{
GstBuffer *buf1 = gst_sample_get_buffer (gst_value_get_sample (value1));
GstBuffer *buf2 = gst_sample_get_buffer (gst_value_get_sample (value2));
/* FIXME: should we take into account anything else such as caps? */
return compare_buffer (buf1, buf2);
}
/***********
* boolean *
***********/
static gint
gst_value_compare_boolean (const GValue * value1, const GValue * value2)
{
if ((value1->data[0].v_int != 0) == (value2->data[0].v_int != 0))
return GST_VALUE_EQUAL;
return GST_VALUE_UNORDERED;
}
static gchar *
gst_value_serialize_boolean (const GValue * value)
{
if (value->data[0].v_int) {
return g_strdup ("true");
}
return g_strdup ("false");
}
static gboolean
gst_value_deserialize_boolean (GValue * dest, const gchar * s)
{
gboolean ret = FALSE;
if (g_ascii_strcasecmp (s, "true") == 0 ||
g_ascii_strcasecmp (s, "yes") == 0 ||
g_ascii_strcasecmp (s, "t") == 0 || strcmp (s, "1") == 0) {
g_value_set_boolean (dest, TRUE);
ret = TRUE;
} else if (g_ascii_strcasecmp (s, "false") == 0 ||
g_ascii_strcasecmp (s, "no") == 0 ||
g_ascii_strcasecmp (s, "f") == 0 || strcmp (s, "0") == 0) {
g_value_set_boolean (dest, FALSE);
ret = TRUE;
}
return ret;
}
#define CREATE_SERIALIZATION_START(_type,_macro) \
static gint \
gst_value_compare_ ## _type \
(const GValue * value1, const GValue * value2) \
{ \
g ## _type val1 = g_value_get_ ## _type (value1); \
g ## _type val2 = g_value_get_ ## _type (value2); \
if (val1 > val2) \
return GST_VALUE_GREATER_THAN; \
if (val1 < val2) \
return GST_VALUE_LESS_THAN; \
return GST_VALUE_EQUAL; \
} \
\
static gchar * \
gst_value_serialize_ ## _type (const GValue * value) \
{ \
GValue val = { 0, }; \
g_value_init (&val, G_TYPE_STRING); \
if (!g_value_transform (value, &val)) \
g_assert_not_reached (); \
/* NO_COPY_MADNESS!!! */ \
return (char *) g_value_get_string (&val); \
}
/* deserialize the given s into to as a gint64.
* check if the result is actually storeable in the given size number of
* bytes.
*/
static gboolean
gst_value_deserialize_int_helper (gint64 * to, const gchar * s,
gint64 min, gint64 max, gint size)
{
gboolean ret = FALSE;
gchar *end;
gint64 mask = -1;
errno = 0;
*to = g_ascii_strtoull (s, &end, 0);
/* a range error is a definitive no-no */
if (errno == ERANGE) {
return FALSE;
}
if (*end == 0) {
ret = TRUE;
} else {
if (g_ascii_strcasecmp (s, "little_endian") == 0) {
*to = G_LITTLE_ENDIAN;
ret = TRUE;
} else if (g_ascii_strcasecmp (s, "big_endian") == 0) {
*to = G_BIG_ENDIAN;
ret = TRUE;
} else if (g_ascii_strcasecmp (s, "byte_order") == 0) {
*to = G_BYTE_ORDER;
ret = TRUE;
} else if (g_ascii_strcasecmp (s, "min") == 0) {
*to = min;
ret = TRUE;
} else if (g_ascii_strcasecmp (s, "max") == 0) {
*to = max;
ret = TRUE;
}
}
if (ret) {
/* by definition, a gint64 fits into a gint64; so ignore those */
if (size != sizeof (mask)) {
if (*to >= 0) {
/* for positive numbers, we create a mask of 1's outside of the range
* and 0's inside the range. An and will thus keep only 1 bits
* outside of the range */
mask <<= (size * 8);
if ((mask & *to) != 0) {
ret = FALSE;
}
} else {
/* for negative numbers, we do a 2's complement version */
mask <<= ((size * 8) - 1);
if ((mask & *to) != mask) {
ret = FALSE;
}
}
}
}
return ret;
}
#define CREATE_SERIALIZATION(_type,_macro) \
CREATE_SERIALIZATION_START(_type,_macro) \
\
static gboolean \
gst_value_deserialize_ ## _type (GValue * dest, const gchar *s) \
{ \
gint64 x; \
\
if (gst_value_deserialize_int_helper (&x, s, G_MIN ## _macro, \
G_MAX ## _macro, sizeof (g ## _type))) { \
g_value_set_ ## _type (dest, /*(g ## _type)*/ x); \
return TRUE; \
} else { \
return FALSE; \
} \
}
#define CREATE_USERIALIZATION(_type,_macro) \
CREATE_SERIALIZATION_START(_type,_macro) \
\
static gboolean \
gst_value_deserialize_ ## _type (GValue * dest, const gchar *s) \
{ \
gint64 x; \
gchar *end; \
gboolean ret = FALSE; \
\
errno = 0; \
x = g_ascii_strtoull (s, &end, 0); \
/* a range error is a definitive no-no */ \
if (errno == ERANGE) { \
return FALSE; \
} \
/* the cast ensures the range check later on makes sense */ \
x = (g ## _type) x; \
if (*end == 0) { \
ret = TRUE; \
} else { \
if (g_ascii_strcasecmp (s, "little_endian") == 0) { \
x = G_LITTLE_ENDIAN; \
ret = TRUE; \
} else if (g_ascii_strcasecmp (s, "big_endian") == 0) { \
x = G_BIG_ENDIAN; \
ret = TRUE; \
} else if (g_ascii_strcasecmp (s, "byte_order") == 0) { \
x = G_BYTE_ORDER; \
ret = TRUE; \
} else if (g_ascii_strcasecmp (s, "min") == 0) { \
x = 0; \
ret = TRUE; \
} else if (g_ascii_strcasecmp (s, "max") == 0) { \
x = G_MAX ## _macro; \
ret = TRUE; \
} \
} \
if (ret) { \
if (x > G_MAX ## _macro) { \
ret = FALSE; \
} else { \
g_value_set_ ## _type (dest, x); \
} \
} \
return ret; \
}
#define REGISTER_SERIALIZATION(_gtype, _type) \
G_STMT_START { \
static const GstValueTable gst_value = { \
_gtype, \
gst_value_compare_ ## _type, \
gst_value_serialize_ ## _type, \
gst_value_deserialize_ ## _type, \
}; \
\
gst_value_register (&gst_value); \
} G_STMT_END
CREATE_SERIALIZATION (int, INT);
CREATE_SERIALIZATION (int64, INT64);
CREATE_SERIALIZATION (long, LONG);
CREATE_USERIALIZATION (uint, UINT);
CREATE_USERIALIZATION (uint64, UINT64);
CREATE_USERIALIZATION (ulong, ULONG);
/* FIXME 0.11: remove this again, plugins shouldn't have uchar properties */
#ifndef G_MAXUCHAR
#define G_MAXUCHAR 255
#endif
CREATE_USERIALIZATION (uchar, UCHAR);
/**********
* double *
**********/
static gint
gst_value_compare_double (const GValue * value1, const GValue * value2)
{
if (value1->data[0].v_double > value2->data[0].v_double)
return GST_VALUE_GREATER_THAN;
if (value1->data[0].v_double < value2->data[0].v_double)
return GST_VALUE_LESS_THAN;
if (value1->data[0].v_double == value2->data[0].v_double)
return GST_VALUE_EQUAL;
return GST_VALUE_UNORDERED;
}
static gchar *
gst_value_serialize_double (const GValue * value)
{
gchar d[G_ASCII_DTOSTR_BUF_SIZE];
g_ascii_dtostr (d, G_ASCII_DTOSTR_BUF_SIZE, value->data[0].v_double);
return g_strdup (d);
}
static gboolean
gst_value_deserialize_double (GValue * dest, const gchar * s)
{
gdouble x;
gboolean ret = FALSE;
gchar *end;
x = g_ascii_strtod (s, &end);
if (*end == 0) {
ret = TRUE;
} else {
if (g_ascii_strcasecmp (s, "min") == 0) {
x = -G_MAXDOUBLE;
ret = TRUE;
} else if (g_ascii_strcasecmp (s, "max") == 0) {
x = G_MAXDOUBLE;
ret = TRUE;
}
}
if (ret) {
g_value_set_double (dest, x);
}
return ret;
}
/*********
* float *
*********/
static gint
gst_value_compare_float (const GValue * value1, const GValue * value2)
{
if (value1->data[0].v_float > value2->data[0].v_float)
return GST_VALUE_GREATER_THAN;
if (value1->data[0].v_float < value2->data[0].v_float)
return GST_VALUE_LESS_THAN;
if (value1->data[0].v_float == value2->data[0].v_float)
return GST_VALUE_EQUAL;
return GST_VALUE_UNORDERED;
}
static gchar *
gst_value_serialize_float (const GValue * value)
{
gchar d[G_ASCII_DTOSTR_BUF_SIZE];
g_ascii_dtostr (d, G_ASCII_DTOSTR_BUF_SIZE, value->data[0].v_float);
return g_strdup (d);
}
static gboolean
gst_value_deserialize_float (GValue * dest, const gchar * s)
{
gdouble x;
gboolean ret = FALSE;
gchar *end;
x = g_ascii_strtod (s, &end);
if (*end == 0) {
ret = TRUE;
} else {
if (g_ascii_strcasecmp (s, "min") == 0) {
x = -G_MAXFLOAT;
ret = TRUE;
} else if (g_ascii_strcasecmp (s, "max") == 0) {
x = G_MAXFLOAT;
ret = TRUE;
}
}
if (x > G_MAXFLOAT || x < -G_MAXFLOAT)
ret = FALSE;
if (ret) {
g_value_set_float (dest, (float) x);
}
return ret;
}
/**********
* string *
**********/
static gint
gst_value_compare_string (const GValue * value1, const GValue * value2)
{
if (G_UNLIKELY (!value1->data[0].v_pointer || !value2->data[0].v_pointer)) {
/* if only one is NULL, no match - otherwise both NULL == EQUAL */
if (value1->data[0].v_pointer != value2->data[0].v_pointer)
return GST_VALUE_UNORDERED;
} else {
gint x = strcmp (value1->data[0].v_pointer, value2->data[0].v_pointer);
if (x < 0)
return GST_VALUE_LESS_THAN;
if (x > 0)
return GST_VALUE_GREATER_THAN;
}
return GST_VALUE_EQUAL;
}
static gint
gst_string_measure_wrapping (const gchar * s)
{
gint len;
gboolean wrap = FALSE;
if (G_UNLIKELY (s == NULL))
return -1;
/* Special case: the actual string NULL needs wrapping */
if (G_UNLIKELY (strcmp (s, "NULL") == 0))
return 4;
len = 0;
while (*s) {
if (GST_ASCII_IS_STRING (*s)) {
len++;
} else if (*s < 0x20 || *s >= 0x7f) {
wrap = TRUE;
len += 4;
} else {
wrap = TRUE;
len += 2;
}
s++;
}
/* Wrap the string if we found something that needs
* wrapping, or the empty string (len == 0) */
return (wrap || len == 0) ? len : -1;
}
static gchar *
gst_string_wrap_inner (const gchar * s, gint len)
{
gchar *d, *e;
e = d = g_malloc (len + 3);
*e++ = '\"';
while (*s) {
if (GST_ASCII_IS_STRING (*s)) {
*e++ = *s++;
} else if (*s < 0x20 || *s >= 0x7f) {
*e++ = '\\';
*e++ = '0' + ((*(guchar *) s) >> 6);
*e++ = '0' + (((*s) >> 3) & 0x7);
*e++ = '0' + ((*s++) & 0x7);
} else {
*e++ = '\\';
*e++ = *s++;
}
}
*e++ = '\"';
*e = 0;
g_assert (e - d <= len + 3);
return d;
}
/* Do string wrapping/escaping */
static gchar *
gst_string_wrap (const gchar * s)
{
gint len = gst_string_measure_wrapping (s);
if (G_LIKELY (len < 0))
return g_strdup (s);
return gst_string_wrap_inner (s, len);
}
/* Same as above, but take ownership of the string */
static gchar *
gst_string_take_and_wrap (gchar * s)
{
gchar *out;
gint len = gst_string_measure_wrapping (s);
if (G_LIKELY (len < 0))
return s;
out = gst_string_wrap_inner (s, len);
g_free (s);
return out;
}
/*
* This function takes a string delimited with double quotes (")
* and unescapes any \xxx octal numbers.
*
* If sequences of \y are found where y is not in the range of
* 0->3, y is copied unescaped.
*
* If \xyy is found where x is an octal number but y is not, an
* error is encountered and NULL is returned.
*
* the input string must be \0 terminated.
*/
static gchar *
gst_string_unwrap (const gchar * s)
{
gchar *ret;
gchar *read, *write;
/* NULL string returns NULL */
if (s == NULL)
return NULL;
/* strings not starting with " are invalid */
if (*s != '"')
return NULL;
/* make copy of original string to hold the result. This
* string will always be smaller than the original */
ret = g_strdup (s);
read = ret;
write = ret;
/* need to move to the next position as we parsed the " */
read++;
while (*read) {
if (GST_ASCII_IS_STRING (*read)) {
/* normal chars are just copied */
*write++ = *read++;
} else if (*read == '"') {
/* quote marks end of string */
break;
} else if (*read == '\\') {
/* got an escape char, move to next position to read a tripplet
* of octal numbers */
read++;
/* is the next char a possible first octal number? */
if (*read >= '0' && *read <= '3') {
/* parse other 2 numbers, if one of them is not in the range of
* an octal number, we error. We also catch the case where a zero
* byte is found here. */
if (read[1] < '0' || read[1] > '7' || read[2] < '0' || read[2] > '7')
goto beach;
/* now convert the octal number to a byte again. */
*write++ = ((read[0] - '0') << 6) +
((read[1] - '0') << 3) + (read[2] - '0');
read += 3;
} else {
/* if we run into a \0 here, we definitely won't get a quote later */
if (*read == 0)
goto beach;
/* else copy \X sequence */
*write++ = *read++;
}
} else {
/* weird character, error */
goto beach;
}
}
/* if the string is not ending in " and zero terminated, we error */
if (*read != '"' || read[1] != '\0')
goto beach;
/* null terminate result string and return */
*write = '\0';
return ret;
beach:
g_free (ret);
return NULL;
}
static gchar *
gst_value_serialize_string (const GValue * value)
{
return gst_string_wrap (value->data[0].v_pointer);
}
static gboolean
gst_value_deserialize_string (GValue * dest, const gchar * s)
{
if (G_UNLIKELY (strcmp (s, "NULL") == 0)) {
g_value_set_string (dest, NULL);
return TRUE;
} else if (G_LIKELY (*s != '"')) {
if (!g_utf8_validate (s, -1, NULL))
return FALSE;
g_value_set_string (dest, s);
return TRUE;
} else {
gchar *str = gst_string_unwrap (s);
if (G_UNLIKELY (!str))
return FALSE;
g_value_take_string (dest, str);
}
return TRUE;
}
/********
* enum *
********/
static gint
gst_value_compare_enum (const GValue * value1, const GValue * value2)
{
GEnumValue *en1, *en2;
GEnumClass *klass1 = (GEnumClass *) g_type_class_ref (G_VALUE_TYPE (value1));
GEnumClass *klass2 = (GEnumClass *) g_type_class_ref (G_VALUE_TYPE (value2));
g_return_val_if_fail (klass1, GST_VALUE_UNORDERED);
g_return_val_if_fail (klass2, GST_VALUE_UNORDERED);
en1 = g_enum_get_value (klass1, g_value_get_enum (value1));
en2 = g_enum_get_value (klass2, g_value_get_enum (value2));
g_type_class_unref (klass1);
g_type_class_unref (klass2);
g_return_val_if_fail (en1, GST_VALUE_UNORDERED);
g_return_val_if_fail (en2, GST_VALUE_UNORDERED);
if (en1->value < en2->value)
return GST_VALUE_LESS_THAN;
if (en1->value > en2->value)
return GST_VALUE_GREATER_THAN;
return GST_VALUE_EQUAL;
}
static gchar *
gst_value_serialize_enum (const GValue * value)
{
GEnumValue *en;
GEnumClass *klass = (GEnumClass *) g_type_class_ref (G_VALUE_TYPE (value));
g_return_val_if_fail (klass, NULL);
en = g_enum_get_value (klass, g_value_get_enum (value));
g_type_class_unref (klass);
/* might be one of the custom formats registered later */
if (G_UNLIKELY (en == NULL && G_VALUE_TYPE (value) == GST_TYPE_FORMAT)) {
const GstFormatDefinition *format_def;
format_def = gst_format_get_details ((GstFormat) g_value_get_enum (value));
g_return_val_if_fail (format_def != NULL, NULL);
return g_strdup (format_def->description);
}
g_return_val_if_fail (en, NULL);
return g_strdup (en->value_name);
}
static gint
gst_value_deserialize_enum_iter_cmp (const GValue * format_def_value,
const gchar * s)
{
const GstFormatDefinition *format_def =
g_value_get_pointer (format_def_value);
if (g_ascii_strcasecmp (s, format_def->nick) == 0)
return 0;
return g_ascii_strcasecmp (s, format_def->description);
}
static gboolean
gst_value_deserialize_enum (GValue * dest, const gchar * s)
{
GEnumValue *en;
gchar *endptr = NULL;
GEnumClass *klass = (GEnumClass *) g_type_class_ref (G_VALUE_TYPE (dest));
g_return_val_if_fail (klass, FALSE);
if (!(en = g_enum_get_value_by_name (klass, s))) {
if (!(en = g_enum_get_value_by_nick (klass, s))) {
gint i = strtol (s, &endptr, 0);
if (endptr && *endptr == '\0') {
en = g_enum_get_value (klass, i);
}
}
}
g_type_class_unref (klass);
/* might be one of the custom formats registered later */
if (G_UNLIKELY (en == NULL && G_VALUE_TYPE (dest) == GST_TYPE_FORMAT)) {
GValue res = { 0, };
const GstFormatDefinition *format_def;
GstIterator *iter;
gboolean found;
iter = gst_format_iterate_definitions ();
found = gst_iterator_find_custom (iter,
(GCompareFunc) gst_value_deserialize_enum_iter_cmp, &res, (gpointer) s);
g_return_val_if_fail (found, FALSE);
format_def = g_value_get_pointer (&res);
g_return_val_if_fail (format_def != NULL, FALSE);
g_value_set_enum (dest, (gint) format_def->value);
g_value_unset (&res);
gst_iterator_free (iter);
return TRUE;
}
g_return_val_if_fail (en, FALSE);
g_value_set_enum (dest, en->value);
return TRUE;
}
/********
* flags *
********/
/* we just compare the value here */
static gint
gst_value_compare_flags (const GValue * value1, const GValue * value2)
{
guint fl1, fl2;
GFlagsClass *klass1 =
(GFlagsClass *) g_type_class_ref (G_VALUE_TYPE (value1));
GFlagsClass *klass2 =
(GFlagsClass *) g_type_class_ref (G_VALUE_TYPE (value2));
g_return_val_if_fail (klass1, GST_VALUE_UNORDERED);
g_return_val_if_fail (klass2, GST_VALUE_UNORDERED);
fl1 = g_value_get_flags (value1);
fl2 = g_value_get_flags (value2);
g_type_class_unref (klass1);
g_type_class_unref (klass2);
if (fl1 < fl2)
return GST_VALUE_LESS_THAN;
if (fl1 > fl2)
return GST_VALUE_GREATER_THAN;
return GST_VALUE_EQUAL;
}
/* the different flags are serialized separated with a + */
static gchar *
gst_value_serialize_flags (const GValue * value)
{
guint flags;
GFlagsValue *fl;
GFlagsClass *klass = (GFlagsClass *) g_type_class_ref (G_VALUE_TYPE (value));
gchar *result, *tmp;
gboolean first = TRUE;
g_return_val_if_fail (klass, NULL);
flags = g_value_get_flags (value);
/* if no flags are set, try to serialize to the _NONE string */
if (!flags) {
fl = g_flags_get_first_value (klass, flags);
return g_strdup (fl->value_name);
}
/* some flags are set, so serialize one by one */
result = g_strdup ("");
while (flags) {
fl = g_flags_get_first_value (klass, flags);
if (fl != NULL) {
tmp = g_strconcat (result, (first ? "" : "+"), fl->value_name, NULL);
g_free (result);
result = tmp;
first = FALSE;
/* clear flag */
flags &= ~fl->value;
}
}
g_type_class_unref (klass);
return result;
}
static gboolean
gst_value_deserialize_flags (GValue * dest, const gchar * s)
{
GFlagsValue *fl;
gchar *endptr = NULL;
GFlagsClass *klass = (GFlagsClass *) g_type_class_ref (G_VALUE_TYPE (dest));
gchar **split;
guint flags;
gint i;
g_return_val_if_fail (klass, FALSE);
/* split into parts delimited with + */
split = g_strsplit (s, "+", 0);
flags = 0;
i = 0;
/* loop over each part */
while (split[i]) {
if (!(fl = g_flags_get_value_by_name (klass, split[i]))) {
if (!(fl = g_flags_get_value_by_nick (klass, split[i]))) {
gint val = strtol (split[i], &endptr, 0);
/* just or numeric value */
if (endptr && *endptr == '\0') {
flags |= val;
}
}
}
if (fl) {
flags |= fl->value;
}
i++;
}
g_strfreev (split);
g_type_class_unref (klass);
g_value_set_flags (dest, flags);
return TRUE;
}
/****************
* subset *
****************/
static gboolean
gst_value_is_subset_int_range_int_range (const GValue * value1,
const GValue * value2)
{
gint gcd;
g_return_val_if_fail (GST_VALUE_HOLDS_INT_RANGE (value1), FALSE);
g_return_val_if_fail (GST_VALUE_HOLDS_INT_RANGE (value2), FALSE);
if (INT_RANGE_MIN (value1) * INT_RANGE_STEP (value1) <
INT_RANGE_MIN (value2) * INT_RANGE_STEP (value2))
return FALSE;
if (INT_RANGE_MAX (value1) * INT_RANGE_STEP (value1) >
INT_RANGE_MAX (value2) * INT_RANGE_STEP (value2))
return FALSE;
if (INT_RANGE_MIN (value2) == INT_RANGE_MAX (value2)) {
if ((INT_RANGE_MIN (value2) * INT_RANGE_STEP (value2)) %
INT_RANGE_STEP (value1))
return FALSE;
return TRUE;
}
gcd =
gst_util_greatest_common_divisor (INT_RANGE_STEP (value1),
INT_RANGE_STEP (value2));
if (gcd != MIN (INT_RANGE_STEP (value1), INT_RANGE_STEP (value2)))
return FALSE;
return TRUE;
}
static gboolean
gst_value_is_subset_int64_range_int64_range (const GValue * value1,
const GValue * value2)
{
gint64 gcd;
g_return_val_if_fail (GST_VALUE_HOLDS_INT64_RANGE (value1), FALSE);
g_return_val_if_fail (GST_VALUE_HOLDS_INT64_RANGE (value2), FALSE);
if (INT64_RANGE_MIN (value1) < INT64_RANGE_MIN (value2))
return FALSE;
if (INT64_RANGE_MAX (value1) > INT64_RANGE_MAX (value2))
return FALSE;
if (INT64_RANGE_MIN (value2) == INT64_RANGE_MAX (value2)) {
if ((INT64_RANGE_MIN (value2) * INT64_RANGE_STEP (value2)) %
INT64_RANGE_STEP (value1))
return FALSE;
return TRUE;
}
gcd =
gst_util_greatest_common_divisor_int64 (INT64_RANGE_STEP (value1),
INT64_RANGE_STEP (value2));
if (gcd != MIN (INT64_RANGE_STEP (value1), INT64_RANGE_STEP (value2)))
return FALSE;
return TRUE;
}
/**
* gst_value_is_subset:
* @value1: a #GValue
* @value2: a #GValue
*
* Check that @value1 is a subset of @value2.
*
* Return: %TRUE is @value1 is a subset of @value2
*/
gboolean
gst_value_is_subset (const GValue * value1, const GValue * value2)
{
/* special case for int/int64 ranges, since we cannot compute
the difference for those when they have different steps,
and it's actually a lot simpler to compute whether a range
is a subset of another. */
if (GST_VALUE_HOLDS_INT_RANGE (value1) && GST_VALUE_HOLDS_INT_RANGE (value2)) {
return gst_value_is_subset_int_range_int_range (value1, value2);
} else if (GST_VALUE_HOLDS_INT64_RANGE (value1)
&& GST_VALUE_HOLDS_INT64_RANGE (value2)) {
return gst_value_is_subset_int64_range_int64_range (value1, value2);
}
/*
* 1 - [1,2] = empty
* -> !subset
*
* [1,2] - 1 = 2
* -> 1 - [1,2] = empty
* -> subset
*
* [1,3] - [1,2] = 3
* -> [1,2] - [1,3] = empty
* -> subset
*
* {1,2} - {1,3} = 2
* -> {1,3} - {1,2} = 3
* -> !subset
*
* First caps subtraction needs to return a non-empty set, second
* subtractions needs to give en empty set.
* Both substractions are switched below, as it's faster that way.
*/
if (!gst_value_subtract (NULL, value1, value2)) {
if (gst_value_subtract (NULL, value2, value1)) {
return TRUE;
}
}
return FALSE;
}
/*********
* union *
*********/
static gboolean
gst_value_union_int_int_range (GValue * dest, const GValue * src1,
const GValue * src2)
{
gint v = src1->data[0].v_int;
/* check if it's already in the range */
if (INT_RANGE_MIN (src2) * INT_RANGE_STEP (src2) <= v &&
INT_RANGE_MAX (src2) * INT_RANGE_STEP (src2) >= v &&
v % INT_RANGE_STEP (src2) == 0) {
if (dest)
gst_value_init_and_copy (dest, src2);
return TRUE;
}
/* check if it extends the range */
if (v == (INT_RANGE_MIN (src2) - 1) * INT_RANGE_STEP (src2)) {
if (dest) {
gst_value_init_and_copy (dest, src2);
--INT_RANGE_MIN (src2);
}
return TRUE;
}
if (v == (INT_RANGE_MAX (src2) + 1) * INT_RANGE_STEP (src2)) {
if (dest) {
gst_value_init_and_copy (dest, src2);
++INT_RANGE_MAX (src2);
}
return TRUE;
}
return FALSE;
}
static gboolean
gst_value_union_int_range_int_range (GValue * dest, const GValue * src1,
const GValue * src2)
{
/* We can union in several special cases:
1 - one is a subset of another
2 - same step and not disjoint
3 - different step, at least one with one value which matches a 'next' or 'previous'
- anything else ?
*/
/* 1 - subset */
if (gst_value_is_subset_int_range_int_range (src1, src2)) {
if (dest)
gst_value_init_and_copy (dest, src2);
return TRUE;
}
if (gst_value_is_subset_int_range_int_range (src2, src1)) {
if (dest)
gst_value_init_and_copy (dest, src1);
return TRUE;
}
/* 2 - same step and not disjoint */
if (INT_RANGE_STEP (src1) == INT_RANGE_STEP (src2)) {
if ((INT_RANGE_MIN (src1) <= INT_RANGE_MAX (src2) + 1 &&
INT_RANGE_MAX (src1) >= INT_RANGE_MIN (src2) - 1) ||
(INT_RANGE_MIN (src2) <= INT_RANGE_MAX (src1) + 1 &&
INT_RANGE_MAX (src2) >= INT_RANGE_MIN (src1) - 1)) {
if (dest) {
gint step = INT_RANGE_STEP (src1);
gint min = step * MIN (INT_RANGE_MIN (src1), INT_RANGE_MIN (src2));
gint max = step * MAX (INT_RANGE_MAX (src1), INT_RANGE_MAX (src2));
g_value_init (dest, GST_TYPE_INT_RANGE);
gst_value_set_int_range_step (dest, min, max, step);
}
return TRUE;
}
}
/* 3 - single value matches next or previous */
if (INT_RANGE_STEP (src1) != INT_RANGE_STEP (src2)) {
gint n1 = INT_RANGE_MAX (src1) - INT_RANGE_MIN (src1) + 1;
gint n2 = INT_RANGE_MAX (src2) - INT_RANGE_MIN (src2) + 1;
if (n1 == 1 || n2 == 1) {
const GValue *range_value = NULL;
gint scalar = 0;
if (n1 == 1) {
range_value = src2;
scalar = INT_RANGE_MIN (src1) * INT_RANGE_STEP (src1);
} else if (n2 == 1) {
range_value = src1;
scalar = INT_RANGE_MIN (src2) * INT_RANGE_STEP (src2);
}
if (scalar ==
(INT_RANGE_MIN (range_value) - 1) * INT_RANGE_STEP (range_value)) {
if (dest) {
gst_value_init_and_copy (dest, range_value);
--INT_RANGE_MIN (range_value);
}
return TRUE;
} else if (scalar ==
(INT_RANGE_MAX (range_value) + 1) * INT_RANGE_STEP (range_value)) {
if (dest) {
gst_value_init_and_copy (dest, range_value);
++INT_RANGE_MIN (range_value);
}
return TRUE;
}
}
}
/* If we get there, we did not find a way to make a union that can be
represented with our simplistic model. */
return FALSE;
}
/****************
* intersection *
****************/
static gboolean
gst_value_intersect_int_int_range (GValue * dest, const GValue * src1,
const GValue * src2)
{
if (INT_RANGE_MIN (src2) * INT_RANGE_STEP (src2) <= src1->data[0].v_int &&
INT_RANGE_MAX (src2) * INT_RANGE_STEP (src2) >= src1->data[0].v_int &&
src1->data[0].v_int % INT_RANGE_STEP (src2) == 0) {
if (dest)
gst_value_init_and_copy (dest, src1);
return TRUE;
}
return FALSE;
}
static gboolean
gst_value_intersect_int_range_int_range (GValue * dest, const GValue * src1,
const GValue * src2)
{
gint min;
gint max;
gint step;
step =
INT_RANGE_STEP (src1) /
gst_util_greatest_common_divisor (INT_RANGE_STEP (src1),
INT_RANGE_STEP (src2));
if (G_MAXINT32 / INT_RANGE_STEP (src2) < step)
return FALSE;
step *= INT_RANGE_STEP (src2);
min =
MAX (INT_RANGE_MIN (src1) * INT_RANGE_STEP (src1),
INT_RANGE_MIN (src2) * INT_RANGE_STEP (src2));
min = (min + step - 1) / step * step;
max =
MIN (INT_RANGE_MAX (src1) * INT_RANGE_STEP (src1),
INT_RANGE_MAX (src2) * INT_RANGE_STEP (src2));
max = max / step * step;
if (min < max) {
if (dest) {
g_value_init (dest, GST_TYPE_INT_RANGE);
gst_value_set_int_range_step (dest, min, max, step);
}
return TRUE;
}
if (min == max) {
if (dest) {
g_value_init (dest, G_TYPE_INT);
g_value_set_int (dest, min);
}
return TRUE;
}
return FALSE;
}
#define INT64_RANGE_MIN_VAL(v) (INT64_RANGE_MIN (v) * INT64_RANGE_STEP (v))
#define INT64_RANGE_MAX_VAL(v) (INT64_RANGE_MAX (v) * INT64_RANGE_STEP (v))
static gboolean
gst_value_intersect_int64_int64_range (GValue * dest, const GValue * src1,
const GValue * src2)
{
if (INT64_RANGE_MIN_VAL (src2) <= src1->data[0].v_int64 &&
INT64_RANGE_MAX_VAL (src2) >= src1->data[0].v_int64 &&
src1->data[0].v_int64 % INT64_RANGE_STEP (src2) == 0) {
if (dest)
gst_value_init_and_copy (dest, src1);
return TRUE;
}
return FALSE;
}
static gboolean
gst_value_intersect_int64_range_int64_range (GValue * dest, const GValue * src1,
const GValue * src2)
{
gint64 min;
gint64 max;
gint64 step;
step =
INT64_RANGE_STEP (src1) /
gst_util_greatest_common_divisor_int64 (INT64_RANGE_STEP (src1),
INT64_RANGE_STEP (src2));
if (G_MAXINT64 / INT64_RANGE_STEP (src2) < step)
return FALSE;
step *= INT64_RANGE_STEP (src2);
min =
MAX (INT64_RANGE_MIN (src1) * INT64_RANGE_STEP (src1),
INT64_RANGE_MIN (src2) * INT64_RANGE_STEP (src2));
min = (min + step - 1) / step * step;
max =
MIN (INT64_RANGE_MAX (src1) * INT64_RANGE_STEP (src1),
INT64_RANGE_MAX (src2) * INT64_RANGE_STEP (src2));
max = max / step * step;
if (min < max) {
if (dest) {
g_value_init (dest, GST_TYPE_INT64_RANGE);
gst_value_set_int64_range_step (dest, min, max, step);
}
return TRUE;
}
if (min == max) {
if (dest) {
g_value_init (dest, G_TYPE_INT64);
g_value_set_int64 (dest, min);
}
return TRUE;
}
return FALSE;
}
static gboolean
gst_value_intersect_double_double_range (GValue * dest, const GValue * src1,
const GValue * src2)
{
if (src2->data[0].v_double <= src1->data[0].v_double &&
src2->data[1].v_double >= src1->data[0].v_double) {
if (dest)
gst_value_init_and_copy (dest, src1);
return TRUE;
}
return FALSE;
}
static gboolean
gst_value_intersect_double_range_double_range (GValue * dest,
const GValue * src1, const GValue * src2)
{
gdouble min;
gdouble max;
min = MAX (src1->data[0].v_double, src2->data[0].v_double);
max = MIN (src1->data[1].v_double, src2->data[1].v_double);
if (min < max) {
if (dest) {
g_value_init (dest, GST_TYPE_DOUBLE_RANGE);
gst_value_set_double_range (dest, min, max);
}
return TRUE;
}
if (min == max) {
if (dest) {
g_value_init (dest, G_TYPE_DOUBLE);
g_value_set_int (dest, (int) min);
}
return TRUE;
}
return FALSE;
}
static gboolean
gst_value_intersect_list (GValue * dest, const GValue * value1,
const GValue * value2)
{
guint i, size;
GValue intersection = { 0, };
gboolean ret = FALSE;
size = VALUE_LIST_SIZE (value1);
for (i = 0; i < size; i++) {
const GValue *cur = VALUE_LIST_GET_VALUE (value1, i);
/* quicker version when we don't need the resulting set */
if (!dest) {
if (gst_value_intersect (NULL, cur, value2)) {
ret = TRUE;
break;
}
continue;
}
if (gst_value_intersect (&intersection, cur, value2)) {
/* append value */
if (!ret) {
gst_value_init_and_copy (dest, &intersection);
ret = TRUE;
} else if (GST_VALUE_HOLDS_LIST (dest)) {
gst_value_list_append_value (dest, &intersection);
} else {
GValue temp = { 0, };
gst_value_init_and_copy (&temp, dest);
g_value_unset (dest);
gst_value_list_concat (dest, &temp, &intersection);
g_value_unset (&temp);
}
g_value_unset (&intersection);
}
}
return ret;
}
static gboolean
gst_value_intersect_array (GValue * dest, const GValue * src1,
const GValue * src2)
{
guint size;
guint n;
GValue val = { 0 };
/* only works on similar-sized arrays */
size = gst_value_array_get_size (src1);
if (size != gst_value_array_get_size (src2))
return FALSE;
/* quicker value when we don't need the resulting set */
if (!dest) {
for (n = 0; n < size; n++) {
if (!gst_value_intersect (NULL, gst_value_array_get_value (src1, n),
gst_value_array_get_value (src2, n))) {
return FALSE;
}
}
return TRUE;
}
g_value_init (dest, GST_TYPE_ARRAY);
for (n = 0; n < size; n++) {
if (!gst_value_intersect (&val, gst_value_array_get_value (src1, n),
gst_value_array_get_value (src2, n))) {
g_value_unset (dest);
return FALSE;
}
gst_value_array_append_value (dest, &val);
g_value_unset (&val);
}
return TRUE;
}
static gboolean
gst_value_intersect_fraction_fraction_range (GValue * dest, const GValue * src1,
const GValue * src2)
{
gint res1, res2;
GValue *vals;
GstValueCompareFunc compare;
vals = src2->data[0].v_pointer;
if (vals == NULL)
return FALSE;
if ((compare = gst_value_get_compare_func (src1))) {
res1 = gst_value_compare_with_func (&vals[0], src1, compare);
res2 = gst_value_compare_with_func (&vals[1], src1, compare);
if ((res1 == GST_VALUE_EQUAL || res1 == GST_VALUE_LESS_THAN) &&
(res2 == GST_VALUE_EQUAL || res2 == GST_VALUE_GREATER_THAN)) {
if (dest)
gst_value_init_and_copy (dest, src1);
return TRUE;
}
}
return FALSE;
}
static gboolean
gst_value_intersect_fraction_range_fraction_range (GValue * dest,
const GValue * src1, const GValue * src2)
{
GValue *min;
GValue *max;
gint res;
GValue *vals1, *vals2;
GstValueCompareFunc compare;
vals1 = src1->data[0].v_pointer;
vals2 = src2->data[0].v_pointer;
g_return_val_if_fail (vals1 != NULL && vals2 != NULL, FALSE);
if ((compare = gst_value_get_compare_func (&vals1[0]))) {
/* min = MAX (src1.start, src2.start) */
res = gst_value_compare_with_func (&vals1[0], &vals2[0], compare);
g_return_val_if_fail (res != GST_VALUE_UNORDERED, FALSE);
if (res == GST_VALUE_LESS_THAN)
min = &vals2[0]; /* Take the max of the 2 */
else
min = &vals1[0];
/* max = MIN (src1.end, src2.end) */
res = gst_value_compare_with_func (&vals1[1], &vals2[1], compare);
g_return_val_if_fail (res != GST_VALUE_UNORDERED, FALSE);
if (res == GST_VALUE_GREATER_THAN)
max = &vals2[1]; /* Take the min of the 2 */
else
max = &vals1[1];
res = gst_value_compare_with_func (min, max, compare);
g_return_val_if_fail (res != GST_VALUE_UNORDERED, FALSE);
if (res == GST_VALUE_LESS_THAN) {
if (dest) {
g_value_init (dest, GST_TYPE_FRACTION_RANGE);
vals1 = dest->data[0].v_pointer;
g_value_copy (min, &vals1[0]);
g_value_copy (max, &vals1[1]);
}
return TRUE;
}
if (res == GST_VALUE_EQUAL) {
if (dest)
gst_value_init_and_copy (dest, min);
return TRUE;
}
}
return FALSE;
}
/***************
* subtraction *
***************/
static gboolean
gst_value_subtract_int_int_range (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
gint min = gst_value_get_int_range_min (subtrahend);
gint max = gst_value_get_int_range_max (subtrahend);
gint step = gst_value_get_int_range_step (subtrahend);
gint val = g_value_get_int (minuend);
/* subtracting a range from an int only works if the int is not in the
* range */
if (val < min || val > max || val % step) {
/* and the result is the int */
if (dest)
gst_value_init_and_copy (dest, minuend);
return TRUE;
}
return FALSE;
}
/* creates a new int range based on input values.
*/
static gboolean
gst_value_create_new_range (GValue * dest, gint min1, gint max1, gint min2,
gint max2, gint step)
{
GValue v1 = { 0, };
GValue v2 = { 0, };
GValue *pv1, *pv2; /* yeah, hungarian! */
g_return_val_if_fail (step > 0, FALSE);
g_return_val_if_fail (min1 % step == 0, FALSE);
g_return_val_if_fail (max1 % step == 0, FALSE);
g_return_val_if_fail (min2 % step == 0, FALSE);
g_return_val_if_fail (max2 % step == 0, FALSE);
if (min1 <= max1 && min2 <= max2) {
pv1 = &v1;
pv2 = &v2;
} else if (min1 <= max1) {
pv1 = dest;
pv2 = NULL;
} else if (min2 <= max2) {
pv1 = NULL;
pv2 = dest;
} else {
return FALSE;
}
if (!dest)
return TRUE;
if (min1 < max1) {
g_value_init (pv1, GST_TYPE_INT_RANGE);
gst_value_set_int_range_step (pv1, min1, max1, step);
} else if (min1 == max1) {
g_value_init (pv1, G_TYPE_INT);
g_value_set_int (pv1, min1);
}
if (min2 < max2) {
g_value_init (pv2, GST_TYPE_INT_RANGE);
gst_value_set_int_range_step (pv2, min2, max2, step);
} else if (min2 == max2) {
g_value_init (pv2, G_TYPE_INT);
g_value_set_int (pv2, min2);
}
if (min1 <= max1 && min2 <= max2) {
gst_value_list_concat (dest, pv1, pv2);
g_value_unset (pv1);
g_value_unset (pv2);
}
return TRUE;
}
static gboolean
gst_value_subtract_int_range_int (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
gint min = gst_value_get_int_range_min (minuend);
gint max = gst_value_get_int_range_max (minuend);
gint step = gst_value_get_int_range_step (minuend);
gint val = g_value_get_int (subtrahend);
g_return_val_if_fail (min < max, FALSE);
/* value is outside of the range, return range unchanged */
if (val < min || val > max || val % step) {
if (dest)
gst_value_init_and_copy (dest, minuend);
return TRUE;
} else {
/* max must be MAXINT too as val <= max */
if (val >= G_MAXINT - step + 1) {
max -= step;
val -= step;
}
/* min must be MININT too as val >= max */
if (val <= G_MININT + step - 1) {
min += step;
val += step;
}
if (dest)
gst_value_create_new_range (dest, min, val - step, val + step, max, step);
}
return TRUE;
}
static gboolean
gst_value_subtract_int_range_int_range (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
gint min1 = gst_value_get_int_range_min (minuend);
gint max1 = gst_value_get_int_range_max (minuend);
gint step1 = gst_value_get_int_range_step (minuend);
gint min2 = gst_value_get_int_range_min (subtrahend);
gint max2 = gst_value_get_int_range_max (subtrahend);
gint step2 = gst_value_get_int_range_step (subtrahend);
gint step;
if (step1 != step2) {
/* ENOIMPL */
g_assert (FALSE);
return FALSE;
}
step = step1;
if (max2 >= max1 && min2 <= min1) {
return FALSE;
} else if (max2 >= max1) {
return gst_value_create_new_range (dest, min1, MIN (min2 - step, max1),
step, 0, step);
} else if (min2 <= min1) {
return gst_value_create_new_range (dest, MAX (max2 + step, min1), max1,
step, 0, step);
} else {
return gst_value_create_new_range (dest, min1, MIN (min2 - step, max1),
MAX (max2 + step, min1), max1, step);
}
}
static gboolean
gst_value_subtract_int64_int64_range (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
gint64 min = gst_value_get_int64_range_min (subtrahend);
gint64 max = gst_value_get_int64_range_max (subtrahend);
gint64 step = gst_value_get_int64_range_step (subtrahend);
gint64 val = g_value_get_int64 (minuend);
/* subtracting a range from an int64 only works if the int64 is not in the
* range */
if (val < min || val > max || val % step) {
/* and the result is the int64 */
if (dest)
gst_value_init_and_copy (dest, minuend);
return TRUE;
}
return FALSE;
}
/* creates a new int64 range based on input values.
*/
static gboolean
gst_value_create_new_int64_range (GValue * dest, gint64 min1, gint64 max1,
gint64 min2, gint64 max2, gint64 step)
{
GValue v1 = { 0, };
GValue v2 = { 0, };
GValue *pv1, *pv2; /* yeah, hungarian! */
g_return_val_if_fail (step > 0, FALSE);
g_return_val_if_fail (min1 % step == 0, FALSE);
g_return_val_if_fail (max1 % step == 0, FALSE);
g_return_val_if_fail (min2 % step == 0, FALSE);
g_return_val_if_fail (max2 % step == 0, FALSE);
if (min1 <= max1 && min2 <= max2) {
pv1 = &v1;
pv2 = &v2;
} else if (min1 <= max1) {
pv1 = dest;
pv2 = NULL;
} else if (min2 <= max2) {
pv1 = NULL;
pv2 = dest;
} else {
return FALSE;
}
if (!dest)
return TRUE;
if (min1 < max1) {
g_value_init (pv1, GST_TYPE_INT64_RANGE);
gst_value_set_int64_range_step (pv1, min1, max1, step);
} else if (min1 == max1) {
g_value_init (pv1, G_TYPE_INT64);
g_value_set_int64 (pv1, min1);
}
if (min2 < max2) {
g_value_init (pv2, GST_TYPE_INT64_RANGE);
gst_value_set_int64_range_step (pv2, min2, max2, step);
} else if (min2 == max2) {
g_value_init (pv2, G_TYPE_INT64);
g_value_set_int64 (pv2, min2);
}
if (min1 <= max1 && min2 <= max2) {
gst_value_list_concat (dest, pv1, pv2);
g_value_unset (pv1);
g_value_unset (pv2);
}
return TRUE;
}
static gboolean
gst_value_subtract_int64_range_int64 (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
gint64 min = gst_value_get_int64_range_min (minuend);
gint64 max = gst_value_get_int64_range_max (minuend);
gint64 step = gst_value_get_int64_range_step (minuend);
gint64 val = g_value_get_int64 (subtrahend);
g_return_val_if_fail (min < max, FALSE);
/* value is outside of the range, return range unchanged */
if (val < min || val > max || val % step) {
if (dest)
gst_value_init_and_copy (dest, minuend);
return TRUE;
} else {
/* max must be MAXINT64 too as val <= max */
if (val >= G_MAXINT64 - step + 1) {
max -= step;
val -= step;
}
/* min must be MININT64 too as val >= max */
if (val <= G_MININT64 + step - 1) {
min += step;
val += step;
}
if (dest)
gst_value_create_new_int64_range (dest, min, val - step, val + step, max,
step);
}
return TRUE;
}
static gboolean
gst_value_subtract_int64_range_int64_range (GValue * dest,
const GValue * minuend, const GValue * subtrahend)
{
gint64 min1 = gst_value_get_int64_range_min (minuend);
gint64 max1 = gst_value_get_int64_range_max (minuend);
gint64 step1 = gst_value_get_int64_range_step (minuend);
gint64 min2 = gst_value_get_int64_range_min (subtrahend);
gint64 max2 = gst_value_get_int64_range_max (subtrahend);
gint64 step2 = gst_value_get_int64_range_step (subtrahend);
gint64 step;
if (step1 != step2) {
/* ENOIMPL */
g_assert (FALSE);
return FALSE;
}
step = step1;
if (max2 >= max1 && min2 <= min1) {
return FALSE;
} else if (max2 >= max1) {
return gst_value_create_new_int64_range (dest, min1, MIN (min2 - step,
max1), step, 0, step);
} else if (min2 <= min1) {
return gst_value_create_new_int64_range (dest, MAX (max2 + step, min1),
max1, step, 0, step);
} else {
return gst_value_create_new_int64_range (dest, min1, MIN (min2 - step,
max1), MAX (max2 + step, min1), max1, step);
}
}
static gboolean
gst_value_subtract_double_double_range (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
gdouble min = gst_value_get_double_range_min (subtrahend);
gdouble max = gst_value_get_double_range_max (subtrahend);
gdouble val = g_value_get_double (minuend);
if (val < min || val > max) {
if (dest)
gst_value_init_and_copy (dest, minuend);
return TRUE;
}
return FALSE;
}
static gboolean
gst_value_subtract_double_range_double (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
/* since we don't have open ranges, we cannot create a hole in
* a double range. We return the original range */
if (dest)
gst_value_init_and_copy (dest, minuend);
return TRUE;
}
static gboolean
gst_value_subtract_double_range_double_range (GValue * dest,
const GValue * minuend, const GValue * subtrahend)
{
/* since we don't have open ranges, we have to approximate */
/* done like with ints */
gdouble min1 = gst_value_get_double_range_min (minuend);
gdouble max2 = gst_value_get_double_range_max (minuend);
gdouble max1 = MIN (gst_value_get_double_range_min (subtrahend), max2);
gdouble min2 = MAX (gst_value_get_double_range_max (subtrahend), min1);
GValue v1 = { 0, };
GValue v2 = { 0, };
GValue *pv1, *pv2; /* yeah, hungarian! */
if (min1 < max1 && min2 < max2) {
pv1 = &v1;
pv2 = &v2;
} else if (min1 < max1) {
pv1 = dest;
pv2 = NULL;
} else if (min2 < max2) {
pv1 = NULL;
pv2 = dest;
} else {
return FALSE;
}
if (!dest)
return TRUE;
if (min1 < max1) {
g_value_init (pv1, GST_TYPE_DOUBLE_RANGE);
gst_value_set_double_range (pv1, min1, max1);
}
if (min2 < max2) {
g_value_init (pv2, GST_TYPE_DOUBLE_RANGE);
gst_value_set_double_range (pv2, min2, max2);
}
if (min1 < max1 && min2 < max2) {
gst_value_list_concat (dest, pv1, pv2);
g_value_unset (pv1);
g_value_unset (pv2);
}
return TRUE;
}
static gboolean
gst_value_subtract_from_list (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
guint i, size;
GValue subtraction = { 0, };
gboolean ret = FALSE;
GType ltype;
ltype = gst_value_list_get_type ();
size = VALUE_LIST_SIZE (minuend);
for (i = 0; i < size; i++) {
const GValue *cur = VALUE_LIST_GET_VALUE (minuend, i);
/* quicker version when we can discard the result */
if (!dest) {
if (gst_value_subtract (NULL, cur, subtrahend)) {
ret = TRUE;
break;
}
continue;
}
if (gst_value_subtract (&subtraction, cur, subtrahend)) {
if (!ret) {
gst_value_init_and_copy (dest, &subtraction);
ret = TRUE;
} else if (G_VALUE_HOLDS (dest, ltype)
&& !G_VALUE_HOLDS (&subtraction, ltype)) {
gst_value_list_append_value (dest, &subtraction);
} else {
GValue temp = { 0, };
gst_value_init_and_copy (&temp, dest);
g_value_unset (dest);
gst_value_list_concat (dest, &temp, &subtraction);
g_value_unset (&temp);
}
g_value_unset (&subtraction);
}
}
return ret;
}
static gboolean
gst_value_subtract_list (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
guint i, size;
GValue data[2] = { {0,}, {0,} };
GValue *subtraction = &data[0], *result = &data[1];
gst_value_init_and_copy (result, minuend);
size = VALUE_LIST_SIZE (subtrahend);
for (i = 0; i < size; i++) {
const GValue *cur = VALUE_LIST_GET_VALUE (subtrahend, i);
if (gst_value_subtract (subtraction, result, cur)) {
GValue *temp = result;
result = subtraction;
subtraction = temp;
g_value_unset (subtraction);
} else {
g_value_unset (result);
return FALSE;
}
}
if (dest)
gst_value_init_and_copy (dest, result);
g_value_unset (result);
return TRUE;
}
static gboolean
gst_value_subtract_fraction_fraction_range (GValue * dest,
const GValue * minuend, const GValue * subtrahend)
{
const GValue *min = gst_value_get_fraction_range_min (subtrahend);
const GValue *max = gst_value_get_fraction_range_max (subtrahend);
GstValueCompareFunc compare;
if ((compare = gst_value_get_compare_func (minuend))) {
/* subtracting a range from an fraction only works if the fraction
* is not in the range */
if (gst_value_compare_with_func (minuend, min, compare) ==
GST_VALUE_LESS_THAN ||
gst_value_compare_with_func (minuend, max, compare) ==
GST_VALUE_GREATER_THAN) {
/* and the result is the value */
if (dest)
gst_value_init_and_copy (dest, minuend);
return TRUE;
}
}
return FALSE;
}
static gboolean
gst_value_subtract_fraction_range_fraction (GValue * dest,
const GValue * minuend, const GValue * subtrahend)
{
/* since we don't have open ranges, we cannot create a hole in
* a range. We return the original range */
if (dest)
gst_value_init_and_copy (dest, minuend);
return TRUE;
}
static gboolean
gst_value_subtract_fraction_range_fraction_range (GValue * dest,
const GValue * minuend, const GValue * subtrahend)
{
/* since we don't have open ranges, we have to approximate */
/* done like with ints and doubles. Creates a list of 2 fraction ranges */
const GValue *min1 = gst_value_get_fraction_range_min (minuend);
const GValue *max2 = gst_value_get_fraction_range_max (minuend);
const GValue *max1 = gst_value_get_fraction_range_min (subtrahend);
const GValue *min2 = gst_value_get_fraction_range_max (subtrahend);
gint cmp1, cmp2;
GValue v1 = { 0, };
GValue v2 = { 0, };
GValue *pv1, *pv2; /* yeah, hungarian! */
GstValueCompareFunc compare;
g_return_val_if_fail (min1 != NULL && max1 != NULL, FALSE);
g_return_val_if_fail (min2 != NULL && max2 != NULL, FALSE);
compare = gst_value_get_compare_func (min1);
g_return_val_if_fail (compare, FALSE);
cmp1 = gst_value_compare_with_func (max2, max1, compare);
g_return_val_if_fail (cmp1 != GST_VALUE_UNORDERED, FALSE);
if (cmp1 == GST_VALUE_LESS_THAN)
max1 = max2;
cmp1 = gst_value_compare_with_func (min1, min2, compare);
g_return_val_if_fail (cmp1 != GST_VALUE_UNORDERED, FALSE);
if (cmp1 == GST_VALUE_GREATER_THAN)
min2 = min1;
cmp1 = gst_value_compare_with_func (min1, max1, compare);
cmp2 = gst_value_compare_with_func (min2, max2, compare);
if (cmp1 == GST_VALUE_LESS_THAN && cmp2 == GST_VALUE_LESS_THAN) {
pv1 = &v1;
pv2 = &v2;
} else if (cmp1 == GST_VALUE_LESS_THAN) {
pv1 = dest;
pv2 = NULL;
} else if (cmp2 == GST_VALUE_LESS_THAN) {
pv1 = NULL;
pv2 = dest;
} else {
return FALSE;
}
if (!dest)
return TRUE;
if (cmp1 == GST_VALUE_LESS_THAN) {
g_value_init (pv1, GST_TYPE_FRACTION_RANGE);
gst_value_set_fraction_range (pv1, min1, max1);
}
if (cmp2 == GST_VALUE_LESS_THAN) {
g_value_init (pv2, GST_TYPE_FRACTION_RANGE);
gst_value_set_fraction_range (pv2, min2, max2);
}
if (cmp1 == GST_VALUE_LESS_THAN && cmp2 == GST_VALUE_LESS_THAN) {
gst_value_list_concat (dest, pv1, pv2);
g_value_unset (pv1);
g_value_unset (pv2);
}
return TRUE;
}
/**************
* comparison *
**************/
/*
* gst_value_get_compare_func:
* @value1: a value to get the compare function for
*
* Determines the compare function to be used with values of the same type as
* @value1. The function can be given to gst_value_compare_with_func().
*
* Returns: A #GstValueCompareFunc value
*/
static GstValueCompareFunc
gst_value_get_compare_func (const GValue * value1)
{
GstValueTable *table, *best = NULL;
guint i;
GType type1;
type1 = G_VALUE_TYPE (value1);
/* this is a fast check */
best = gst_value_hash_lookup_type (type1);
/* slower checks */
if (G_UNLIKELY (!best || !best->compare)) {
guint len = gst_value_table->len;
best = NULL;
for (i = 0; i < len; i++) {
table = &g_array_index (gst_value_table, GstValueTable, i);
if (table->compare && g_type_is_a (type1, table->type)) {
if (!best || g_type_is_a (table->type, best->type))
best = table;
}
}
}
if (G_LIKELY (best))
return best->compare;
return NULL;
}
/**
* gst_value_can_compare:
* @value1: a value to compare
* @value2: another value to compare
*
* Determines if @value1 and @value2 can be compared.
*
* Returns: TRUE if the values can be compared
*/
gboolean
gst_value_can_compare (const GValue * value1, const GValue * value2)
{
g_return_val_if_fail (G_IS_VALUE (value1), FALSE);
g_return_val_if_fail (G_IS_VALUE (value2), FALSE);
if (G_VALUE_TYPE (value1) != G_VALUE_TYPE (value2))
return FALSE;
return gst_value_get_compare_func (value1) != NULL;
}
static gboolean
gst_value_list_equals_range (const GValue * list, const GValue * value)
{
const GValue *first;
guint list_size, n;
g_return_val_if_fail (G_IS_VALUE (list), FALSE);
g_return_val_if_fail (G_IS_VALUE (value), FALSE);
g_return_val_if_fail (GST_VALUE_HOLDS_LIST (list), FALSE);
/* TODO: compare against an empty list ? No type though... */
list_size = VALUE_LIST_SIZE (list);
if (list_size == 0)
return FALSE;
/* compare the basic types - they have to match */
first = VALUE_LIST_GET_VALUE (list, 0);
#define CHECK_TYPES(type,prefix) \
(prefix##_VALUE_HOLDS_##type(first) && GST_VALUE_HOLDS_##type##_RANGE (value))
if (CHECK_TYPES (INT, G)) {
const gint rmin = gst_value_get_int_range_min (value);
const gint rmax = gst_value_get_int_range_max (value);
const gint rstep = gst_value_get_int_range_step (value);
/* note: this will overflow for min 0 and max INT_MAX, but this
would only be equal to a list of INT_MAX elements, which seems
very unlikely */
if (list_size != rmax / rstep - rmin / rstep + 1)
return FALSE;
for (n = 0; n < list_size; ++n) {
gint v = g_value_get_int (VALUE_LIST_GET_VALUE (list, n));
if (v < rmin || v > rmax || v % rstep) {
return FALSE;
}
}
return TRUE;
} else if (CHECK_TYPES (INT64, G)) {
const gint64 rmin = gst_value_get_int64_range_min (value);
const gint64 rmax = gst_value_get_int64_range_max (value);
const gint64 rstep = gst_value_get_int64_range_step (value);
GST_DEBUG ("List/range of int64s");
if (list_size != rmax / rstep - rmin / rstep + 1)
return FALSE;
for (n = 0; n < list_size; ++n) {
gint64 v = g_value_get_int64 (VALUE_LIST_GET_VALUE (list, n));
if (v < rmin || v > rmax || v % rstep)
return FALSE;
}
return TRUE;
}
#undef CHECK_TYPES
/* other combinations don't make sense for equality */
return FALSE;
}
/**
* gst_value_compare:
* @value1: a value to compare
* @value2: another value to compare
*
* Compares @value1 and @value2. If @value1 and @value2 cannot be
* compared, the function returns GST_VALUE_UNORDERED. Otherwise,
* if @value1 is greater than @value2, GST_VALUE_GREATER_THAN is returned.
* If @value1 is less than @value2, GST_VALUE_LESS_THAN is returned.
* If the values are equal, GST_VALUE_EQUAL is returned.
*
* Returns: comparison result
*/
gint
gst_value_compare (const GValue * value1, const GValue * value2)
{
GstValueCompareFunc compare;
GType ltype;
g_return_val_if_fail (G_IS_VALUE (value1), GST_VALUE_LESS_THAN);
g_return_val_if_fail (G_IS_VALUE (value2), GST_VALUE_GREATER_THAN);
/* Special cases: lists and scalar values ("{ 1 }" and "1" are equal),
as well as lists and ranges ("{ 1, 2 }" and "[ 1, 2 ]" are equal) */
ltype = gst_value_list_get_type ();
if (G_VALUE_HOLDS (value1, ltype) && !G_VALUE_HOLDS (value2, ltype)) {
if (gst_value_list_equals_range (value1, value2)) {
return GST_VALUE_EQUAL;
} else if (gst_value_list_get_size (value1) == 1) {
const GValue *elt;
elt = gst_value_list_get_value (value1, 0);
return gst_value_compare (elt, value2);
}
} else if (G_VALUE_HOLDS (value2, ltype) && !G_VALUE_HOLDS (value1, ltype)) {
if (gst_value_list_equals_range (value2, value1)) {
return GST_VALUE_EQUAL;
} else if (gst_value_list_get_size (value2) == 1) {
const GValue *elt;
elt = gst_value_list_get_value (value2, 0);
return gst_value_compare (elt, value1);
}
}
if (G_VALUE_TYPE (value1) != G_VALUE_TYPE (value2))
return GST_VALUE_UNORDERED;
compare = gst_value_get_compare_func (value1);
if (compare) {
return compare (value1, value2);
}
g_critical ("unable to compare values of type %s\n",
g_type_name (G_VALUE_TYPE (value1)));
return GST_VALUE_UNORDERED;
}
/*
* gst_value_compare_with_func:
* @value1: a value to compare
* @value2: another value to compare
* @compare: compare function
*
* Compares @value1 and @value2 using the @compare function. Works like
* gst_value_compare() but allows to save time determining the compare function
* a multiple times.
*
* Returns: comparison result
*/
static gint
gst_value_compare_with_func (const GValue * value1, const GValue * value2,
GstValueCompareFunc compare)
{
g_assert (compare);
if (G_VALUE_TYPE (value1) != G_VALUE_TYPE (value2))
return GST_VALUE_UNORDERED;
return compare (value1, value2);
}
/* union */
/**
* gst_value_can_union:
* @value1: a value to union
* @value2: another value to union
*
* Determines if @value1 and @value2 can be non-trivially unioned.
* Any two values can be trivially unioned by adding both of them
* to a GstValueList. However, certain types have the possibility
* to be unioned in a simpler way. For example, an integer range
* and an integer can be unioned if the integer is a subset of the
* integer range. If there is the possibility that two values can
* be unioned, this function returns TRUE.
*
* Returns: TRUE if there is a function allowing the two values to
* be unioned.
*/
gboolean
gst_value_can_union (const GValue * value1, const GValue * value2)
{
GstValueUnionInfo *union_info;
guint i, len;
g_return_val_if_fail (G_IS_VALUE (value1), FALSE);
g_return_val_if_fail (G_IS_VALUE (value2), FALSE);
len = gst_value_union_funcs->len;
for (i = 0; i < len; i++) {
union_info = &g_array_index (gst_value_union_funcs, GstValueUnionInfo, i);
if (union_info->type1 == G_VALUE_TYPE (value1) &&
union_info->type2 == G_VALUE_TYPE (value2))
return TRUE;
if (union_info->type1 == G_VALUE_TYPE (value2) &&
union_info->type2 == G_VALUE_TYPE (value1))
return TRUE;
}
return FALSE;
}
/**
* gst_value_union:
* @dest: (out caller-allocates): the destination value
* @value1: a value to union
* @value2: another value to union
*
* Creates a GValue corresponding to the union of @value1 and @value2.
*
* Returns: TRUE if the union suceeded.
*/
gboolean
gst_value_union (GValue * dest, const GValue * value1, const GValue * value2)
{
const GstValueUnionInfo *union_info;
guint i, len;
GType type1, type2;
g_return_val_if_fail (dest != NULL, FALSE);
g_return_val_if_fail (G_IS_VALUE (value1), FALSE);
g_return_val_if_fail (G_IS_VALUE (value2), FALSE);
g_return_val_if_fail (gst_value_list_or_array_are_compatible (value1, value2),
FALSE);
len = gst_value_union_funcs->len;
type1 = G_VALUE_TYPE (value1);
type2 = G_VALUE_TYPE (value2);
for (i = 0; i < len; i++) {
union_info = &g_array_index (gst_value_union_funcs, GstValueUnionInfo, i);
if (union_info->type1 == type1 && union_info->type2 == type2) {
return union_info->func (dest, value1, value2);
}
if (union_info->type1 == type2 && union_info->type2 == type1) {
return union_info->func (dest, value2, value1);
}
}
gst_value_list_concat (dest, value1, value2);
return TRUE;
}
/* gst_value_register_union_func: (skip)
* @type1: a type to union
* @type2: another type to union
* @func: a function that implements creating a union between the two types
*
* Registers a union function that can create a union between #GValue items
* of the type @type1 and @type2.
*
* Union functions should be registered at startup before any pipelines are
* started, as gst_value_register_union_func() is not thread-safe and cannot
* be used at the same time as gst_value_union() or gst_value_can_union().
*/
static void
gst_value_register_union_func (GType type1, GType type2, GstValueUnionFunc func)
{
GstValueUnionInfo union_info;
union_info.type1 = type1;
union_info.type2 = type2;
union_info.func = func;
g_array_append_val (gst_value_union_funcs, union_info);
}
/* intersection */
/**
* gst_value_can_intersect:
* @value1: a value to intersect
* @value2: another value to intersect
*
* Determines if intersecting two values will produce a valid result.
* Two values will produce a valid intersection if they have the same
* type, or if there is a method (registered by
* gst_value_register_intersect_func()) to calculate the intersection.
*
* Returns: TRUE if the values can intersect
*/
gboolean
gst_value_can_intersect (const GValue * value1, const GValue * value2)
{
GstValueIntersectInfo *intersect_info;
guint i, len;
GType ltype, type1, type2;
g_return_val_if_fail (G_IS_VALUE (value1), FALSE);
g_return_val_if_fail (G_IS_VALUE (value2), FALSE);
ltype = gst_value_list_get_type ();
/* special cases */
if (G_VALUE_HOLDS (value1, ltype) || G_VALUE_HOLDS (value2, ltype))
return TRUE;
type1 = G_VALUE_TYPE (value1);
type2 = G_VALUE_TYPE (value2);
/* practically all GstValue types have a compare function (_can_compare=TRUE)
* GstStructure and GstCaps have npot, but are intersectable */
if (type1 == type2)
return TRUE;
/* check registered intersect functions */
len = gst_value_intersect_funcs->len;
for (i = 0; i < len; i++) {
intersect_info = &g_array_index (gst_value_intersect_funcs,
GstValueIntersectInfo, i);
if ((intersect_info->type1 == type1 && intersect_info->type2 == type2) ||
(intersect_info->type1 == type2 && intersect_info->type2 == type1))
return TRUE;
}
return gst_value_can_compare (value1, value2);
}
/**
* gst_value_intersect:
* @dest: (out caller-allocates) (transfer full): a uninitialized #GValue that will hold the calculated
* intersection value. May be NULL if the resulting set if not needed.
* @value1: a value to intersect
* @value2: another value to intersect
*
* Calculates the intersection of two values. If the values have
* a non-empty intersection, the value representing the intersection
* is placed in @dest, unless NULL. If the intersection is non-empty,
* @dest is not modified.
*
* Returns: TRUE if the intersection is non-empty
*/
gboolean
gst_value_intersect (GValue * dest, const GValue * value1,
const GValue * value2)
{
GstValueIntersectInfo *intersect_info;
guint i, len;
GType ltype, type1, type2;
g_return_val_if_fail (G_IS_VALUE (value1), FALSE);
g_return_val_if_fail (G_IS_VALUE (value2), FALSE);
ltype = gst_value_list_get_type ();
/* special cases first */
if (G_VALUE_HOLDS (value1, ltype))
return gst_value_intersect_list (dest, value1, value2);
if (G_VALUE_HOLDS (value2, ltype))
return gst_value_intersect_list (dest, value2, value1);
if (gst_value_compare (value1, value2) == GST_VALUE_EQUAL) {
if (dest)
gst_value_init_and_copy (dest, value1);
return TRUE;
}
type1 = G_VALUE_TYPE (value1);
type2 = G_VALUE_TYPE (value2);
len = gst_value_intersect_funcs->len;
for (i = 0; i < len; i++) {
intersect_info = &g_array_index (gst_value_intersect_funcs,
GstValueIntersectInfo, i);
if (intersect_info->type1 == type1 && intersect_info->type2 == type2) {
return intersect_info->func (dest, value1, value2);
}
if (intersect_info->type1 == type2 && intersect_info->type2 == type1) {
return intersect_info->func (dest, value2, value1);
}
}
return FALSE;
}
/* gst_value_register_intersect_func: (skip)
* @type1: the first type to intersect
* @type2: the second type to intersect
* @func: the intersection function
*
* Registers a function that is called to calculate the intersection
* of the values having the types @type1 and @type2.
*
* Intersect functions should be registered at startup before any pipelines are
* started, as gst_value_register_intersect_func() is not thread-safe and
* cannot be used at the same time as gst_value_intersect() or
* gst_value_can_intersect().
*/
static void
gst_value_register_intersect_func (GType type1, GType type2,
GstValueIntersectFunc func)
{
GstValueIntersectInfo intersect_info;
intersect_info.type1 = type1;
intersect_info.type2 = type2;
intersect_info.func = func;
g_array_append_val (gst_value_intersect_funcs, intersect_info);
}
/* subtraction */
/**
* gst_value_subtract:
* @dest: (out caller-allocates): the destination value for the result if the
* subtraction is not empty. May be NULL, in which case the resulting set
* will not be computed, which can give a fair speedup.
* @minuend: the value to subtract from
* @subtrahend: the value to subtract
*
* Subtracts @subtrahend from @minuend and stores the result in @dest.
* Note that this means subtraction as in sets, not as in mathematics.
*
* Returns: %TRUE if the subtraction is not empty
*/
gboolean
gst_value_subtract (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
GstValueSubtractInfo *info;
guint i, len;
GType ltype, mtype, stype;
g_return_val_if_fail (G_IS_VALUE (minuend), FALSE);
g_return_val_if_fail (G_IS_VALUE (subtrahend), FALSE);
ltype = gst_value_list_get_type ();
/* special cases first */
if (G_VALUE_HOLDS (minuend, ltype))
return gst_value_subtract_from_list (dest, minuend, subtrahend);
if (G_VALUE_HOLDS (subtrahend, ltype))
return gst_value_subtract_list (dest, minuend, subtrahend);
mtype = G_VALUE_TYPE (minuend);
stype = G_VALUE_TYPE (subtrahend);
len = gst_value_subtract_funcs->len;
for (i = 0; i < len; i++) {
info = &g_array_index (gst_value_subtract_funcs, GstValueSubtractInfo, i);
if (info->minuend == mtype && info->subtrahend == stype) {
return info->func (dest, minuend, subtrahend);
}
}
if (gst_value_compare (minuend, subtrahend) != GST_VALUE_EQUAL) {
if (dest)
gst_value_init_and_copy (dest, minuend);
return TRUE;
}
return FALSE;
}
#if 0
gboolean
gst_value_subtract (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
gboolean ret = gst_value_subtract2 (dest, minuend, subtrahend);
g_printerr ("\"%s\" - \"%s\" = \"%s\"\n", gst_value_serialize (minuend),
gst_value_serialize (subtrahend),
ret ? gst_value_serialize (dest) : "---");
return ret;
}
#endif
/**
* gst_value_can_subtract:
* @minuend: the value to subtract from
* @subtrahend: the value to subtract
*
* Checks if it's possible to subtract @subtrahend from @minuend.
*
* Returns: TRUE if a subtraction is possible
*/
gboolean
gst_value_can_subtract (const GValue * minuend, const GValue * subtrahend)
{
GstValueSubtractInfo *info;
guint i, len;
GType ltype, mtype, stype;
g_return_val_if_fail (G_IS_VALUE (minuend), FALSE);
g_return_val_if_fail (G_IS_VALUE (subtrahend), FALSE);
ltype = gst_value_list_get_type ();
/* special cases */
if (G_VALUE_HOLDS (minuend, ltype) || G_VALUE_HOLDS (subtrahend, ltype))
return TRUE;
mtype = G_VALUE_TYPE (minuend);
stype = G_VALUE_TYPE (subtrahend);
len = gst_value_subtract_funcs->len;
for (i = 0; i < len; i++) {
info = &g_array_index (gst_value_subtract_funcs, GstValueSubtractInfo, i);
if (info->minuend == mtype && info->subtrahend == stype)
return TRUE;
}
return gst_value_can_compare (minuend, subtrahend);
}
/* gst_value_register_subtract_func: (skip)
* @minuend_type: type of the minuend
* @subtrahend_type: type of the subtrahend
* @func: function to use
*
* Registers @func as a function capable of subtracting the values of
* @subtrahend_type from values of @minuend_type.
*
* Subtract functions should be registered at startup before any pipelines are
* started, as gst_value_register_subtract_func() is not thread-safe and
* cannot be used at the same time as gst_value_subtract().
*/
static void
gst_value_register_subtract_func (GType minuend_type, GType subtrahend_type,
GstValueSubtractFunc func)
{
GstValueSubtractInfo info;
/* one type must be unfixed, other subtractions can be done as comparisons,
* special case: bitmasks */
if (minuend_type != GST_TYPE_BITMASK)
g_return_if_fail (!gst_type_is_fixed (minuend_type)
|| !gst_type_is_fixed (subtrahend_type));
info.minuend = minuend_type;
info.subtrahend = subtrahend_type;
info.func = func;
g_array_append_val (gst_value_subtract_funcs, info);
}
/**
* gst_value_register:
* @table: structure containing functions to register
*
* Registers functions to perform calculations on #GValue items of a given
* type. Each type can only be added once.
*/
void
gst_value_register (const GstValueTable * table)
{
GstValueTable *found;
g_return_if_fail (table != NULL);
g_array_append_val (gst_value_table, *table);
found = gst_value_hash_lookup_type (table->type);
if (found)
g_warning ("adding type %s multiple times", g_type_name (table->type));
/* FIXME: we're not really doing the const justice, we assume the table is
* static */
gst_value_hash_add_type (table->type, table);
}
/**
* gst_value_init_and_copy:
* @dest: (out caller-allocates): the target value
* @src: the source value
*
* Initialises the target value to be of the same type as source and then copies
* the contents from source to target.
*/
void
gst_value_init_and_copy (GValue * dest, const GValue * src)
{
g_return_if_fail (G_IS_VALUE (src));
g_return_if_fail (dest != NULL);
g_value_init (dest, G_VALUE_TYPE (src));
g_value_copy (src, dest);
}
/**
* gst_value_serialize:
* @value: a #GValue to serialize
*
* tries to transform the given @value into a string representation that allows
* getting back this string later on using gst_value_deserialize().
*
* Free-function: g_free
*
* Returns: (transfer full): the serialization for @value or NULL if none exists
*/
gchar *
gst_value_serialize (const GValue * value)
{
guint i, len;
GValue s_val = { 0 };
GstValueTable *table, *best;
gchar *s;
GType type;
g_return_val_if_fail (G_IS_VALUE (value), NULL);
type = G_VALUE_TYPE (value);
best = gst_value_hash_lookup_type (type);
if (G_UNLIKELY (!best || !best->serialize)) {
len = gst_value_table->len;
best = NULL;
for (i = 0; i < len; i++) {
table = &g_array_index (gst_value_table, GstValueTable, i);
if (table->serialize && g_type_is_a (type, table->type)) {
if (!best || g_type_is_a (table->type, best->type))
best = table;
}
}
}
if (G_LIKELY (best))
return best->serialize (value);
g_value_init (&s_val, G_TYPE_STRING);
if (g_value_transform (value, &s_val)) {
s = gst_string_wrap (g_value_get_string (&s_val));
} else {
s = NULL;
}
g_value_unset (&s_val);
return s;
}
/**
* gst_value_deserialize:
* @dest: (out caller-allocates): #GValue to fill with contents of
* deserialization
* @src: string to deserialize
*
* Tries to deserialize a string into the type specified by the given GValue.
* If the operation succeeds, TRUE is returned, FALSE otherwise.
*
* Returns: TRUE on success
*/
gboolean
gst_value_deserialize (GValue * dest, const gchar * src)
{
GstValueTable *table, *best;
guint i, len;
GType type;
g_return_val_if_fail (src != NULL, FALSE);
g_return_val_if_fail (G_IS_VALUE (dest), FALSE);
type = G_VALUE_TYPE (dest);
best = gst_value_hash_lookup_type (type);
if (G_UNLIKELY (!best || !best->deserialize)) {
len = gst_value_table->len;
best = NULL;
for (i = 0; i < len; i++) {
table = &g_array_index (gst_value_table, GstValueTable, i);
if (table->deserialize && g_type_is_a (type, table->type)) {
if (!best || g_type_is_a (table->type, best->type))
best = table;
}
}
}
if (G_LIKELY (best))
return best->deserialize (dest, src);
return FALSE;
}
/**
* gst_value_is_fixed:
* @value: the #GValue to check
*
* Tests if the given GValue, if available in a GstStructure (or any other
* container) contains a "fixed" (which means: one value) or an "unfixed"
* (which means: multiple possible values, such as data lists or data
* ranges) value.
*
* Returns: true if the value is "fixed".
*/
gboolean
gst_value_is_fixed (const GValue * value)
{
GType type;
g_return_val_if_fail (G_IS_VALUE (value), FALSE);
type = G_VALUE_TYPE (value);
/* the most common types are just basic plain glib types */
if (type <= G_TYPE_MAKE_FUNDAMENTAL (G_TYPE_RESERVED_GLIB_LAST)) {
return TRUE;
}
if (type == GST_TYPE_ARRAY) {
gint size, n;
const GValue *kid;
/* check recursively */
size = gst_value_array_get_size (value);
for (n = 0; n < size; n++) {
kid = gst_value_array_get_value (value, n);
if (!gst_value_is_fixed (kid))
return FALSE;
}
return TRUE;
}
return gst_type_is_fixed (type);
}
/**
* gst_value_fixate:
* @dest: the #GValue destination
* @src: the #GValue to fixate
*
* Fixate @src into a new value @dest.
* For ranges, the first element is taken. For lists and arrays, the
* first item is fixated and returned.
* If @src is already fixed, this function returns FALSE.
*
* Returns: true if @dest contains a fixated version of @src.
*/
gboolean
gst_value_fixate (GValue * dest, const GValue * src)
{
g_return_val_if_fail (G_IS_VALUE (src), FALSE);
g_return_val_if_fail (dest != NULL, FALSE);
if (G_VALUE_TYPE (src) == GST_TYPE_INT_RANGE) {
g_value_init (dest, G_TYPE_INT);
g_value_set_int (dest, gst_value_get_int_range_min (src));
} else if (G_VALUE_TYPE (src) == GST_TYPE_DOUBLE_RANGE) {
g_value_init (dest, G_TYPE_DOUBLE);
g_value_set_double (dest, gst_value_get_double_range_min (src));
} else if (G_VALUE_TYPE (src) == GST_TYPE_FRACTION_RANGE) {
gst_value_init_and_copy (dest, gst_value_get_fraction_range_min (src));
} else if (G_VALUE_TYPE (src) == GST_TYPE_LIST) {
GValue temp = { 0 };
/* list could be empty */
if (gst_value_list_get_size (src) <= 0)
return FALSE;
gst_value_init_and_copy (&temp, gst_value_list_get_value (src, 0));
if (!gst_value_fixate (dest, &temp))
gst_value_init_and_copy (dest, &temp);
g_value_unset (&temp);
} else if (G_VALUE_TYPE (src) == GST_TYPE_ARRAY) {
gboolean res = FALSE;
guint n, len;
len = gst_value_array_get_size (src);
g_value_init (dest, GST_TYPE_ARRAY);
for (n = 0; n < len; n++) {
GValue kid = { 0 };
const GValue *orig_kid = gst_value_array_get_value (src, n);
if (!gst_value_fixate (&kid, orig_kid))
gst_value_init_and_copy (&kid, orig_kid);
else
res = TRUE;
gst_value_array_append_value (dest, &kid);
g_value_unset (&kid);
}
if (!res)
g_value_unset (dest);
return res;
} else {
return FALSE;
}
return TRUE;
}
/************
* fraction *
************/
/* helper functions */
static void
gst_value_init_fraction (GValue * value)
{
value->data[0].v_int = 0;
value->data[1].v_int = 1;
}
static void
gst_value_copy_fraction (const GValue * src_value, GValue * dest_value)
{
dest_value->data[0].v_int = src_value->data[0].v_int;
dest_value->data[1].v_int = src_value->data[1].v_int;
}
static gchar *
gst_value_collect_fraction (GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
if (n_collect_values != 2)
return g_strdup_printf ("not enough value locations for `%s' passed",
G_VALUE_TYPE_NAME (value));
if (collect_values[1].v_int == 0)
return g_strdup_printf ("passed '0' as denominator for `%s'",
G_VALUE_TYPE_NAME (value));
if (collect_values[0].v_int < -G_MAXINT)
return
g_strdup_printf
("passed value smaller than -G_MAXINT as numerator for `%s'",
G_VALUE_TYPE_NAME (value));
if (collect_values[1].v_int < -G_MAXINT)
return
g_strdup_printf
("passed value smaller than -G_MAXINT as denominator for `%s'",
G_VALUE_TYPE_NAME (value));
gst_value_set_fraction (value,
collect_values[0].v_int, collect_values[1].v_int);
return NULL;
}
static gchar *
gst_value_lcopy_fraction (const GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
gint *numerator = collect_values[0].v_pointer;
gint *denominator = collect_values[1].v_pointer;
if (!numerator)
return g_strdup_printf ("numerator for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
if (!denominator)
return g_strdup_printf ("denominator for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
*numerator = value->data[0].v_int;
*denominator = value->data[1].v_int;
return NULL;
}
/**
* gst_value_set_fraction:
* @value: a GValue initialized to #GST_TYPE_FRACTION
* @numerator: the numerator of the fraction
* @denominator: the denominator of the fraction
*
* Sets @value to the fraction specified by @numerator over @denominator.
* The fraction gets reduced to the smallest numerator and denominator,
* and if necessary the sign is moved to the numerator.
*/
void
gst_value_set_fraction (GValue * value, gint numerator, gint denominator)
{
gint gcd = 0;
g_return_if_fail (GST_VALUE_HOLDS_FRACTION (value));
g_return_if_fail (denominator != 0);
g_return_if_fail (denominator >= -G_MAXINT);
g_return_if_fail (numerator >= -G_MAXINT);
/* normalize sign */
if (denominator < 0) {
numerator = -numerator;
denominator = -denominator;
}
/* check for reduction */
gcd = gst_util_greatest_common_divisor (numerator, denominator);
if (gcd) {
numerator /= gcd;
denominator /= gcd;
}
g_assert (denominator > 0);
value->data[0].v_int = numerator;
value->data[1].v_int = denominator;
}
/**
* gst_value_get_fraction_numerator:
* @value: a GValue initialized to #GST_TYPE_FRACTION
*
* Gets the numerator of the fraction specified by @value.
*
* Returns: the numerator of the fraction.
*/
gint
gst_value_get_fraction_numerator (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_FRACTION (value), 0);
return value->data[0].v_int;
}
/**
* gst_value_get_fraction_denominator:
* @value: a GValue initialized to #GST_TYPE_FRACTION
*
* Gets the denominator of the fraction specified by @value.
*
* Returns: the denominator of the fraction.
*/
gint
gst_value_get_fraction_denominator (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_FRACTION (value), 1);
return value->data[1].v_int;
}
/**
* gst_value_fraction_multiply:
* @product: a GValue initialized to #GST_TYPE_FRACTION
* @factor1: a GValue initialized to #GST_TYPE_FRACTION
* @factor2: a GValue initialized to #GST_TYPE_FRACTION
*
* Multiplies the two #GValue items containing a #GST_TYPE_FRACTION and sets
* @product to the product of the two fractions.
*
* Returns: FALSE in case of an error (like integer overflow), TRUE otherwise.
*/
gboolean
gst_value_fraction_multiply (GValue * product, const GValue * factor1,
const GValue * factor2)
{
gint n1, n2, d1, d2;
gint res_n, res_d;
g_return_val_if_fail (product != NULL, FALSE);
g_return_val_if_fail (GST_VALUE_HOLDS_FRACTION (factor1), FALSE);
g_return_val_if_fail (GST_VALUE_HOLDS_FRACTION (factor2), FALSE);
n1 = factor1->data[0].v_int;
n2 = factor2->data[0].v_int;
d1 = factor1->data[1].v_int;
d2 = factor2->data[1].v_int;
if (!gst_util_fraction_multiply (n1, d1, n2, d2, &res_n, &res_d))
return FALSE;
gst_value_set_fraction (product, res_n, res_d);
return TRUE;
}
/**
* gst_value_fraction_subtract:
* @dest: a GValue initialized to #GST_TYPE_FRACTION
* @minuend: a GValue initialized to #GST_TYPE_FRACTION
* @subtrahend: a GValue initialized to #GST_TYPE_FRACTION
*
* Subtracts the @subtrahend from the @minuend and sets @dest to the result.
*
* Returns: FALSE in case of an error (like integer overflow), TRUE otherwise.
*/
gboolean
gst_value_fraction_subtract (GValue * dest,
const GValue * minuend, const GValue * subtrahend)
{
gint n1, n2, d1, d2;
gint res_n, res_d;
g_return_val_if_fail (dest != NULL, FALSE);
g_return_val_if_fail (GST_VALUE_HOLDS_FRACTION (minuend), FALSE);
g_return_val_if_fail (GST_VALUE_HOLDS_FRACTION (subtrahend), FALSE);
n1 = minuend->data[0].v_int;
n2 = subtrahend->data[0].v_int;
d1 = minuend->data[1].v_int;
d2 = subtrahend->data[1].v_int;
if (!gst_util_fraction_add (n1, d1, -n2, d2, &res_n, &res_d))
return FALSE;
gst_value_set_fraction (dest, res_n, res_d);
return TRUE;
}
static gchar *
gst_value_serialize_fraction (const GValue * value)
{
gint32 numerator = value->data[0].v_int;
gint32 denominator = value->data[1].v_int;
gboolean positive = TRUE;
/* get the sign and make components absolute */
if (numerator < 0) {
numerator = -numerator;
positive = !positive;
}
if (denominator < 0) {
denominator = -denominator;
positive = !positive;
}
return g_strdup_printf ("%s%d/%d",
positive ? "" : "-", numerator, denominator);
}
static gboolean
gst_value_deserialize_fraction (GValue * dest, const gchar * s)
{
gint num, den;
gint num_chars;
if (G_UNLIKELY (s == NULL))
return FALSE;
if (G_UNLIKELY (dest == NULL || !GST_VALUE_HOLDS_FRACTION (dest)))
return FALSE;
if (sscanf (s, "%d/%d%n", &num, &den, &num_chars) >= 2) {
if (s[num_chars] != 0)
return FALSE;
if (den == 0)
return FALSE;
gst_value_set_fraction (dest, num, den);
return TRUE;
} else if (g_ascii_strcasecmp (s, "1/max") == 0) {
gst_value_set_fraction (dest, 1, G_MAXINT);
return TRUE;
} else if (sscanf (s, "%d%n", &num, &num_chars) >= 1) {
if (s[num_chars] != 0)
return FALSE;
gst_value_set_fraction (dest, num, 1);
return TRUE;
} else if (g_ascii_strcasecmp (s, "min") == 0) {
gst_value_set_fraction (dest, -G_MAXINT, 1);
return TRUE;
} else if (g_ascii_strcasecmp (s, "max") == 0) {
gst_value_set_fraction (dest, G_MAXINT, 1);
return TRUE;
}
return FALSE;
}
static void
gst_value_transform_fraction_string (const GValue * src_value,
GValue * dest_value)
{
dest_value->data[0].v_pointer = gst_value_serialize_fraction (src_value);
}
static void
gst_value_transform_string_fraction (const GValue * src_value,
GValue * dest_value)
{
if (!gst_value_deserialize_fraction (dest_value,
src_value->data[0].v_pointer))
/* If the deserialize fails, ensure we leave the fraction in a
* valid, if incorrect, state */
gst_value_set_fraction (dest_value, 0, 1);
}
static void
gst_value_transform_double_fraction (const GValue * src_value,
GValue * dest_value)
{
gdouble src = g_value_get_double (src_value);
gint n, d;
gst_util_double_to_fraction (src, &n, &d);
gst_value_set_fraction (dest_value, n, d);
}
static void
gst_value_transform_float_fraction (const GValue * src_value,
GValue * dest_value)
{
gfloat src = g_value_get_float (src_value);
gint n, d;
gst_util_double_to_fraction (src, &n, &d);
gst_value_set_fraction (dest_value, n, d);
}
static void
gst_value_transform_fraction_double (const GValue * src_value,
GValue * dest_value)
{
dest_value->data[0].v_double = ((double) src_value->data[0].v_int) /
((double) src_value->data[1].v_int);
}
static void
gst_value_transform_fraction_float (const GValue * src_value,
GValue * dest_value)
{
dest_value->data[0].v_float = ((float) src_value->data[0].v_int) /
((float) src_value->data[1].v_int);
}
static gint
gst_value_compare_fraction (const GValue * value1, const GValue * value2)
{
gint n1, n2;
gint d1, d2;
gint ret;
n1 = value1->data[0].v_int;
n2 = value2->data[0].v_int;
d1 = value1->data[1].v_int;
d2 = value2->data[1].v_int;
/* fractions are reduced when set, so we can quickly see if they're equal */
if (n1 == n2 && d1 == d2)
return GST_VALUE_EQUAL;
if (d1 == 0 && d2 == 0)
return GST_VALUE_UNORDERED;
else if (d1 == 0)
return GST_VALUE_GREATER_THAN;
else if (d2 == 0)
return GST_VALUE_LESS_THAN;
ret = gst_util_fraction_compare (n1, d1, n2, d2);
if (ret == -1)
return GST_VALUE_LESS_THAN;
else if (ret == 1)
return GST_VALUE_GREATER_THAN;
/* Equality can't happen here because we check for that
* first already */
g_return_val_if_reached (GST_VALUE_UNORDERED);
}
/*********
* GDate *
*********/
static gint
gst_value_compare_date (const GValue * value1, const GValue * value2)
{
const GDate *date1 = (const GDate *) g_value_get_boxed (value1);
const GDate *date2 = (const GDate *) g_value_get_boxed (value2);
guint32 j1, j2;
if (date1 == date2)
return GST_VALUE_EQUAL;
if ((date1 == NULL || !g_date_valid (date1))
&& (date2 != NULL && g_date_valid (date2))) {
return GST_VALUE_LESS_THAN;
}
if ((date2 == NULL || !g_date_valid (date2))
&& (date1 != NULL && g_date_valid (date1))) {
return GST_VALUE_GREATER_THAN;
}
if (date1 == NULL || date2 == NULL || !g_date_valid (date1)
|| !g_date_valid (date2)) {
return GST_VALUE_UNORDERED;
}
j1 = g_date_get_julian (date1);
j2 = g_date_get_julian (date2);
if (j1 == j2)
return GST_VALUE_EQUAL;
else if (j1 < j2)
return GST_VALUE_LESS_THAN;
else
return GST_VALUE_GREATER_THAN;
}
static gchar *
gst_value_serialize_date (const GValue * val)
{
const GDate *date = (const GDate *) g_value_get_boxed (val);
if (date == NULL || !g_date_valid (date))
return g_strdup ("9999-99-99");
return g_strdup_printf ("%04u-%02u-%02u", g_date_get_year (date),
g_date_get_month (date), g_date_get_day (date));
}
static gboolean
gst_value_deserialize_date (GValue * dest, const gchar * s)
{
guint year, month, day;
if (!s || sscanf (s, "%04u-%02u-%02u", &year, &month, &day) != 3)
return FALSE;
if (!g_date_valid_dmy (day, month, year))
return FALSE;
g_value_take_boxed (dest, g_date_new_dmy (day, month, year));
return TRUE;
}
/*************
* GstDateTime *
*************/
static gint
gst_value_compare_date_time (const GValue * value1, const GValue * value2)
{
const GstDateTime *date1 = (const GstDateTime *) g_value_get_boxed (value1);
const GstDateTime *date2 = (const GstDateTime *) g_value_get_boxed (value2);
if (date1 == date2)
return GST_VALUE_EQUAL;
if ((date1 == NULL) && (date2 != NULL)) {
return GST_VALUE_LESS_THAN;
}
if ((date2 == NULL) && (date1 != NULL)) {
return GST_VALUE_LESS_THAN;
}
/* returns GST_VALUE_* */
return __gst_date_time_compare (date1, date2);
}
static gchar *
gst_value_serialize_date_time (const GValue * val)
{
GstDateTime *date = (GstDateTime *) g_value_get_boxed (val);
gfloat offset;
gint tzhour, tzminute;
if (date == NULL)
return g_strdup ("null");
offset = gst_date_time_get_time_zone_offset (date);
tzhour = (gint) ABS (offset);
tzminute = (gint) ((ABS (offset) - tzhour) * 60);
return g_strdup_printf ("\"%04d-%02d-%02dT%02d:%02d:%02d.%06d"
"%c%02d%02d\"", gst_date_time_get_year (date),
gst_date_time_get_month (date), gst_date_time_get_day (date),
gst_date_time_get_hour (date), gst_date_time_get_minute (date),
gst_date_time_get_second (date), gst_date_time_get_microsecond (date),
offset >= 0 ? '+' : '-', tzhour, tzminute);
}
static gboolean
gst_value_deserialize_date_time (GValue * dest, const gchar * s)
{
gint year, month, day, hour, minute, second, usecond;
gchar signal;
gint offset = 0;
gfloat tzoffset = 0;
gint ret;
if (!s || strcmp (s, "null") == 0) {
return FALSE;
}
ret = sscanf (s, "%04d-%02d-%02dT%02d:%02d:%02d.%06d%c%04d",
&year, &month, &day, &hour, &minute, &second, &usecond, &signal, &offset);
if (ret >= 9) {
tzoffset = (offset / 100) + ((offset % 100) / 60.0);
if (signal == '-')
tzoffset = -tzoffset;
} else
return FALSE;
g_value_take_boxed (dest, gst_date_time_new (tzoffset, year, month, day, hour,
minute, second + (usecond / 1000000.0)));
return TRUE;
}
static void
gst_value_transform_date_string (const GValue * src_value, GValue * dest_value)
{
dest_value->data[0].v_pointer = gst_value_serialize_date (src_value);
}
static void
gst_value_transform_string_date (const GValue * src_value, GValue * dest_value)
{
gst_value_deserialize_date (dest_value, src_value->data[0].v_pointer);
}
/************
* bitmask *
************/
/* helper functions */
static void
gst_value_init_bitmask (GValue * value)
{
value->data[0].v_uint64 = 0;
}
static void
gst_value_copy_bitmask (const GValue * src_value, GValue * dest_value)
{
dest_value->data[0].v_uint64 = src_value->data[0].v_uint64;
}
static gchar *
gst_value_collect_bitmask (GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
if (n_collect_values != 1)
return g_strdup_printf ("not enough value locations for `%s' passed",
G_VALUE_TYPE_NAME (value));
gst_value_set_bitmask (value, (guint64) collect_values[0].v_int64);
return NULL;
}
static gchar *
gst_value_lcopy_bitmask (const GValue * value, guint n_collect_values,
GTypeCValue * collect_values, guint collect_flags)
{
guint64 *bitmask = collect_values[0].v_pointer;
if (!bitmask)
return g_strdup_printf ("value for `%s' passed as NULL",
G_VALUE_TYPE_NAME (value));
*bitmask = value->data[0].v_uint64;
return NULL;
}
/**
* gst_value_set_bitmask:
* @value: a GValue initialized to #GST_TYPE_FRACTION
* @bitmask: the bitmask
*
* Sets @value to the bitmask specified by @bitmask.
*/
void
gst_value_set_bitmask (GValue * value, guint64 bitmask)
{
g_return_if_fail (GST_VALUE_HOLDS_BITMASK (value));
value->data[0].v_uint64 = bitmask;
}
/**
* gst_value_get_bitmask:
* @value: a GValue initialized to #GST_TYPE_FRACTION
*
* Gets the bitmask specified by @value.
*
* Returns: the bitmask.
*/
guint64
gst_value_get_bitmask (const GValue * value)
{
g_return_val_if_fail (GST_VALUE_HOLDS_BITMASK (value), 0);
return value->data[0].v_uint64;
}
static gchar *
gst_value_serialize_bitmask (const GValue * value)
{
guint64 bitmask = value->data[0].v_uint64;
return g_strdup_printf ("0x%016" G_GINT64_MODIFIER "x", bitmask);
}
static gboolean
gst_value_deserialize_bitmask (GValue * dest, const gchar * s)
{
gchar *endptr = NULL;
guint64 val;
if (G_UNLIKELY (s == NULL))
return FALSE;
if (G_UNLIKELY (dest == NULL || !GST_VALUE_HOLDS_BITMASK (dest)))
return FALSE;
val = g_ascii_strtoull (s, &endptr, 16);
if (val == G_MAXUINT64 && (errno == ERANGE || errno == EINVAL))
return FALSE;
if (val == 0 && endptr == s)
return FALSE;
gst_value_set_bitmask (dest, val);
return TRUE;
}
static void
gst_value_transform_bitmask_string (const GValue * src_value,
GValue * dest_value)
{
dest_value->data[0].v_pointer = gst_value_serialize_bitmask (src_value);
}
static void
gst_value_transform_string_bitmask (const GValue * src_value,
GValue * dest_value)
{
if (!gst_value_deserialize_bitmask (dest_value, src_value->data[0].v_pointer))
gst_value_set_bitmask (dest_value, 0);
}
static void
gst_value_transform_uint64_bitmask (const GValue * src_value,
GValue * dest_value)
{
dest_value->data[0].v_uint64 = src_value->data[0].v_uint64;
}
static void
gst_value_transform_bitmask_uint64 (const GValue * src_value,
GValue * dest_value)
{
dest_value->data[0].v_uint64 = src_value->data[0].v_uint64;
}
static gboolean
gst_value_intersect_bitmask_bitmask (GValue * dest, const GValue * src1,
const GValue * src2)
{
guint64 s1, s2;
s1 = gst_value_get_bitmask (src1);
s2 = gst_value_get_bitmask (src2);
if (dest) {
g_value_init (dest, GST_TYPE_BITMASK);
gst_value_set_bitmask (dest, s1 & s2);
}
return TRUE;
}
static gboolean
gst_value_union_bitmask_bitmask (GValue * dest, const GValue * src1,
const GValue * src2)
{
guint64 s1, s2;
s1 = gst_value_get_bitmask (src1);
s2 = gst_value_get_bitmask (src2);
g_value_init (dest, GST_TYPE_BITMASK);
gst_value_set_bitmask (dest, s1 | s2);
return TRUE;
}
static gboolean
gst_value_subtract_bitmask_bitmask (GValue * dest,
const GValue * minuend, const GValue * subtrahend)
{
guint64 m, s, r;
g_return_val_if_fail (GST_VALUE_HOLDS_BITMASK (minuend), FALSE);
g_return_val_if_fail (GST_VALUE_HOLDS_BITMASK (subtrahend), FALSE);
m = minuend->data[0].v_uint64;
s = subtrahend->data[0].v_uint64;
r = m & (~s);
if (dest) {
g_value_init (dest, GST_TYPE_BITMASK);
gst_value_set_bitmask (dest, r);
}
return (r != 0);
}
static gint
gst_value_compare_bitmask (const GValue * value1, const GValue * value2)
{
guint64 v1, v2;
v1 = value1->data[0].v_uint64;
v2 = value2->data[0].v_uint64;
if (v1 == v2)
return GST_VALUE_EQUAL;
return GST_VALUE_UNORDERED;
}
static void
gst_value_transform_object_string (const GValue * src_value,
GValue * dest_value)
{
GstObject *obj;
gchar *str;
obj = g_value_get_object (src_value);
if (obj) {
str =
g_strdup_printf ("(%s) %s", G_OBJECT_TYPE_NAME (obj),
GST_OBJECT_NAME (obj));
} else {
str = g_strdup ("NULL");
}
dest_value->data[0].v_pointer = str;
}
static GTypeInfo _info = {
0,
NULL,
NULL,
NULL,
NULL,
NULL,
0,
0,
NULL,
NULL,
};
static GTypeFundamentalInfo _finfo = {
0
};
#define FUNC_VALUE_GET_TYPE(type, name) \
GType gst_ ## type ## _get_type (void) \
{ \
static volatile GType gst_ ## type ## _type = 0; \
\
if (g_once_init_enter (&gst_ ## type ## _type)) { \
GType _type; \
_info.value_table = & _gst_ ## type ## _value_table; \
_type = g_type_register_fundamental ( \
g_type_fundamental_next (), \
name, &_info, &_finfo, 0); \
g_once_init_leave(&gst_ ## type ## _type, _type); \
} \
\
return gst_ ## type ## _type; \
}
static const GTypeValueTable _gst_int_range_value_table = {
gst_value_init_int_range,
gst_value_free_int_range,
gst_value_copy_int_range,
NULL,
(char *) "ii",
gst_value_collect_int_range,
(char *) "pp",
gst_value_lcopy_int_range
};
FUNC_VALUE_GET_TYPE (int_range, "GstIntRange");
static const GTypeValueTable _gst_int64_range_value_table = {
gst_value_init_int64_range,
gst_value_free_int64_range,
gst_value_copy_int64_range,
NULL,
(char *) "qq",
gst_value_collect_int64_range,
(char *) "pp",
gst_value_lcopy_int64_range
};
FUNC_VALUE_GET_TYPE (int64_range, "GstInt64Range");
static const GTypeValueTable _gst_double_range_value_table = {
gst_value_init_double_range,
NULL,
gst_value_copy_double_range,
NULL,
(char *) "dd",
gst_value_collect_double_range,
(char *) "pp",
gst_value_lcopy_double_range
};
FUNC_VALUE_GET_TYPE (double_range, "GstDoubleRange");
static const GTypeValueTable _gst_fraction_range_value_table = {
gst_value_init_fraction_range,
gst_value_free_fraction_range,
gst_value_copy_fraction_range,
NULL,
(char *) "iiii",
gst_value_collect_fraction_range,
(char *) "pppp",
gst_value_lcopy_fraction_range
};
FUNC_VALUE_GET_TYPE (fraction_range, "GstFractionRange");
static const GTypeValueTable _gst_value_list_value_table = {
gst_value_init_list_or_array,
gst_value_free_list_or_array,
gst_value_copy_list_or_array,
gst_value_list_or_array_peek_pointer,
(char *) "p",
gst_value_collect_list_or_array,
(char *) "p",
gst_value_lcopy_list_or_array
};
FUNC_VALUE_GET_TYPE (value_list, "GstValueList");
static const GTypeValueTable _gst_value_array_value_table = {
gst_value_init_list_or_array,
gst_value_free_list_or_array,
gst_value_copy_list_or_array,
gst_value_list_or_array_peek_pointer,
(char *) "p",
gst_value_collect_list_or_array,
(char *) "p",
gst_value_lcopy_list_or_array
};
FUNC_VALUE_GET_TYPE (value_array, "GstValueArray");
static const GTypeValueTable _gst_fraction_value_table = {
gst_value_init_fraction,
NULL,
gst_value_copy_fraction,
NULL,
(char *) "ii",
gst_value_collect_fraction,
(char *) "pp",
gst_value_lcopy_fraction
};
FUNC_VALUE_GET_TYPE (fraction, "GstFraction");
G_DEFINE_BOXED_TYPE (GstDateTime, gst_date_time,
(GBoxedCopyFunc) gst_date_time_ref, (GBoxedFreeFunc) gst_date_time_unref);
static const GTypeValueTable _gst_bitmask_value_table = {
gst_value_init_bitmask,
NULL,
gst_value_copy_bitmask,
NULL,
(char *) "q",
gst_value_collect_bitmask,
(char *) "p",
gst_value_lcopy_bitmask
};
FUNC_VALUE_GET_TYPE (bitmask, "GstBitmask");
void
_priv_gst_value_initialize (void)
{
gst_value_table = g_array_new (FALSE, FALSE, sizeof (GstValueTable));
gst_value_hash = g_hash_table_new (NULL, NULL);
gst_value_union_funcs = g_array_new (FALSE, FALSE,
sizeof (GstValueUnionInfo));
gst_value_intersect_funcs = g_array_new (FALSE, FALSE,
sizeof (GstValueIntersectInfo));
gst_value_subtract_funcs = g_array_new (FALSE, FALSE,
sizeof (GstValueSubtractInfo));
{
static GstValueTable gst_value = {
0,
gst_value_compare_int_range,
gst_value_serialize_int_range,
gst_value_deserialize_int_range,
};
gst_value.type = gst_int_range_get_type ();
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
gst_value_compare_int64_range,
gst_value_serialize_int64_range,
gst_value_deserialize_int64_range,
};
gst_value.type = gst_int64_range_get_type ();
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
gst_value_compare_double_range,
gst_value_serialize_double_range,
gst_value_deserialize_double_range,
};
gst_value.type = gst_double_range_get_type ();
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
gst_value_compare_fraction_range,
gst_value_serialize_fraction_range,
gst_value_deserialize_fraction_range,
};
gst_value.type = gst_fraction_range_get_type ();
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
gst_value_compare_list,
gst_value_serialize_list,
gst_value_deserialize_list,
};
gst_value.type = gst_value_list_get_type ();
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
gst_value_compare_array,
gst_value_serialize_array,
gst_value_deserialize_array,
};
gst_value.type = gst_value_array_get_type ();
gst_value_register (&gst_value);
}
{
#if 0
static const GTypeValueTable value_table = {
gst_value_init_buffer,
NULL,
gst_value_copy_buffer,
NULL,
"i",
NULL, /*gst_value_collect_buffer, */
"p",
NULL /*gst_value_lcopy_buffer */
};
#endif
static GstValueTable gst_value = {
0,
gst_value_compare_buffer,
gst_value_serialize_buffer,
gst_value_deserialize_buffer,
};
gst_value.type = GST_TYPE_BUFFER;
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
gst_value_compare_sample,
NULL,
NULL,
};
gst_value.type = GST_TYPE_SAMPLE;
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
gst_value_compare_fraction,
gst_value_serialize_fraction,
gst_value_deserialize_fraction,
};
gst_value.type = gst_fraction_get_type ();
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
NULL,
gst_value_serialize_caps,
gst_value_deserialize_caps,
};
gst_value.type = GST_TYPE_CAPS;
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
NULL,
gst_value_serialize_segment,
gst_value_deserialize_segment,
};
gst_value.type = GST_TYPE_SEGMENT;
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
NULL,
gst_value_serialize_structure,
gst_value_deserialize_structure,
};
gst_value.type = GST_TYPE_STRUCTURE;
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
gst_value_compare_date,
gst_value_serialize_date,
gst_value_deserialize_date,
};
gst_value.type = G_TYPE_DATE;
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
gst_value_compare_date_time,
gst_value_serialize_date_time,
gst_value_deserialize_date_time,
};
gst_value.type = gst_date_time_get_type ();
gst_value_register (&gst_value);
}
{
static GstValueTable gst_value = {
0,
gst_value_compare_bitmask,
gst_value_serialize_bitmask,
gst_value_deserialize_bitmask,
};
gst_value.type = gst_bitmask_get_type ();
gst_value_register (&gst_value);
}
REGISTER_SERIALIZATION (G_TYPE_DOUBLE, double);
REGISTER_SERIALIZATION (G_TYPE_FLOAT, float);
REGISTER_SERIALIZATION (G_TYPE_STRING, string);
REGISTER_SERIALIZATION (G_TYPE_BOOLEAN, boolean);
REGISTER_SERIALIZATION (G_TYPE_ENUM, enum);
REGISTER_SERIALIZATION (G_TYPE_FLAGS, flags);
REGISTER_SERIALIZATION (G_TYPE_INT, int);
REGISTER_SERIALIZATION (G_TYPE_INT64, int64);
REGISTER_SERIALIZATION (G_TYPE_LONG, long);
REGISTER_SERIALIZATION (G_TYPE_UINT, uint);
REGISTER_SERIALIZATION (G_TYPE_UINT64, uint64);
REGISTER_SERIALIZATION (G_TYPE_ULONG, ulong);
REGISTER_SERIALIZATION (G_TYPE_UCHAR, uchar);
g_value_register_transform_func (GST_TYPE_INT_RANGE, G_TYPE_STRING,
gst_value_transform_int_range_string);
g_value_register_transform_func (GST_TYPE_INT64_RANGE, G_TYPE_STRING,
gst_value_transform_int64_range_string);
g_value_register_transform_func (GST_TYPE_DOUBLE_RANGE, G_TYPE_STRING,
gst_value_transform_double_range_string);
g_value_register_transform_func (GST_TYPE_FRACTION_RANGE, G_TYPE_STRING,
gst_value_transform_fraction_range_string);
g_value_register_transform_func (GST_TYPE_LIST, G_TYPE_STRING,
gst_value_transform_list_string);
g_value_register_transform_func (GST_TYPE_ARRAY, G_TYPE_STRING,
gst_value_transform_array_string);
g_value_register_transform_func (GST_TYPE_FRACTION, G_TYPE_STRING,
gst_value_transform_fraction_string);
g_value_register_transform_func (G_TYPE_STRING, GST_TYPE_FRACTION,
gst_value_transform_string_fraction);
g_value_register_transform_func (GST_TYPE_FRACTION, G_TYPE_DOUBLE,
gst_value_transform_fraction_double);
g_value_register_transform_func (GST_TYPE_FRACTION, G_TYPE_FLOAT,
gst_value_transform_fraction_float);
g_value_register_transform_func (G_TYPE_DOUBLE, GST_TYPE_FRACTION,
gst_value_transform_double_fraction);
g_value_register_transform_func (G_TYPE_FLOAT, GST_TYPE_FRACTION,
gst_value_transform_float_fraction);
g_value_register_transform_func (G_TYPE_DATE, G_TYPE_STRING,
gst_value_transform_date_string);
g_value_register_transform_func (G_TYPE_STRING, G_TYPE_DATE,
gst_value_transform_string_date);
g_value_register_transform_func (GST_TYPE_OBJECT, G_TYPE_STRING,
gst_value_transform_object_string);
g_value_register_transform_func (GST_TYPE_BITMASK, G_TYPE_UINT64,
gst_value_transform_bitmask_uint64);
g_value_register_transform_func (GST_TYPE_BITMASK, G_TYPE_STRING,
gst_value_transform_bitmask_string);
g_value_register_transform_func (G_TYPE_UINT64, GST_TYPE_BITMASK,
gst_value_transform_uint64_bitmask);
g_value_register_transform_func (G_TYPE_STRING, GST_TYPE_BITMASK,
gst_value_transform_string_bitmask);
gst_value_register_intersect_func (G_TYPE_INT, GST_TYPE_INT_RANGE,
gst_value_intersect_int_int_range);
gst_value_register_intersect_func (GST_TYPE_INT_RANGE, GST_TYPE_INT_RANGE,
gst_value_intersect_int_range_int_range);
gst_value_register_intersect_func (G_TYPE_INT64, GST_TYPE_INT64_RANGE,
gst_value_intersect_int64_int64_range);
gst_value_register_intersect_func (GST_TYPE_INT64_RANGE, GST_TYPE_INT64_RANGE,
gst_value_intersect_int64_range_int64_range);
gst_value_register_intersect_func (G_TYPE_DOUBLE, GST_TYPE_DOUBLE_RANGE,
gst_value_intersect_double_double_range);
gst_value_register_intersect_func (GST_TYPE_DOUBLE_RANGE,
GST_TYPE_DOUBLE_RANGE, gst_value_intersect_double_range_double_range);
gst_value_register_intersect_func (GST_TYPE_ARRAY,
GST_TYPE_ARRAY, gst_value_intersect_array);
gst_value_register_intersect_func (GST_TYPE_FRACTION, GST_TYPE_FRACTION_RANGE,
gst_value_intersect_fraction_fraction_range);
gst_value_register_intersect_func (GST_TYPE_FRACTION_RANGE,
GST_TYPE_FRACTION_RANGE,
gst_value_intersect_fraction_range_fraction_range);
gst_value_register_intersect_func (GST_TYPE_BITMASK,
GST_TYPE_BITMASK, gst_value_intersect_bitmask_bitmask);
gst_value_register_subtract_func (G_TYPE_INT, GST_TYPE_INT_RANGE,
gst_value_subtract_int_int_range);
gst_value_register_subtract_func (GST_TYPE_INT_RANGE, G_TYPE_INT,
gst_value_subtract_int_range_int);
gst_value_register_subtract_func (GST_TYPE_INT_RANGE, GST_TYPE_INT_RANGE,
gst_value_subtract_int_range_int_range);
gst_value_register_subtract_func (G_TYPE_INT64, GST_TYPE_INT64_RANGE,
gst_value_subtract_int64_int64_range);
gst_value_register_subtract_func (GST_TYPE_INT64_RANGE, G_TYPE_INT64,
gst_value_subtract_int64_range_int64);
gst_value_register_subtract_func (GST_TYPE_INT64_RANGE, GST_TYPE_INT64_RANGE,
gst_value_subtract_int64_range_int64_range);
gst_value_register_subtract_func (G_TYPE_DOUBLE, GST_TYPE_DOUBLE_RANGE,
gst_value_subtract_double_double_range);
gst_value_register_subtract_func (GST_TYPE_DOUBLE_RANGE, G_TYPE_DOUBLE,
gst_value_subtract_double_range_double);
gst_value_register_subtract_func (GST_TYPE_DOUBLE_RANGE,
GST_TYPE_DOUBLE_RANGE, gst_value_subtract_double_range_double_range);
gst_value_register_subtract_func (GST_TYPE_FRACTION, GST_TYPE_FRACTION_RANGE,
gst_value_subtract_fraction_fraction_range);
gst_value_register_subtract_func (GST_TYPE_FRACTION_RANGE, GST_TYPE_FRACTION,
gst_value_subtract_fraction_range_fraction);
gst_value_register_subtract_func (GST_TYPE_FRACTION_RANGE,
GST_TYPE_FRACTION_RANGE,
gst_value_subtract_fraction_range_fraction_range);
gst_value_register_subtract_func (GST_TYPE_BITMASK,
GST_TYPE_BITMASK, gst_value_subtract_bitmask_bitmask);
/* see bug #317246, #64994, #65041 */
{
volatile GType date_type = G_TYPE_DATE;
g_type_name (date_type);
}
gst_value_register_union_func (G_TYPE_INT, GST_TYPE_INT_RANGE,
gst_value_union_int_int_range);
gst_value_register_union_func (GST_TYPE_INT_RANGE, GST_TYPE_INT_RANGE,
gst_value_union_int_range_int_range);
gst_value_register_union_func (GST_TYPE_BITMASK,
GST_TYPE_BITMASK, gst_value_union_bitmask_bitmask);
#if 0
/* Implement these if needed */
gst_value_register_union_func (GST_TYPE_FRACTION, GST_TYPE_FRACTION_RANGE,
gst_value_union_fraction_fraction_range);
gst_value_register_union_func (GST_TYPE_FRACTION_RANGE,
GST_TYPE_FRACTION_RANGE, gst_value_union_fraction_range_fraction_range);
#endif
}
Reference in a new issue View git blame Copy permalink