#include <gst/gst.h>
#include <gobject/gvaluecollector.h>
-typedef struct _GstValueCompareInfo GstValueCompareInfo;
-struct _GstValueCompareInfo {
- GType type;
- GstValueCompareFunc func;
-};
typedef struct _GstValueUnionInfo GstValueUnionInfo;
struct _GstValueUnionInfo {
GType gst_type_double_range;
GType gst_type_list;
-GArray *gst_value_compare_funcs;
-GArray *gst_value_union_funcs;
-GArray *gst_value_intersect_funcs;
+static GArray *gst_value_table;
+static GArray *gst_value_union_funcs;
+static GArray *gst_value_intersect_funcs;
+/*************************************/
/* list */
static void
return NULL;
}
+/**
+ * gst_value_list_prepend_value:
+ *
+ */
void
gst_value_list_prepend_value (GValue *value, const GValue *prepend_value)
{
g_array_prepend_vals ((GArray *) value->data[0].v_pointer, prepend_value, 1);
}
+/**
+ * gst_value_list_append_value:
+ *
+ */
void
gst_value_list_append_value (GValue *value, const GValue *append_value)
{
g_array_append_vals ((GArray *) value->data[0].v_pointer, append_value, 1);
}
+/**
+ * gst_value_list_get_size:
+ *
+ */
guint
gst_value_list_get_size (const GValue *value)
{
return ((GArray *) value->data[0].v_pointer)->len;
}
+/**
+ * gst_value_list_get_value:
+ *
+ */
const GValue *
gst_value_list_get_value (const GValue *value, guint index)
{
}
}
+static void
+gst_value_transform_list_string (const GValue *src_value,
+ GValue *dest_value)
+{
+ GValue *list_value;
+ GArray *array;
+ GString *s;
+ int i;
+ char *list_s;
+
+ array = src_value->data[0].v_pointer;
+
+ s = g_string_new("{ ");
+ for(i=0;i<array->len;i++){
+ list_value = &g_array_index(array, GValue, i);
+
+ if (i != 0) {
+ g_string_append (s, ", ");
+ }
+ list_s = g_strdup_value_contents (list_value);
+ g_string_append (s, list_s);
+ g_free (list_s);
+ }
+ g_string_append (s, " }");
+
+ dest_value->data[0].v_pointer = g_string_free (s, FALSE);
+}
+
+static int
+gst_value_compare_list (const GValue *value1, const GValue *value2)
+{
+ int i,j;
+ GArray *array1 = value1->data[0].v_pointer;
+ GArray *array2 = value2->data[0].v_pointer;
+ GValue *v1;
+ GValue *v2;
+
+ if (array1->len != array2->len) return GST_VALUE_UNORDERED;
+
+ for(i=0;i<array1->len;i++){
+ v1 = &g_array_index (array1, GValue, i);
+ for(j=0;j<array1->len;j++){
+ v2 = &g_array_index (array2, GValue, j);
+ if (gst_value_compare(v1, v2) == GST_VALUE_EQUAL) break;
+ }
+ if (j==array1->len) {
+ return GST_VALUE_UNORDERED;
+ }
+ }
+
+ return GST_VALUE_EQUAL;
+}
+
+static char *
+gst_value_serialize_list (const GValue *value)
+{
+ g_warning("unimplemented");
+ return NULL;
+}
+
+static gboolean
+gst_value_deserialize_list (GValue *dest, const char *s)
+{
+ g_warning("unimplemented");
+ return FALSE;
+}
+
+/*************************************/
/* fourcc */
static void
return NULL;
}
+/**
+ * gst_value_set_fourcc:
+ *
+ */
void
gst_value_set_fourcc (GValue *value, guint32 fourcc)
{
value->data[0].v_int = fourcc;
}
+/**
+ * gst_value_get_fourcc:
+ *
+ */
guint32
gst_value_get_fourcc (const GValue *value)
{
return value->data[0].v_int;
}
+static void
+gst_value_transform_fourcc_string (const GValue *src_value,
+ GValue *dest_value)
+{
+ guint32 fourcc = src_value->data[0].v_int;
+
+ if (g_ascii_isprint ((fourcc>>0) & 0xff) &&
+ g_ascii_isprint ((fourcc>>8) & 0xff) &&
+ g_ascii_isprint ((fourcc>>16) & 0xff) &&
+ g_ascii_isprint ((fourcc>>24) & 0xff)){
+ dest_value->data[0].v_pointer = g_strdup_printf(
+ GST_FOURCC_FORMAT, GST_FOURCC_ARGS(fourcc));
+ } else {
+ dest_value->data[0].v_pointer = g_strdup_printf("0x%08x", fourcc);
+ }
+}
+
+static int
+gst_value_compare_fourcc (const GValue *value1, const GValue *value2)
+{
+ if (value2->data[0].v_int == value1->data[0].v_int) return GST_VALUE_EQUAL;
+ return GST_VALUE_UNORDERED;
+}
+
+static char *
+gst_value_serialize_fourcc (const GValue *value)
+{
+ g_warning("unimplemented");
+ return NULL;
+}
+
+static gboolean
+gst_value_deserialize_fourcc (GValue *dest, const char *s)
+{
+ g_warning("unimplemented");
+ return FALSE;
+}
+
+/*************************************/
/* int range */
static void
return NULL;
}
+/**
+ * gst_value_set_int_range:
+ *
+ */
void
gst_value_set_int_range (GValue *value, int start, int end)
{
value->data[1].v_int = end;
}
+/**
+ * gst_value_get_int_range_min:
+ *
+ */
int
gst_value_get_int_range_min (const GValue *value)
{
return value->data[0].v_int;
}
+/**
+ * gst_value_get_int_range_max:
+ *
+ */
int
gst_value_get_int_range_max (const GValue *value)
{
return value->data[1].v_int;
}
+static void
+gst_value_transform_int_range_string (const GValue *src_value,
+ GValue *dest_value)
+{
+ dest_value->data[0].v_pointer = g_strdup_printf("[%d,%d]",
+ (int)src_value->data[0].v_int, (int)src_value->data[1].v_int);
+}
+
+static int
+gst_value_compare_int_range (const GValue *value1, const GValue *value2)
+{
+ if (value2->data[0].v_int == value1->data[0].v_int &&
+ value2->data[0].v_int == value1->data[0].v_int) return GST_VALUE_EQUAL;
+ return GST_VALUE_UNORDERED;
+}
+
+static char *
+gst_value_serialize_int_range (const GValue *value)
+{
+ g_warning("unimplemented");
+ return NULL;
+}
+
+static gboolean
+gst_value_deserialize_int_range (GValue *dest, const char *s)
+{
+ g_warning("unimplemented");
+ return FALSE;
+}
+
+/*************************************/
/* double range */
static void
return NULL;
}
+/**
+ * gst_value_set_double_range:
+ *
+ */
void
gst_value_set_double_range (GValue *value, double start, double end)
{
value->data[1].v_double = end;
}
+/**
+ * gst_value_get_double_range_min:
+ *
+ */
double
gst_value_get_double_range_min (const GValue *value)
{
return value->data[0].v_double;
}
+/**
+ * gst_value_get_double_range_max:
+ *
+ */
double
gst_value_get_double_range_max (const GValue *value)
{
return value->data[1].v_double;
}
+static void
+gst_value_transform_double_range_string (const GValue *src_value,
+ GValue *dest_value)
+{
+ char 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 int
+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 char *
+gst_value_serialize_double_range (const GValue *value)
+{
+ g_warning("unimplemented");
+ return NULL;
+}
+
+static gboolean
+gst_value_deserialize_double_range (GValue *dest, const char *s)
+{
+ g_warning("unimplemented");
+ return FALSE;
+}
+
+/*************************************/
/* GstCaps */
+/**
+ * gst_value_set_caps:
+ *
+ */
void
gst_value_set_caps (GValue *value, const GstCaps *caps)
{
value->data[0].v_pointer = gst_caps_copy (caps);
}
+/**
+ * gst_value_get_caps:
+ *
+ */
const GstCaps *
gst_value_get_caps (const GValue *value)
{
return value->data[0].v_pointer;
}
-/* fourcc */
+/*************************************/
+/* boolean */
-static void
-gst_value_transform_fourcc_string (const GValue *src_value,
- GValue *dest_value)
+static int
+gst_value_compare_boolean (const GValue *value1, const GValue *value2)
{
- guint32 fourcc = src_value->data[0].v_int;
+ if ((value1->data[0].v_int!=0) == (value2->data[0].v_int!=0))
+ return GST_VALUE_EQUAL;
+ return GST_VALUE_UNORDERED;
+}
- if (g_ascii_isprint ((fourcc>>0) & 0xff) &&
- g_ascii_isprint ((fourcc>>8) & 0xff) &&
- g_ascii_isprint ((fourcc>>16) & 0xff) &&
- g_ascii_isprint ((fourcc>>24) & 0xff)){
- dest_value->data[0].v_pointer = g_strdup_printf(
- GST_FOURCC_FORMAT, GST_FOURCC_ARGS(fourcc));
- } else {
- dest_value->data[0].v_pointer = g_strdup_printf("0x%08x", fourcc);
- }
+static char *
+gst_value_serialize_boolean (const GValue *value)
+{
+ g_warning("unimplemented");
+ return NULL;
}
-static void
-gst_value_transform_int_range_string (const GValue *src_value,
- GValue *dest_value)
+static gboolean
+gst_value_deserialize_boolean (GValue *dest, const char *s)
{
- dest_value->data[0].v_pointer = g_strdup_printf("[%d,%d]",
- (int)src_value->data[0].v_int, (int)src_value->data[1].v_int);
+ g_warning("unimplemented");
+ return FALSE;
}
-static void
-gst_value_transform_double_range_string (const GValue *src_value,
- GValue *dest_value)
+/*************************************/
+/* int */
+
+static int
+gst_value_compare_int (const GValue *value1, const GValue *value2)
{
- char s1[G_ASCII_DTOSTR_BUF_SIZE],s2[G_ASCII_DTOSTR_BUF_SIZE];
+ if (value1->data[0].v_int > value2->data[0].v_int)
+ return GST_VALUE_GREATER_THAN;
+ if (value1->data[0].v_int < value2->data[0].v_int)
+ return GST_VALUE_LESS_THAN;
+ return GST_VALUE_EQUAL;
+}
- 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 char *
+gst_value_serialize_int (const GValue *value)
+{
+ g_warning("unimplemented");
+ return NULL;
}
-static void
-gst_value_transform_list_string (const GValue *src_value,
- GValue *dest_value)
+static gboolean
+gst_value_deserialize_int (GValue *dest, const char *s)
{
- GValue *list_value;
- GArray *array;
- GString *s;
- int i;
- char *list_s;
+ g_warning("unimplemented");
+ return FALSE;
+}
- array = src_value->data[0].v_pointer;
-
- s = g_string_new("{ ");
- for(i=0;i<array->len;i++){
- list_value = &g_array_index(array, GValue, i);
-
- if (i != 0) {
- g_string_append (s, ", ");
- }
- list_s = g_strdup_value_contents (list_value);
- g_string_append (s, list_s);
- g_free (list_s);
- }
- g_string_append (s, " }");
-
- dest_value->data[0].v_pointer = g_string_free (s, FALSE);
-}
-
-/* comparison functions */
-
-static int
-gst_value_compare_boolean (const GValue *value1, const GValue *value2)
-{
- /* FIXME: ds, can we assume that those values are only TRUE and FALSE? */
- if (value1->data[0].v_int == value2->data[0].v_int)
- return GST_VALUE_EQUAL;
- return GST_VALUE_UNORDERED;
-}
-
-static int
-gst_value_compare_int (const GValue *value1, const GValue *value2)
-{
- if (value1->data[0].v_int > value2->data[0].v_int)
- return GST_VALUE_GREATER_THAN;
- if (value1->data[0].v_int < value2->data[0].v_int)
- return GST_VALUE_LESS_THAN;
- return GST_VALUE_EQUAL;
-}
+/*************************************/
+/* double */
static int
gst_value_compare_double (const GValue *value1, const GValue *value2)
return GST_VALUE_UNORDERED;
}
-static int
-gst_value_compare_float (const GValue *value1, const GValue *value2)
+static char *
+gst_value_serialize_double (const GValue *value)
{
- 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 int
-gst_value_compare_string (const GValue *value1, const GValue *value2)
-{
- int 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 int
-gst_value_compare_fourcc (const GValue *value1, const GValue *value2)
-{
- if (value2->data[0].v_int == value1->data[0].v_int) return GST_VALUE_EQUAL;
- return GST_VALUE_UNORDERED;
+ g_warning("unimplemented");
+ return NULL;
}
-static int
-gst_value_compare_int_range (const GValue *value1, const GValue *value2)
+static gboolean
+gst_value_deserialize_double (GValue *dest, const char *s)
{
- if (value2->data[0].v_int == value1->data[0].v_int &&
- value2->data[0].v_int == value1->data[0].v_int) return GST_VALUE_EQUAL;
- return GST_VALUE_UNORDERED;
+ g_warning("unimplemented");
+ return FALSE;
}
-static int
-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;
-}
+/*************************************/
+/* string */
static int
-gst_value_compare_list (const GValue *value1, const GValue *value2)
+gst_value_compare_string (const GValue *value1, const GValue *value2)
{
- int i,j;
- GArray *array1 = value1->data[0].v_pointer;
- GArray *array2 = value2->data[0].v_pointer;
- GValue *v1;
- GValue *v2;
-
- if (array1->len != array2->len) return GST_VALUE_UNORDERED;
-
- for(i=0;i<array1->len;i++){
- v1 = &g_array_index (array1, GValue, i);
- for(j=0;j<array1->len;j++){
- v2 = &g_array_index (array2, GValue, j);
- if (gst_value_compare(v1, v2) == GST_VALUE_EQUAL) break;
- }
- if (j==array1->len) {
- return GST_VALUE_UNORDERED;
- }
- }
-
+ int 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;
}
-gboolean
-gst_value_can_compare (const GValue *value1, const GValue *value2)
-{
- GstValueCompareInfo *compare_info;
- int i;
-
- if(G_VALUE_TYPE(value1) != G_VALUE_TYPE(value2))return FALSE;
- for(i=0;i<gst_value_compare_funcs->len;i++){
- compare_info = &g_array_index(gst_value_compare_funcs,
- GstValueCompareInfo, i);
- if(compare_info->type == G_VALUE_TYPE(value1)) return TRUE;
- }
-
- return FALSE;
-}
-
-int
-gst_value_compare (const GValue *value1, const GValue *value2)
-{
- GstValueCompareInfo *compare_info;
- int i;
-
- if (G_VALUE_TYPE(value1) != G_VALUE_TYPE(value2)) return GST_VALUE_UNORDERED;
-
- for(i=0;i<gst_value_compare_funcs->len;i++){
- compare_info = &g_array_index(gst_value_compare_funcs,
- GstValueCompareInfo, i);
- if(compare_info->type != G_VALUE_TYPE(value1)) continue;
-
- return compare_info->func(value1, value2);
- }
-
- g_critical("unable to compare values of type %s\n",
- g_type_name (G_VALUE_TYPE (value1)));
- return GST_VALUE_UNORDERED;
-}
-
-void
-gst_value_register_compare_func (GType type, GstValueCompareFunc func)
+static char *
+gst_value_serialize_string (const GValue *value)
{
- GstValueCompareInfo compare_info;
-
- compare_info.type = type;
- compare_info.func = func;
-
- g_array_append_val(gst_value_compare_funcs, compare_info);
+ g_warning("unimplemented");
+ return NULL;
}
-/* union */
-
-gboolean
-gst_value_can_union (const GValue *value1, const GValue *value2)
+static gboolean
+gst_value_deserialize_string (GValue *dest, const char *s)
{
- GstValueUnionInfo *union_info;
- int i;
-
- for(i=0;i<gst_value_union_funcs->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;
- }
-
+ g_warning("unimplemented");
return FALSE;
}
-gboolean
-gst_value_union (GValue *dest, const GValue *value1, const GValue *value2)
-{
- GstValueUnionInfo *union_info;
- int i;
-
- for(i=0;i<gst_value_union_funcs->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 union_info->func(dest, value1, value2);
- }
- }
-
- gst_value_list_concat (dest, value1, value2);
- return TRUE;
-}
-
-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);
-}
+/*************************************/
+/* unions */
+/*************************************/
/* intersection */
static gboolean
return ret;
}
+
+/*************************************/
+
+/**
+ * gst_value_can_compare:
+ *
+ */
+gboolean
+gst_value_can_compare (const GValue *value1, const GValue *value2)
+{
+ GstValueTable *table;
+ int i;
+
+ if(G_VALUE_TYPE(value1) != G_VALUE_TYPE(value2))return FALSE;
+ for(i=0;i<gst_value_table->len;i++){
+ table = &g_array_index(gst_value_table, GstValueTable, i);
+ if(table->type == G_VALUE_TYPE(value1) &&
+ table->compare) return TRUE;
+ }
+
+ return FALSE;
+}
+
+/**
+ * gst_value_compare:
+ *
+ */
+int
+gst_value_compare (const GValue *value1, const GValue *value2)
+{
+ GstValueTable *table;
+ int i;
+
+ if (G_VALUE_TYPE(value1) != G_VALUE_TYPE(value2)) return GST_VALUE_UNORDERED;
+
+ for(i=0;i<gst_value_table->len;i++){
+ table = &g_array_index(gst_value_table, GstValueTable, i);
+ if(table->type != G_VALUE_TYPE(value1) ||
+ table->compare == NULL) continue;
+
+ return table->compare(value1, value2);
+ }
+
+ g_critical("unable to compare values of type %s\n",
+ g_type_name (G_VALUE_TYPE (value1)));
+ return GST_VALUE_UNORDERED;
+}
+
+/* union */
+
+/**
+ * gst_value_can_union:
+ *
+ */
+gboolean
+gst_value_can_union (const GValue *value1, const GValue *value2)
+{
+ GstValueUnionInfo *union_info;
+ int i;
+
+ for(i=0;i<gst_value_union_funcs->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;
+ }
+
+ return FALSE;
+}
+
+/**
+ * gst_value_union:
+ *
+ */
+gboolean
+gst_value_union (GValue *dest, const GValue *value1, const GValue *value2)
+{
+ GstValueUnionInfo *union_info;
+ int i;
+
+ for(i=0;i<gst_value_union_funcs->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 union_info->func(dest, value1, value2);
+ }
+ }
+
+ gst_value_list_concat (dest, value1, value2);
+ return TRUE;
+}
+
+/**
+ * gst_value_register_union_func:
+ *
+ */
+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:
+ *
+ */
gboolean
gst_value_can_intersect (const GValue *value1, const GValue *value2)
{
return gst_value_can_compare (value1, value2);
}
+/**
+ * gst_value_intersect:
+ *
+ */
gboolean
gst_value_intersect (GValue *dest, const GValue *value1, const GValue *value2)
{
return ret;
}
-void
-gst_value_init_and_copy (GValue *dest, const GValue *src)
-{
- g_value_init (dest, G_VALUE_TYPE(src));
- g_value_copy (src, dest);
-}
-
+/**
+ * gst_value_register_intersection_func:
+ *
+ */
void
gst_value_register_intersect_func (GType type1, GType type2,
GstValueIntersectFunc func)
g_array_append_val(gst_value_intersect_funcs, intersect_info);
}
+/**
+ * gst_value_register:
+ *
+ */
+void
+gst_value_register (const GstValueTable *table)
+{
+ g_array_append_val(gst_value_table, *table);
+}
+
+/**
+ * gst_value_init_and_copy:
+ *
+ */
+void
+gst_value_init_and_copy (GValue *dest, const GValue *src)
+{
+ g_value_init (dest, G_VALUE_TYPE(src));
+ g_value_copy (src, dest);
+}
+
void
_gst_value_initialize (void)
{
};
//const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
+ gst_value_table = g_array_new(FALSE, FALSE, sizeof(GstValueTable));
+ gst_value_union_funcs = g_array_new(FALSE, FALSE,
+ sizeof(GstValueUnionInfo));
+ gst_value_intersect_funcs = g_array_new(FALSE, FALSE,
+ sizeof(GstValueIntersectInfo));
+
{
static const GTypeValueTable value_table = {
gst_value_init_fourcc,
"p",
gst_value_lcopy_fourcc
};
+ static GstValueTable gst_value = {
+ 0,
+ gst_value_compare_fourcc,
+ gst_value_serialize_fourcc,
+ gst_value_deserialize_fourcc,
+ };
info.value_table = &value_table;
gst_type_fourcc = g_type_register_static (G_TYPE_BOXED, "GstFourcc", &info, 0);
+ gst_value.type = gst_type_int_range;
+ gst_value_register (&gst_value);
}
{
"pp",
gst_value_lcopy_int_range
};
+ static GstValueTable gst_value = {
+ 0,
+ gst_value_compare_int_range,
+ gst_value_serialize_int_range,
+ gst_value_deserialize_int_range,
+ };
info.value_table = &value_table;
gst_type_int_range = g_type_register_static (G_TYPE_BOXED, "GstIntRange", &info, 0);
+ gst_value.type = gst_type_int_range;
+ gst_value_register (&gst_value);
}
{
"pp",
gst_value_lcopy_double_range
};
+ static GstValueTable gst_value = {
+ 0,
+ gst_value_compare_double_range,
+ gst_value_serialize_double_range,
+ gst_value_deserialize_double_range,
+ };
info.value_table = &value_table;
gst_type_double_range = g_type_register_static (G_TYPE_BOXED, "GstDoubleRange", &info, 0);
+ gst_value.type = gst_type_double_range;
+ gst_value_register (&gst_value);
}
{
"p",
gst_value_lcopy_list
};
+ static GstValueTable gst_value = {
+ 0,
+ gst_value_compare_list,
+ gst_value_serialize_list,
+ gst_value_deserialize_list,
+ };
info.value_table = &value_table;
gst_type_list = g_type_register_static (G_TYPE_BOXED, "GstValueList", &info, 0);
+ gst_value.type = gst_type_double_range;
+ gst_value_register (&gst_value);
+ }
+
+ {
+ static const GstValueTable gst_value = {
+ G_TYPE_INT,
+ gst_value_compare_int,
+ gst_value_serialize_int,
+ gst_value_deserialize_int,
+ };
+ gst_value_register (&gst_value);
+ }
+
+ {
+ static const GstValueTable gst_value = {
+ G_TYPE_DOUBLE,
+ gst_value_compare_double,
+ gst_value_serialize_double,
+ gst_value_deserialize_double,
+ };
+ gst_value_register (&gst_value);
+ }
+
+ {
+ static const GstValueTable gst_value = {
+ G_TYPE_STRING,
+ gst_value_compare_string,
+ gst_value_serialize_string,
+ gst_value_deserialize_string,
+ };
+ gst_value_register (&gst_value);
+ }
+
+ {
+ static const GstValueTable gst_value = {
+ G_TYPE_BOOLEAN,
+ gst_value_compare_boolean,
+ gst_value_serialize_boolean,
+ gst_value_deserialize_boolean,
+ };
+ gst_value_register (&gst_value);
}
g_value_register_transform_func (GST_TYPE_FOURCC, G_TYPE_STRING,
g_value_register_transform_func (GST_TYPE_LIST, G_TYPE_STRING,
gst_value_transform_list_string);
- gst_value_compare_funcs = g_array_new(FALSE, FALSE,
- sizeof(GstValueCompareInfo));
-
- gst_value_register_compare_func (G_TYPE_BOOLEAN, gst_value_compare_boolean);
- gst_value_register_compare_func (G_TYPE_INT, gst_value_compare_int);
- gst_value_register_compare_func (G_TYPE_FLOAT, gst_value_compare_float);
- gst_value_register_compare_func (G_TYPE_DOUBLE, gst_value_compare_double);
- gst_value_register_compare_func (G_TYPE_STRING, gst_value_compare_string);
- gst_value_register_compare_func (GST_TYPE_FOURCC, gst_value_compare_fourcc);
- gst_value_register_compare_func (GST_TYPE_INT_RANGE, gst_value_compare_int_range);
- gst_value_register_compare_func (GST_TYPE_DOUBLE_RANGE, gst_value_compare_double_range);
- gst_value_register_compare_func (GST_TYPE_LIST, gst_value_compare_list);
-
- gst_value_union_funcs = g_array_new(FALSE, FALSE,
- sizeof(GstValueUnionInfo));
-
- gst_value_intersect_funcs = g_array_new(FALSE, FALSE,
- sizeof(GstValueIntersectInfo));
-
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,
projects / platform / upstream / gstreamer.git / commitdiff