23b806657494c8b278bbaca15fc99ca4129fa013
[platform/upstream/gstreamer.git] / gst / gstvalue.c
1 /* GStreamer
2  * Copyright (C) <2003> David A. Schleef <ds@schleef.org>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26
27 #include "gst_private.h"
28 #include <gst/gst.h>
29 #include <gobject/gvaluecollector.h>
30
31 typedef struct _GstValueUnionInfo GstValueUnionInfo;
32 struct _GstValueUnionInfo
33 {
34   GType type1;
35   GType type2;
36   GstValueUnionFunc func;
37 };
38
39 typedef struct _GstValueIntersectInfo GstValueIntersectInfo;
40 struct _GstValueIntersectInfo
41 {
42   GType type1;
43   GType type2;
44   GstValueIntersectFunc func;
45 };
46
47 typedef struct _GstValueSubtractInfo GstValueSubtractInfo;
48 struct _GstValueSubtractInfo
49 {
50   GType minuend;
51   GType subtrahend;
52   GstValueSubtractFunc func;
53 };
54
55 GType gst_type_fourcc;
56 GType gst_type_int_range;
57 GType gst_type_double_range;
58 GType gst_type_list;
59 GType gst_type_fixed_list;
60
61 static GArray *gst_value_table;
62 static GArray *gst_value_union_funcs;
63 static GArray *gst_value_intersect_funcs;
64 static GArray *gst_value_subtract_funcs;
65
66 /********
67  * list *
68  ********/
69
70 /* two helper functions to serialize/stringify any type of list
71  * regular lists are done with { }, fixed lists with < >
72  */
73 static char *
74 gst_value_serialize_any_list (const GValue * value, const char *begin,
75     const char *end)
76 {
77   int i;
78   GArray *array = value->data[0].v_pointer;
79   GString *s;
80   GValue *v;
81   gchar *s_val;
82
83   s = g_string_new (begin);
84   for (i = 0; i < array->len; i++) {
85     v = &g_array_index (array, GValue, i);
86     s_val = gst_value_serialize (v);
87     g_string_append (s, s_val);
88     g_free (s_val);
89     if (i < array->len - 1) {
90       g_string_append (s, ", ");
91     }
92   }
93   g_string_append (s, end);
94   return g_string_free (s, FALSE);
95 }
96
97 static void
98 gst_value_transform_any_list_string (const GValue * src_value,
99     GValue * dest_value, const char *begin, const char *end)
100 {
101   GValue *list_value;
102   GArray *array;
103   GString *s;
104   int i;
105   char *list_s;
106
107   array = src_value->data[0].v_pointer;
108
109   s = g_string_new (begin);
110   for (i = 0; i < array->len; i++) {
111     list_value = &g_array_index (array, GValue, i);
112
113     if (i != 0) {
114       g_string_append (s, ", ");
115     }
116     list_s = g_strdup_value_contents (list_value);
117     g_string_append (s, list_s);
118     g_free (list_s);
119   }
120   g_string_append (s, end);
121
122   dest_value->data[0].v_pointer = g_string_free (s, FALSE);
123 }
124
125 /* GValue functions usable for both regular lists and fixed lists */
126 static void
127 gst_value_init_list (GValue * value)
128 {
129   value->data[0].v_pointer = g_array_new (FALSE, TRUE, sizeof (GValue));
130 }
131
132 static GArray *
133 gst_value_list_array_copy (const GArray * src)
134 {
135   GArray *dest;
136   gint i;
137
138   dest = g_array_sized_new (FALSE, TRUE, sizeof (GValue), src->len);
139   g_array_set_size (dest, src->len);
140   for (i = 0; i < src->len; i++) {
141     gst_value_init_and_copy (&g_array_index (dest, GValue, i),
142         &g_array_index (src, GValue, i));
143   }
144
145   return dest;
146 }
147
148 static void
149 gst_value_copy_list (const GValue * src_value, GValue * dest_value)
150 {
151   dest_value->data[0].v_pointer =
152       gst_value_list_array_copy ((GArray *) src_value->data[0].v_pointer);
153 }
154
155 static void
156 gst_value_free_list (GValue * value)
157 {
158   gint i;
159   GArray *src = (GArray *) value->data[0].v_pointer;
160
161   if ((value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS) == 0) {
162     for (i = 0; i < src->len; i++) {
163       g_value_unset (&g_array_index (src, GValue, i));
164     }
165     g_array_free (src, TRUE);
166   }
167 }
168
169 static gpointer
170 gst_value_list_peek_pointer (const GValue * value)
171 {
172   return value->data[0].v_pointer;
173 }
174
175 static gchar *
176 gst_value_collect_list (GValue * value, guint n_collect_values,
177     GTypeCValue * collect_values, guint collect_flags)
178 {
179   if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
180     value->data[0].v_pointer = collect_values[0].v_pointer;
181     value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
182   } else {
183     value->data[0].v_pointer =
184         gst_value_list_array_copy ((GArray *) collect_values[0].v_pointer);
185   }
186   return NULL;
187 }
188
189 static gchar *
190 gst_value_lcopy_list (const GValue * value, guint n_collect_values,
191     GTypeCValue * collect_values, guint collect_flags)
192 {
193   GArray **dest = collect_values[0].v_pointer;
194
195   if (!dest)
196     return g_strdup_printf ("value location for `%s' passed as NULL",
197         G_VALUE_TYPE_NAME (value));
198   if (!value->data[0].v_pointer)
199     return g_strdup_printf ("invalid value given for `%s'",
200         G_VALUE_TYPE_NAME (value));
201   if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
202     *dest = (GArray *) value->data[0].v_pointer;
203   } else {
204     *dest = gst_value_list_array_copy ((GArray *) value->data[0].v_pointer);
205   }
206   return NULL;
207 }
208
209 /**
210  * gst_value_list_prepend_value:
211  * @value: a GstValueList to prepend a value to
212  * @prepend_value: the value to prepend
213  *
214  * Prepends @prepend_value to the GstValueList in @value.
215  *
216  */
217 void
218 gst_value_list_prepend_value (GValue * value, const GValue * prepend_value)
219 {
220   GValue val = { 0, };
221
222   g_return_if_fail (GST_VALUE_HOLDS_LIST (value)
223       || GST_VALUE_HOLDS_FIXED_LIST (value));
224
225   gst_value_init_and_copy (&val, prepend_value);
226   g_array_prepend_vals ((GArray *) value->data[0].v_pointer, &val, 1);
227 }
228
229 /**
230  * gst_value_list_append_value:
231  * @value: a GstValueList to append a value to
232  * @append_value: the value to append
233  *
234  * Appends @append_value to the GstValueList in @value.
235  */
236 void
237 gst_value_list_append_value (GValue * value, const GValue * append_value)
238 {
239   GValue val = { 0, };
240
241   g_return_if_fail (GST_VALUE_HOLDS_LIST (value)
242       || GST_VALUE_HOLDS_FIXED_LIST (value));
243
244   gst_value_init_and_copy (&val, append_value);
245   g_array_append_vals ((GArray *) value->data[0].v_pointer, &val, 1);
246 }
247
248 /**
249  * gst_value_list_get_size:
250  * @value: a GstValueList
251  *
252  * Gets the number of values contained in @value.
253  *
254  * Returns: the number of values
255  */
256 guint
257 gst_value_list_get_size (const GValue * value)
258 {
259   g_return_val_if_fail (GST_VALUE_HOLDS_LIST (value)
260       || GST_VALUE_HOLDS_FIXED_LIST (value), 0);
261
262   return ((GArray *) value->data[0].v_pointer)->len;
263 }
264
265 /**
266  * gst_value_list_get_value:
267  * @value: a GstValueList
268  * @index: index of value to get from the list
269  *
270  * Gets the value that is a member of the list contained in @value and
271  * has the index @index.
272  *
273  * Returns: the value at the given index
274  */
275 const GValue *
276 gst_value_list_get_value (const GValue * value, guint index)
277 {
278   g_return_val_if_fail (GST_VALUE_HOLDS_LIST (value)
279       || GST_VALUE_HOLDS_FIXED_LIST (value), NULL);
280   g_return_val_if_fail (index < gst_value_list_get_size (value), NULL);
281
282   return (const GValue *) &g_array_index ((GArray *) value->data[0].v_pointer,
283       GValue, index);
284 }
285
286 /**
287  * gst_value_list_concat:
288  * @dest: an uninitialized #GValue to take the result
289  * @value1: first value to put into the union
290  * @value2: second value to put into the union
291  *
292  * Concatenates copies of value1 and value2 into a list.  The value
293  * @dest is initialized to the type GST_TYPE_LIST.
294  */
295 void
296 gst_value_list_concat (GValue * dest, const GValue * value1,
297     const GValue * value2)
298 {
299   guint i, value1_length, value2_length;
300   GArray *array;
301
302   g_return_if_fail (dest != NULL);
303   g_return_if_fail (G_VALUE_TYPE (dest) == 0);
304   g_return_if_fail (G_IS_VALUE (value1));
305   g_return_if_fail (G_IS_VALUE (value2));
306
307   value1_length =
308       (GST_VALUE_HOLDS_LIST (value1) ? gst_value_list_get_size (value1) : 1);
309   value2_length =
310       (GST_VALUE_HOLDS_LIST (value2) ? gst_value_list_get_size (value2) : 1);
311   g_value_init (dest, GST_TYPE_LIST);
312   array = (GArray *) dest->data[0].v_pointer;
313   g_array_set_size (array, value1_length + value2_length);
314
315   if (GST_VALUE_HOLDS_LIST (value1)) {
316     for (i = 0; i < value1_length; i++) {
317       gst_value_init_and_copy (&g_array_index (array, GValue, i),
318           gst_value_list_get_value (value1, i));
319     }
320   } else {
321     gst_value_init_and_copy (&g_array_index (array, GValue, 0), value1);
322   }
323
324   if (GST_VALUE_HOLDS_LIST (value2)) {
325     for (i = 0; i < value2_length; i++) {
326       gst_value_init_and_copy (&g_array_index (array, GValue,
327               i + value1_length), gst_value_list_get_value (value2, i));
328     }
329   } else {
330     gst_value_init_and_copy (&g_array_index (array, GValue, value1_length),
331         value2);
332   }
333 }
334
335 static void
336 gst_value_transform_list_string (const GValue * src_value, GValue * dest_value)
337 {
338   gst_value_transform_any_list_string (src_value, dest_value, "{ ", " }");
339 }
340
341 static void
342 gst_value_transform_fixed_list_string (const GValue * src_value,
343     GValue * dest_value)
344 {
345   gst_value_transform_any_list_string (src_value, dest_value, "< ", " >");
346 }
347
348 static int
349 gst_value_compare_list (const GValue * value1, const GValue * value2)
350 {
351   int i, j;
352   GArray *array1 = value1->data[0].v_pointer;
353   GArray *array2 = value2->data[0].v_pointer;
354   GValue *v1;
355   GValue *v2;
356
357   if (array1->len != array2->len)
358     return GST_VALUE_UNORDERED;
359
360   for (i = 0; i < array1->len; i++) {
361     v1 = &g_array_index (array1, GValue, i);
362     for (j = 0; j < array1->len; j++) {
363       v2 = &g_array_index (array2, GValue, j);
364       if (gst_value_compare (v1, v2) == GST_VALUE_EQUAL)
365         break;
366     }
367     if (j == array1->len) {
368       return GST_VALUE_UNORDERED;
369     }
370   }
371
372   return GST_VALUE_EQUAL;
373 }
374
375 static char *
376 gst_value_serialize_list (const GValue * value)
377 {
378   return gst_value_serialize_any_list (value, "{ ", " }");
379 }
380
381 static gboolean
382 gst_value_deserialize_list (GValue * dest, const char *s)
383 {
384   g_warning ("unimplemented");
385   return FALSE;
386 }
387
388 static char *
389 gst_value_serialize_fixed_list (const GValue * value)
390 {
391   return gst_value_serialize_any_list (value, "< ", " >");
392 }
393
394 static gboolean
395 gst_value_deserialize_fixed_list (GValue * dest, const char *s)
396 {
397   g_warning ("unimplemented");
398   return FALSE;
399 }
400
401 /**********
402  * fourcc *
403  **********/
404
405 static void
406 gst_value_init_fourcc (GValue * value)
407 {
408   value->data[0].v_int = 0;
409 }
410
411 static void
412 gst_value_copy_fourcc (const GValue * src_value, GValue * dest_value)
413 {
414   dest_value->data[0].v_int = src_value->data[0].v_int;
415 }
416
417 static gchar *
418 gst_value_collect_fourcc (GValue * value, guint n_collect_values,
419     GTypeCValue * collect_values, guint collect_flags)
420 {
421   value->data[0].v_int = collect_values[0].v_int;
422
423   return NULL;
424 }
425
426 static gchar *
427 gst_value_lcopy_fourcc (const GValue * value, guint n_collect_values,
428     GTypeCValue * collect_values, guint collect_flags)
429 {
430   guint32 *fourcc_p = collect_values[0].v_pointer;
431
432   if (!fourcc_p)
433     return g_strdup_printf ("value location for `%s' passed as NULL",
434         G_VALUE_TYPE_NAME (value));
435
436   *fourcc_p = value->data[0].v_int;
437
438   return NULL;
439 }
440
441 /**
442  * gst_value_set_fourcc:
443  * @value: a GValue initialized to GST_TYPE_FOURCC
444  * @fourcc: the fourcc to set
445  *
446  * Sets @value to @fourcc.
447  */
448 void
449 gst_value_set_fourcc (GValue * value, guint32 fourcc)
450 {
451   g_return_if_fail (GST_VALUE_HOLDS_FOURCC (value));
452
453   value->data[0].v_int = fourcc;
454 }
455
456 /**
457  * gst_value_get_fourcc:
458  * @value: a GValue initialized to GST_TYPE_FOURCC
459  *
460  * Gets the fourcc contained in @value.
461  *
462  * Returns: the fourcc contained in @value.
463  */
464 guint32
465 gst_value_get_fourcc (const GValue * value)
466 {
467   g_return_val_if_fail (GST_VALUE_HOLDS_FOURCC (value), 0);
468
469   return value->data[0].v_int;
470 }
471
472 static void
473 gst_value_transform_fourcc_string (const GValue * src_value,
474     GValue * dest_value)
475 {
476   guint32 fourcc = src_value->data[0].v_int;
477
478   if (g_ascii_isprint ((fourcc >> 0) & 0xff) &&
479       g_ascii_isprint ((fourcc >> 8) & 0xff) &&
480       g_ascii_isprint ((fourcc >> 16) & 0xff) &&
481       g_ascii_isprint ((fourcc >> 24) & 0xff)) {
482     dest_value->data[0].v_pointer =
483         g_strdup_printf (GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
484   } else {
485     dest_value->data[0].v_pointer = g_strdup_printf ("0x%08x", fourcc);
486   }
487 }
488
489 static int
490 gst_value_compare_fourcc (const GValue * value1, const GValue * value2)
491 {
492   if (value2->data[0].v_int == value1->data[0].v_int)
493     return GST_VALUE_EQUAL;
494   return GST_VALUE_UNORDERED;
495 }
496
497 static char *
498 gst_value_serialize_fourcc (const GValue * value)
499 {
500   guint32 fourcc = value->data[0].v_int;
501
502   if (g_ascii_isalnum ((fourcc >> 0) & 0xff) &&
503       g_ascii_isalnum ((fourcc >> 8) & 0xff) &&
504       g_ascii_isalnum ((fourcc >> 16) & 0xff) &&
505       g_ascii_isalnum ((fourcc >> 24) & 0xff)) {
506     return g_strdup_printf (GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
507   } else {
508     return g_strdup_printf ("0x%08x", fourcc);
509   }
510 }
511
512 static gboolean
513 gst_value_deserialize_fourcc (GValue * dest, const char *s)
514 {
515   gboolean ret = FALSE;
516   guint32 fourcc = 0;
517   char *end;
518
519   if (strlen (s) == 4) {
520     fourcc = GST_MAKE_FOURCC (s[0], s[1], s[2], s[3]);
521     ret = TRUE;
522   } else if (g_ascii_isdigit (*s)) {
523     fourcc = strtoul (s, &end, 0);
524     if (*end == 0) {
525       ret = TRUE;
526     }
527   }
528   gst_value_set_fourcc (dest, fourcc);
529
530   return ret;
531 }
532
533 /*************
534  * int range *
535  *************/
536
537 static void
538 gst_value_init_int_range (GValue * value)
539 {
540   value->data[0].v_int = 0;
541   value->data[1].v_int = 0;
542 }
543
544 static void
545 gst_value_copy_int_range (const GValue * src_value, GValue * dest_value)
546 {
547   dest_value->data[0].v_int = src_value->data[0].v_int;
548   dest_value->data[1].v_int = src_value->data[1].v_int;
549 }
550
551 static gchar *
552 gst_value_collect_int_range (GValue * value, guint n_collect_values,
553     GTypeCValue * collect_values, guint collect_flags)
554 {
555   /* FIXME */
556   value->data[0].v_int = collect_values[0].v_int;
557   value->data[1].v_int = collect_values[1].v_int;
558
559   return NULL;
560 }
561
562 static gchar *
563 gst_value_lcopy_int_range (const GValue * value, guint n_collect_values,
564     GTypeCValue * collect_values, guint collect_flags)
565 {
566   guint32 *int_range_start = collect_values[0].v_pointer;
567   guint32 *int_range_end = collect_values[1].v_pointer;
568
569   if (!int_range_start)
570     return g_strdup_printf ("start value location for `%s' passed as NULL",
571         G_VALUE_TYPE_NAME (value));
572   if (!int_range_end)
573     return g_strdup_printf ("end value location for `%s' passed as NULL",
574         G_VALUE_TYPE_NAME (value));
575
576   *int_range_start = value->data[0].v_int;
577   *int_range_end = value->data[1].v_int;
578
579   return NULL;
580 }
581
582 /**
583  * gst_value_set_int_range:
584  * @value: a GValue initialized to GST_TYPE_INT_RANGE
585  * @start: the start of the range
586  * @end: the end of the range
587  *
588  * Sets @value to the range specified by @start and @end.
589  */
590 void
591 gst_value_set_int_range (GValue * value, int start, int end)
592 {
593   g_return_if_fail (GST_VALUE_HOLDS_INT_RANGE (value));
594   g_return_if_fail (start < end);
595
596   value->data[0].v_int = start;
597   value->data[1].v_int = end;
598 }
599
600 /**
601  * gst_value_get_int_range_min:
602  * @value: a GValue initialized to GST_TYPE_INT_RANGE
603  *
604  * Gets the minimum of the range specified by @value.
605  *
606  * Returns: the minimum of the range
607  */
608 int
609 gst_value_get_int_range_min (const GValue * value)
610 {
611   g_return_val_if_fail (GST_VALUE_HOLDS_INT_RANGE (value), 0);
612
613   return value->data[0].v_int;
614 }
615
616 /**
617  * gst_value_get_int_range_max:
618  * @value: a GValue initialized to GST_TYPE_INT_RANGE
619  *
620  * Gets the maximum of the range specified by @value.
621  *
622  * Returns: the maxumum of the range
623  */
624 int
625 gst_value_get_int_range_max (const GValue * value)
626 {
627   g_return_val_if_fail (GST_VALUE_HOLDS_INT_RANGE (value), 0);
628
629   return value->data[1].v_int;
630 }
631
632 static void
633 gst_value_transform_int_range_string (const GValue * src_value,
634     GValue * dest_value)
635 {
636   dest_value->data[0].v_pointer = g_strdup_printf ("[%d,%d]",
637       (int) src_value->data[0].v_int, (int) src_value->data[1].v_int);
638 }
639
640 static int
641 gst_value_compare_int_range (const GValue * value1, const GValue * value2)
642 {
643   if (value2->data[0].v_int == value1->data[0].v_int &&
644       value2->data[1].v_int == value1->data[1].v_int)
645     return GST_VALUE_EQUAL;
646   return GST_VALUE_UNORDERED;
647 }
648
649 static char *
650 gst_value_serialize_int_range (const GValue * value)
651 {
652   return g_strdup_printf ("[ %d, %d ]", value->data[0].v_int,
653       value->data[1].v_int);
654 }
655
656 static gboolean
657 gst_value_deserialize_int_range (GValue * dest, const char *s)
658 {
659   g_warning ("unimplemented");
660   return FALSE;
661 }
662
663 /****************
664  * double range *
665  ****************/
666
667 static void
668 gst_value_init_double_range (GValue * value)
669 {
670   value->data[0].v_double = 0;
671   value->data[1].v_double = 0;
672 }
673
674 static void
675 gst_value_copy_double_range (const GValue * src_value, GValue * dest_value)
676 {
677   dest_value->data[0].v_double = src_value->data[0].v_double;
678   dest_value->data[1].v_double = src_value->data[1].v_double;
679 }
680
681 static gchar *
682 gst_value_collect_double_range (GValue * value, guint n_collect_values,
683     GTypeCValue * collect_values, guint collect_flags)
684 {
685   value->data[0].v_double = collect_values[0].v_double;
686   value->data[1].v_double = collect_values[1].v_double;
687
688   return NULL;
689 }
690
691 static gchar *
692 gst_value_lcopy_double_range (const GValue * value, guint n_collect_values,
693     GTypeCValue * collect_values, guint collect_flags)
694 {
695   gdouble *double_range_start = collect_values[0].v_pointer;
696   gdouble *double_range_end = collect_values[1].v_pointer;
697
698   if (!double_range_start)
699     return g_strdup_printf ("start value location for `%s' passed as NULL",
700         G_VALUE_TYPE_NAME (value));
701   if (!double_range_end)
702     return g_strdup_printf ("end value location for `%s' passed as NULL",
703         G_VALUE_TYPE_NAME (value));
704
705   *double_range_start = value->data[0].v_double;
706   *double_range_end = value->data[1].v_double;
707
708   return NULL;
709 }
710
711 /**
712  * gst_value_set_double_range:
713  * @value: a GValue initialized to GST_TYPE_DOUBLE_RANGE
714  * @start: the start of the range
715  * @end: the end of the range
716  *
717  * Sets @value to the range specified by @start and @end.
718  */
719 void
720 gst_value_set_double_range (GValue * value, double start, double end)
721 {
722   g_return_if_fail (GST_VALUE_HOLDS_DOUBLE_RANGE (value));
723
724   value->data[0].v_double = start;
725   value->data[1].v_double = end;
726 }
727
728 /**
729  * gst_value_get_double_range_min:
730  * @value: a GValue initialized to GST_TYPE_DOUBLE_RANGE
731  *
732  * Gets the minimum of the range specified by @value.
733  *
734  * Returns: the minumum of the range
735  */
736 double
737 gst_value_get_double_range_min (const GValue * value)
738 {
739   g_return_val_if_fail (GST_VALUE_HOLDS_DOUBLE_RANGE (value), 0);
740
741   return value->data[0].v_double;
742 }
743
744 /**
745  * gst_value_get_double_range_max:
746  * @value: a GValue initialized to GST_TYPE_DOUBLE_RANGE
747  *
748  * Gets the maximum of the range specified by @value.
749  *
750  * Returns: the maxumum of the range
751  */
752 double
753 gst_value_get_double_range_max (const GValue * value)
754 {
755   g_return_val_if_fail (GST_VALUE_HOLDS_DOUBLE_RANGE (value), 0);
756
757   return value->data[1].v_double;
758 }
759
760 static void
761 gst_value_transform_double_range_string (const GValue * src_value,
762     GValue * dest_value)
763 {
764   char s1[G_ASCII_DTOSTR_BUF_SIZE], s2[G_ASCII_DTOSTR_BUF_SIZE];
765
766   dest_value->data[0].v_pointer = g_strdup_printf ("[%s,%s]",
767       g_ascii_dtostr (s1, G_ASCII_DTOSTR_BUF_SIZE,
768           src_value->data[0].v_double),
769       g_ascii_dtostr (s2, G_ASCII_DTOSTR_BUF_SIZE,
770           src_value->data[1].v_double));
771 }
772
773 static int
774 gst_value_compare_double_range (const GValue * value1, const GValue * value2)
775 {
776   if (value2->data[0].v_double == value1->data[0].v_double &&
777       value2->data[0].v_double == value1->data[0].v_double)
778     return GST_VALUE_EQUAL;
779   return GST_VALUE_UNORDERED;
780 }
781
782 static char *
783 gst_value_serialize_double_range (const GValue * value)
784 {
785   char d1[G_ASCII_DTOSTR_BUF_SIZE];
786   char d2[G_ASCII_DTOSTR_BUF_SIZE];
787
788   g_ascii_dtostr (d1, G_ASCII_DTOSTR_BUF_SIZE, value->data[0].v_double);
789   g_ascii_dtostr (d2, G_ASCII_DTOSTR_BUF_SIZE, value->data[1].v_double);
790   return g_strdup_printf ("[ %s, %s ]", d1, d2);
791 }
792
793 static gboolean
794 gst_value_deserialize_double_range (GValue * dest, const char *s)
795 {
796   g_warning ("unimplemented");
797   return FALSE;
798 }
799
800 /***********
801  * GstCaps *
802  ***********/
803
804 /**
805  * gst_value_set_caps:
806  * @value: a GValue initialized to GST_TYPE_CAPS
807  * @caps: the caps to set the value to
808  *
809  * Sets the contents of @value to coorespond to @caps.  The actual
810  * #GstCaps structure is copied before it is used.
811  */
812 void
813 gst_value_set_caps (GValue * value, const GstCaps * caps)
814 {
815   g_return_if_fail (G_VALUE_TYPE (value) == GST_TYPE_CAPS);
816
817   g_value_set_boxed (value, caps);
818 }
819
820 /**
821  * gst_value_get_caps:
822  * @value: a GValue initialized to GST_TYPE_CAPS
823  *
824  * Gets the contents of @value.
825  *
826  * Returns: the contents of @value
827  */
828 const GstCaps *
829 gst_value_get_caps (const GValue * value)
830 {
831   g_return_val_if_fail (G_VALUE_TYPE (value) == GST_TYPE_CAPS, NULL);
832
833   return (GstCaps *) g_value_get_boxed (value);
834 }
835
836 /*************
837  * GstBuffer *
838  *************/
839
840 static int
841 gst_value_compare_buffer (const GValue * value1, const GValue * value2)
842 {
843   GstBuffer *buf1 = g_value_get_boxed (value1);
844   GstBuffer *buf2 = g_value_get_boxed (value2);
845
846   if (GST_BUFFER_SIZE (buf1) != GST_BUFFER_SIZE (buf2))
847     return GST_VALUE_UNORDERED;
848   if (GST_BUFFER_SIZE (buf1) == 0)
849     return GST_VALUE_EQUAL;
850   g_assert (GST_BUFFER_DATA (buf1));
851   g_assert (GST_BUFFER_DATA (buf2));
852   if (memcmp (GST_BUFFER_DATA (buf1), GST_BUFFER_DATA (buf2),
853           GST_BUFFER_SIZE (buf1)) == 0)
854     return GST_VALUE_EQUAL;
855
856   return GST_VALUE_UNORDERED;
857 }
858
859 static char *
860 gst_value_serialize_buffer (const GValue * value)
861 {
862   guint8 *data;
863   int i;
864   int size;
865   char *string;
866   GstBuffer *buffer = g_value_get_boxed (value);
867
868   data = GST_BUFFER_DATA (buffer);
869   size = GST_BUFFER_SIZE (buffer);
870
871   string = malloc (size * 2 + 1);
872   for (i = 0; i < size; i++) {
873     sprintf (string + i * 2, "%02x", data[i]);
874   }
875   string[size * 2] = 0;
876
877   return string;
878 }
879
880 static gboolean
881 gst_value_deserialize_buffer (GValue * dest, const char *s)
882 {
883   GstBuffer *buffer;
884   gboolean ret = TRUE;
885   int len;
886   char ts[3];
887   guint8 *data;
888   int i;
889
890   len = strlen (s);
891   if (len & 1)
892     return FALSE;
893   buffer = gst_buffer_new_and_alloc (len / 2);
894   data = GST_BUFFER_DATA (buffer);
895   for (i = 0; i < len / 2; i++) {
896     if (!isxdigit ((int) s[i * 2]) || !isxdigit ((int) s[i * 2 + 1])) {
897       ret = FALSE;
898       break;
899     }
900     ts[0] = s[i * 2 + 0];
901     ts[1] = s[i * 2 + 1];
902     ts[2] = 0;
903
904     data[i] = strtoul (ts, NULL, 16);
905   }
906
907   if (ret) {
908     g_value_set_boxed (dest, buffer);
909     return TRUE;
910   } else {
911     gst_buffer_unref (buffer);
912     return FALSE;
913   }
914 }
915
916
917 /***********
918  * boolean *
919  ***********/
920
921 static int
922 gst_value_compare_boolean (const GValue * value1, const GValue * value2)
923 {
924   if ((value1->data[0].v_int != 0) == (value2->data[0].v_int != 0))
925     return GST_VALUE_EQUAL;
926   return GST_VALUE_UNORDERED;
927 }
928
929 static char *
930 gst_value_serialize_boolean (const GValue * value)
931 {
932   if (value->data[0].v_int) {
933     return g_strdup ("true");
934   }
935   return g_strdup ("false");
936 }
937
938 static gboolean
939 gst_value_deserialize_boolean (GValue * dest, const char *s)
940 {
941   gboolean ret = FALSE;
942
943   if (g_ascii_strcasecmp (s, "true") == 0 ||
944       g_ascii_strcasecmp (s, "yes") == 0 ||
945       g_ascii_strcasecmp (s, "t") == 0 || strcmp (s, "1") == 0) {
946     g_value_set_boolean (dest, TRUE);
947     ret = TRUE;
948   } else if (g_ascii_strcasecmp (s, "false") == 0 ||
949       g_ascii_strcasecmp (s, "no") == 0 ||
950       g_ascii_strcasecmp (s, "f") == 0 || strcmp (s, "0") == 0) {
951     g_value_set_boolean (dest, FALSE);
952     ret = TRUE;
953   }
954
955   return ret;
956 }
957
958 /*******
959  * int *
960  *******/
961
962 static int
963 gst_strtoll (const char *s, char **end, int base)
964 {
965   long long i;
966
967   if (s[0] == '-') {
968     i = -(long long) g_ascii_strtoull (s + 1, end, base);
969   } else {
970     i = g_ascii_strtoull (s, end, base);
971   }
972
973   return i;
974 }
975
976 #define CREATE_SERIALIZATION_START(_type,_macro) \
977 static gint \
978 gst_value_compare_ ## _type (const GValue * value1, const GValue * value2) \
979 { \
980   g ## _type val1 = g_value_get_ ## _type (value1); \
981   g ## _type val2 = g_value_get_ ## _type (value2); \
982   if (val1 > val2) \
983     return GST_VALUE_GREATER_THAN; \
984   if (val1 < val2) \
985     return GST_VALUE_LESS_THAN; \
986   return GST_VALUE_EQUAL; \
987 } \
988 \
989 static char * \
990 gst_value_serialize_ ## _type (const GValue * value) \
991 { \
992   GValue val = { 0, }; \
993   g_value_init (&val, G_TYPE_STRING); \
994   if (!g_value_transform (value, &val)) \
995     g_assert_not_reached (); \
996   /* NO_COPY_MADNESS!!! */ \
997   return (char *) g_value_get_string (&val); \
998 }
999
1000 static gboolean
1001 gst_value_deserialize_int_helper (long long *to, const char *s, long long min,
1002     long long max)
1003 {
1004   gboolean ret = FALSE;
1005   char *end;
1006
1007   *to = gst_strtoll (s, &end, 0);
1008   if (*end == 0) {
1009     ret = TRUE;
1010   } else {
1011     if (g_ascii_strcasecmp (s, "little_endian") == 0) {
1012       *to = G_LITTLE_ENDIAN;
1013       ret = TRUE;
1014     } else if (g_ascii_strcasecmp (s, "big_endian") == 0) {
1015       *to = G_BIG_ENDIAN;
1016       ret = TRUE;
1017     } else if (g_ascii_strcasecmp (s, "byte_order") == 0) {
1018       *to = G_BYTE_ORDER;
1019       ret = TRUE;
1020     } else if (g_ascii_strcasecmp (s, "min") == 0) {
1021       *to = min;
1022       ret = TRUE;
1023     } else if (g_ascii_strcasecmp (s, "max") == 0) {
1024       *to = max;
1025       ret = TRUE;
1026     }
1027   }
1028   if (ret) {
1029     if (*to < min || *to > max) {
1030       ret = FALSE;
1031     }
1032   }
1033   return ret;
1034 }
1035
1036 #define CREATE_SERIALIZATION(_type,_macro) \
1037 CREATE_SERIALIZATION_START(_type,_macro) \
1038 \
1039 static gboolean \
1040 gst_value_deserialize_ ## _type (GValue * dest, const char *s) \
1041 { \
1042   long long x; \
1043 \
1044   if (gst_value_deserialize_int_helper (&x, s, G_MIN ## _macro, G_MAX ## _macro)) { \
1045     g_value_set_ ## _type (dest, x); \
1046     return TRUE; \
1047   } else { \
1048     return FALSE; \
1049   } \
1050 }
1051
1052 #define CREATE_USERIALIZATION(_type,_macro) \
1053 CREATE_SERIALIZATION_START(_type,_macro) \
1054 \
1055 static gboolean \
1056 gst_value_deserialize_ ## _type (GValue * dest, const char *s) \
1057 { \
1058   unsigned long long x; \
1059   char *end; \
1060   gboolean ret = FALSE; \
1061 \
1062   x = g_ascii_strtoull (s, &end, 0); \
1063   if (*end == 0) { \
1064     ret = TRUE; \
1065   } else { \
1066     if (g_ascii_strcasecmp (s, "little_endian") == 0) { \
1067       x = G_LITTLE_ENDIAN; \
1068       ret = TRUE; \
1069     } else if (g_ascii_strcasecmp (s, "big_endian") == 0) { \
1070       x = G_BIG_ENDIAN; \
1071       ret = TRUE; \
1072     } else if (g_ascii_strcasecmp (s, "byte_order") == 0) { \
1073       x = G_BYTE_ORDER; \
1074       ret = TRUE; \
1075     } else if (g_ascii_strcasecmp (s, "min") == 0) { \
1076       x = 0; \
1077       ret = TRUE; \
1078     } else if (g_ascii_strcasecmp (s, "max") == 0) { \
1079       x = G_MAX ## _macro; \
1080       ret = TRUE; \
1081     } \
1082   } \
1083   if (ret) { \
1084     if (x > G_MAX ## _macro) {\
1085       ret = FALSE; \
1086     } else { \
1087       g_value_set_ ## _type (dest, x); \
1088     } \
1089   } \
1090   return ret; \
1091 }
1092
1093 #define REGISTER_SERIALIZATION(_gtype, _type) G_STMT_START{ \
1094   static const GstValueTable gst_value = { \
1095     _gtype, \
1096     gst_value_compare_ ## _type, \
1097     gst_value_serialize_ ## _type, \
1098     gst_value_deserialize_ ## _type, \
1099   }; \
1100 \
1101   gst_value_register (&gst_value); \
1102 } G_STMT_END
1103
1104 CREATE_SERIALIZATION (int, INT)
1105     CREATE_SERIALIZATION (int64, INT64)
1106     CREATE_SERIALIZATION (long, LONG)
1107 CREATE_USERIALIZATION (uint, UINT)
1108 CREATE_USERIALIZATION (uint64, UINT64)
1109 CREATE_USERIALIZATION (ulong, ULONG)
1110
1111 /**********
1112  * double *
1113  **********/
1114      static int
1115          gst_value_compare_double (const GValue * value1, const GValue * value2)
1116 {
1117   if (value1->data[0].v_double > value2->data[0].v_double)
1118     return GST_VALUE_GREATER_THAN;
1119   if (value1->data[0].v_double < value2->data[0].v_double)
1120     return GST_VALUE_LESS_THAN;
1121   if (value1->data[0].v_double == value2->data[0].v_double)
1122     return GST_VALUE_EQUAL;
1123   return GST_VALUE_UNORDERED;
1124 }
1125
1126 static char *
1127 gst_value_serialize_double (const GValue * value)
1128 {
1129   char d[G_ASCII_DTOSTR_BUF_SIZE];
1130
1131   g_ascii_dtostr (d, G_ASCII_DTOSTR_BUF_SIZE, value->data[0].v_double);
1132   return g_strdup (d);
1133 }
1134
1135 static gboolean
1136 gst_value_deserialize_double (GValue * dest, const char *s)
1137 {
1138   double x;
1139   gboolean ret = FALSE;
1140   char *end;
1141
1142   x = g_ascii_strtod (s, &end);
1143   if (*end == 0) {
1144     ret = TRUE;
1145   } else {
1146     if (g_ascii_strcasecmp (s, "min") == 0) {
1147       x = -G_MAXDOUBLE;
1148       ret = TRUE;
1149     } else if (g_ascii_strcasecmp (s, "max") == 0) {
1150       x = G_MAXDOUBLE;
1151       ret = TRUE;
1152     }
1153   }
1154   if (ret) {
1155     g_value_set_double (dest, x);
1156   }
1157   return ret;
1158 }
1159
1160 /*********
1161  * float *
1162  *********/
1163
1164 static int
1165 gst_value_compare_float (const GValue * value1, const GValue * value2)
1166 {
1167   if (value1->data[0].v_float > value2->data[0].v_float)
1168     return GST_VALUE_GREATER_THAN;
1169   if (value1->data[0].v_float < value2->data[0].v_float)
1170     return GST_VALUE_LESS_THAN;
1171   if (value1->data[0].v_float == value2->data[0].v_float)
1172     return GST_VALUE_EQUAL;
1173   return GST_VALUE_UNORDERED;
1174 }
1175
1176 static char *
1177 gst_value_serialize_float (const GValue * value)
1178 {
1179   char d[G_ASCII_DTOSTR_BUF_SIZE];
1180
1181   g_ascii_dtostr (d, G_ASCII_DTOSTR_BUF_SIZE, value->data[0].v_float);
1182   return g_strdup (d);
1183 }
1184
1185 static gboolean
1186 gst_value_deserialize_float (GValue * dest, const char *s)
1187 {
1188   double x;
1189   gboolean ret = FALSE;
1190   char *end;
1191
1192   x = g_ascii_strtod (s, &end);
1193   if (*end == 0) {
1194     ret = TRUE;
1195   } else {
1196     if (g_ascii_strcasecmp (s, "min") == 0) {
1197       x = -G_MAXFLOAT;
1198       ret = TRUE;
1199     } else if (g_ascii_strcasecmp (s, "max") == 0) {
1200       x = G_MAXFLOAT;
1201       ret = TRUE;
1202     }
1203   }
1204   if (x > G_MAXFLOAT || x < -G_MAXFLOAT)
1205     ret = FALSE;
1206   if (ret) {
1207     g_value_set_float (dest, x);
1208   }
1209   return ret;
1210 }
1211
1212 /**********
1213  * string *
1214  **********/
1215
1216 static int
1217 gst_value_compare_string (const GValue * value1, const GValue * value2)
1218 {
1219   int x = strcmp (value1->data[0].v_pointer, value2->data[0].v_pointer);
1220
1221   if (x < 0)
1222     return GST_VALUE_LESS_THAN;
1223   if (x > 0)
1224     return GST_VALUE_GREATER_THAN;
1225   return GST_VALUE_EQUAL;
1226 }
1227
1228 #define GST_ASCII_IS_STRING(c) (g_ascii_isalnum((c)) || ((c) == '_') || \
1229     ((c) == '-') || ((c) == '+') || ((c) == '/') || ((c) == ':') || \
1230     ((c) == '.'))
1231
1232 static gchar *
1233 gst_string_wrap (const char *s)
1234 {
1235   const gchar *t;
1236   int len;
1237   gchar *d, *e;
1238   gboolean wrap = FALSE;
1239
1240   len = 0;
1241   t = s;
1242   while (*t) {
1243     if (GST_ASCII_IS_STRING (*t)) {
1244       len++;
1245     } else if (*t < 0x20 || *t >= 0x7f) {
1246       wrap = TRUE;
1247       len += 4;
1248     } else {
1249       wrap = TRUE;
1250       len += 2;
1251     }
1252     t++;
1253   }
1254
1255   if (!wrap)
1256     return strdup (s);
1257
1258   e = d = g_malloc (len + 3);
1259
1260   *e++ = '\"';
1261   t = s;
1262   while (*t) {
1263     if (GST_ASCII_IS_STRING (*t)) {
1264       *e++ = *t++;
1265     } else if (*t < 0x20 || *t >= 0x7f) {
1266       *e++ = '\\';
1267       *e++ = '0' + ((*t) >> 6);
1268       *e++ = '0' + (((*t) >> 3) & 0x7);
1269       *e++ = '0' + ((*t++) & 0x7);
1270     } else {
1271       *e++ = '\\';
1272       *e++ = *t++;
1273     }
1274   }
1275   *e++ = '\"';
1276   *e = 0;
1277
1278   return d;
1279 }
1280
1281 static char *
1282 gst_value_serialize_string (const GValue * value)
1283 {
1284   return gst_string_wrap (value->data[0].v_pointer);
1285 }
1286
1287 static gboolean
1288 gst_value_deserialize_string (GValue * dest, const char *s)
1289 {
1290   g_value_set_string (dest, s);
1291
1292   return TRUE;
1293 }
1294
1295 /********
1296  * enum *
1297  ********/
1298
1299 static int
1300 gst_value_compare_enum (const GValue * value1, const GValue * value2)
1301 {
1302   GEnumValue *en1, *en2;
1303   GEnumClass *klass1 = (GEnumClass *) g_type_class_ref (G_VALUE_TYPE (value1));
1304   GEnumClass *klass2 = (GEnumClass *) g_type_class_ref (G_VALUE_TYPE (value2));
1305
1306   g_return_val_if_fail (klass1, GST_VALUE_UNORDERED);
1307   g_return_val_if_fail (klass2, GST_VALUE_UNORDERED);
1308   en1 = g_enum_get_value (klass1, g_value_get_enum (value1));
1309   en2 = g_enum_get_value (klass2, g_value_get_enum (value2));
1310   g_type_class_unref (klass1);
1311   g_type_class_unref (klass2);
1312   g_return_val_if_fail (en1, GST_VALUE_UNORDERED);
1313   g_return_val_if_fail (en2, GST_VALUE_UNORDERED);
1314   if (en1->value < en2->value)
1315     return GST_VALUE_LESS_THAN;
1316   if (en1->value > en2->value)
1317     return GST_VALUE_GREATER_THAN;
1318
1319   return GST_VALUE_EQUAL;
1320 }
1321
1322 static char *
1323 gst_value_serialize_enum (const GValue * value)
1324 {
1325   GEnumValue *en;
1326   GEnumClass *klass = (GEnumClass *) g_type_class_ref (G_VALUE_TYPE (value));
1327
1328   g_return_val_if_fail (klass, NULL);
1329   en = g_enum_get_value (klass, g_value_get_enum (value));
1330   g_type_class_unref (klass);
1331   g_return_val_if_fail (en, NULL);
1332   return g_strdup (en->value_name);
1333 }
1334
1335 static gboolean
1336 gst_value_deserialize_enum (GValue * dest, const char *s)
1337 {
1338   GEnumValue *en;
1339   gchar *endptr = NULL;
1340   GEnumClass *klass = (GEnumClass *) g_type_class_ref (G_VALUE_TYPE (dest));
1341
1342   g_return_val_if_fail (klass, FALSE);
1343   if (!(en = g_enum_get_value_by_name (klass, s))) {
1344     if (!(en = g_enum_get_value_by_nick (klass, s))) {
1345       gint i = strtol (s, &endptr, 0);
1346
1347       if (endptr && *endptr == '\0') {
1348         en = g_enum_get_value (klass, i);
1349       }
1350     }
1351   }
1352   g_type_class_unref (klass);
1353   g_return_val_if_fail (en, FALSE);
1354   g_value_set_enum (dest, en->value);
1355   return TRUE;
1356 }
1357
1358 /*********
1359  * union *
1360  *********/
1361
1362 static gboolean
1363 gst_value_union_int_int_range (GValue * dest, const GValue * src1,
1364     const GValue * src2)
1365 {
1366   g_return_val_if_fail (G_VALUE_TYPE (src1) == G_TYPE_INT, FALSE);
1367   g_return_val_if_fail (G_VALUE_TYPE (src2) == GST_TYPE_INT_RANGE, FALSE);
1368
1369   if (src2->data[0].v_int <= src1->data[0].v_int &&
1370       src2->data[1].v_int >= src1->data[0].v_int) {
1371     gst_value_init_and_copy (dest, src2);
1372     return TRUE;
1373   }
1374
1375   return FALSE;
1376 }
1377
1378 static gboolean
1379 gst_value_union_int_range_int_range (GValue * dest, const GValue * src1,
1380     const GValue * src2)
1381 {
1382   int min;
1383   int max;
1384
1385   g_return_val_if_fail (G_VALUE_TYPE (src1) == GST_TYPE_INT_RANGE, FALSE);
1386   g_return_val_if_fail (G_VALUE_TYPE (src2) == GST_TYPE_INT_RANGE, FALSE);
1387
1388   min = MAX (src1->data[0].v_int, src2->data[0].v_int);
1389   max = MIN (src1->data[1].v_int, src2->data[1].v_int);
1390
1391   if (min <= max) {
1392     g_value_init (dest, GST_TYPE_INT_RANGE);
1393     gst_value_set_int_range (dest,
1394         MIN (src1->data[0].v_int, src2->data[0].v_int),
1395         MAX (src1->data[1].v_int, src2->data[1].v_int));
1396     return TRUE;
1397   }
1398
1399   return FALSE;
1400 }
1401
1402 /****************
1403  * intersection *
1404  ****************/
1405
1406 static gboolean
1407 gst_value_intersect_int_int_range (GValue * dest, const GValue * src1,
1408     const GValue * src2)
1409 {
1410   g_return_val_if_fail (G_VALUE_TYPE (src1) == G_TYPE_INT, FALSE);
1411   g_return_val_if_fail (G_VALUE_TYPE (src2) == GST_TYPE_INT_RANGE, FALSE);
1412
1413   if (src2->data[0].v_int <= src1->data[0].v_int &&
1414       src2->data[1].v_int >= src1->data[0].v_int) {
1415     gst_value_init_and_copy (dest, src1);
1416     return TRUE;
1417   }
1418
1419   return FALSE;
1420 }
1421
1422 static gboolean
1423 gst_value_intersect_int_range_int_range (GValue * dest, const GValue * src1,
1424     const GValue * src2)
1425 {
1426   int min;
1427   int max;
1428
1429   g_return_val_if_fail (G_VALUE_TYPE (src1) == GST_TYPE_INT_RANGE, FALSE);
1430   g_return_val_if_fail (G_VALUE_TYPE (src2) == GST_TYPE_INT_RANGE, FALSE);
1431
1432   min = MAX (src1->data[0].v_int, src2->data[0].v_int);
1433   max = MIN (src1->data[1].v_int, src2->data[1].v_int);
1434
1435   if (min < max) {
1436     g_value_init (dest, GST_TYPE_INT_RANGE);
1437     gst_value_set_int_range (dest, min, max);
1438     return TRUE;
1439   }
1440   if (min == max) {
1441     g_value_init (dest, G_TYPE_INT);
1442     g_value_set_int (dest, min);
1443     return TRUE;
1444   }
1445
1446   return FALSE;
1447 }
1448
1449 static gboolean
1450 gst_value_intersect_double_double_range (GValue * dest, const GValue * src1,
1451     const GValue * src2)
1452 {
1453   g_return_val_if_fail (G_VALUE_TYPE (src1) == G_TYPE_DOUBLE, FALSE);
1454   g_return_val_if_fail (G_VALUE_TYPE (src2) == GST_TYPE_DOUBLE_RANGE, FALSE);
1455
1456   if (src2->data[0].v_double <= src1->data[0].v_double &&
1457       src2->data[1].v_double >= src1->data[0].v_double) {
1458     gst_value_init_and_copy (dest, src1);
1459     return TRUE;
1460   }
1461
1462   return FALSE;
1463 }
1464
1465 static gboolean
1466 gst_value_intersect_double_range_double_range (GValue * dest,
1467     const GValue * src1, const GValue * src2)
1468 {
1469   double min;
1470   double max;
1471
1472   g_return_val_if_fail (G_VALUE_TYPE (src1) == GST_TYPE_DOUBLE_RANGE, FALSE);
1473   g_return_val_if_fail (G_VALUE_TYPE (src2) == GST_TYPE_DOUBLE_RANGE, FALSE);
1474
1475   min = MAX (src1->data[0].v_double, src2->data[0].v_double);
1476   max = MIN (src1->data[1].v_double, src2->data[1].v_double);
1477
1478   if (min < max) {
1479     g_value_init (dest, GST_TYPE_DOUBLE_RANGE);
1480     gst_value_set_double_range (dest, min, max);
1481     return TRUE;
1482   }
1483   if (min == max) {
1484     g_value_init (dest, G_TYPE_DOUBLE);
1485     g_value_set_int (dest, min);
1486     return TRUE;
1487   }
1488
1489   return FALSE;
1490 }
1491
1492 static gboolean
1493 gst_value_intersect_list (GValue * dest, const GValue * value1,
1494     const GValue * value2)
1495 {
1496   guint i, size;
1497   GValue intersection = { 0, };
1498   gboolean ret = FALSE;
1499
1500   g_return_val_if_fail (GST_VALUE_HOLDS_LIST (value1), FALSE);
1501
1502   size = gst_value_list_get_size (value1);
1503   for (i = 0; i < size; i++) {
1504     const GValue *cur = gst_value_list_get_value (value1, i);
1505
1506     if (gst_value_intersect (&intersection, cur, value2)) {
1507       /* append value */
1508       if (!ret) {
1509         gst_value_init_and_copy (dest, &intersection);
1510         ret = TRUE;
1511       } else if (GST_VALUE_HOLDS_LIST (dest)) {
1512         gst_value_list_append_value (dest, &intersection);
1513       } else {
1514         GValue temp = { 0, };
1515
1516         gst_value_init_and_copy (&temp, dest);
1517         g_value_unset (dest);
1518         gst_value_list_concat (dest, &temp, &intersection);
1519       }
1520       g_value_unset (&intersection);
1521     }
1522   }
1523
1524   return ret;
1525 }
1526
1527 /***************
1528  * subtraction *
1529  ***************/
1530
1531 static gboolean
1532 gst_value_subtract_int_int_range (GValue * dest, const GValue * minuend,
1533     const GValue * subtrahend)
1534 {
1535   int min = gst_value_get_int_range_min (subtrahend);
1536   int max = gst_value_get_int_range_max (subtrahend);
1537   int val = g_value_get_int (minuend);
1538
1539   if (val < min || val > max) {
1540     gst_value_init_and_copy (dest, minuend);
1541     return TRUE;
1542   }
1543   return FALSE;
1544 }
1545
1546 static gboolean
1547 gst_value_create_new_range (GValue * dest, int min1, int max1, int min2,
1548     int max2)
1549 {
1550   GValue v1 = { 0, };
1551   GValue v2 = { 0, };
1552   GValue *pv1, *pv2;            /* yeah, hungarian! */
1553
1554   if (min1 <= max1 && min2 <= max2) {
1555     pv1 = &v1;
1556     pv2 = &v2;
1557   } else if (min1 <= max1) {
1558     pv1 = dest;
1559     pv2 = NULL;
1560   } else if (min2 <= max2) {
1561     pv1 = NULL;
1562     pv2 = dest;
1563   } else {
1564     return FALSE;
1565   }
1566
1567   if (min1 < max1) {
1568     g_value_init (pv1, GST_TYPE_INT_RANGE);
1569     gst_value_set_int_range (pv1, min1, max1);
1570   } else if (min1 == max1) {
1571     g_value_init (pv1, G_TYPE_INT);
1572     g_value_set_int (pv1, min1);
1573   }
1574   if (min2 < max2) {
1575     g_value_init (pv2, GST_TYPE_INT_RANGE);
1576     gst_value_set_int_range (pv2, min2, max2);
1577   } else if (min2 == max2) {
1578     g_value_init (pv2, G_TYPE_INT);
1579     g_value_set_int (pv2, min2);
1580   }
1581
1582   if (min1 <= max1 && min2 <= max2) {
1583     gst_value_list_concat (dest, pv1, pv2);
1584     g_value_unset (pv1);
1585     g_value_unset (pv2);
1586   }
1587   return TRUE;
1588 }
1589
1590 static gboolean
1591 gst_value_subtract_int_range_int (GValue * dest, const GValue * minuend,
1592     const GValue * subtrahend)
1593 {
1594   int min = gst_value_get_int_range_min (minuend);
1595   int max = gst_value_get_int_range_max (minuend);
1596   int val = g_value_get_int (subtrahend);
1597
1598   g_return_val_if_fail (min < max, FALSE);
1599
1600   if (val < min || val > max) {
1601     gst_value_init_and_copy (dest, minuend);
1602     return TRUE;
1603   } else {
1604     if (val == G_MAXINT) {
1605       max--;
1606       val--;
1607     }
1608     if (val == G_MININT) {
1609       min++;
1610       val++;
1611     }
1612     gst_value_create_new_range (dest, min, val - 1, val + 1, max);
1613   }
1614   return TRUE;
1615 }
1616
1617 static gboolean
1618 gst_value_subtract_int_range_int_range (GValue * dest, const GValue * minuend,
1619     const GValue * subtrahend)
1620 {
1621   int min1 = gst_value_get_int_range_min (minuend);
1622   int max1 = gst_value_get_int_range_max (minuend);
1623   int min2 = gst_value_get_int_range_min (subtrahend);
1624   int max2 = gst_value_get_int_range_max (subtrahend);
1625
1626   if (max2 == G_MAXINT && min2 == G_MININT) {
1627     return FALSE;
1628   } else if (max2 == G_MAXINT) {
1629     return gst_value_create_new_range (dest, min1, MIN (min2 - 1, max1), 1, 0);
1630   } else if (min2 == G_MININT) {
1631     return gst_value_create_new_range (dest, MAX (max2 + 1, min1), max1, 1, 0);
1632   } else {
1633     return gst_value_create_new_range (dest, min1, MIN (min2 - 1, max1),
1634         MAX (max2 + 1, min1), max1);
1635   }
1636 }
1637
1638 static gboolean
1639 gst_value_subtract_double_double_range (GValue * dest, const GValue * minuend,
1640     const GValue * subtrahend)
1641 {
1642   double min = gst_value_get_double_range_min (subtrahend);
1643   double max = gst_value_get_double_range_max (subtrahend);
1644   double val = g_value_get_double (minuend);
1645
1646   if (val < min || val > max) {
1647     gst_value_init_and_copy (dest, minuend);
1648     return TRUE;
1649   }
1650   return FALSE;
1651 }
1652
1653 static gboolean
1654 gst_value_subtract_double_range_double (GValue * dest, const GValue * minuend,
1655     const GValue * subtrahend)
1656 {
1657   /* FIXME! */
1658   gst_value_init_and_copy (dest, minuend);
1659   return TRUE;
1660 }
1661
1662 static gboolean
1663 gst_value_subtract_double_range_double_range (GValue * dest,
1664     const GValue * minuend, const GValue * subtrahend)
1665 {
1666   /* FIXME! */
1667   /* done like with ints */
1668   double min1 = gst_value_get_double_range_min (minuend);
1669   double max2 = gst_value_get_double_range_max (minuend);
1670   double max1 = MIN (gst_value_get_double_range_min (subtrahend), max2);
1671   double min2 = MAX (gst_value_get_double_range_max (subtrahend), min1);
1672   GValue v1 = { 0, };
1673   GValue v2 = { 0, };
1674   GValue *pv1, *pv2;            /* yeah, hungarian! */
1675
1676   if (min1 < max1 && min2 < max2) {
1677     pv1 = &v1;
1678     pv2 = &v2;
1679   } else if (min1 < max1) {
1680     pv1 = dest;
1681     pv2 = NULL;
1682   } else if (min2 < max2) {
1683     pv1 = NULL;
1684     pv2 = dest;
1685   } else {
1686     return FALSE;
1687   }
1688
1689   if (min1 < max1) {
1690     g_value_init (pv1, GST_TYPE_DOUBLE_RANGE);
1691     gst_value_set_double_range (pv1, min1, max1);
1692   }
1693   if (min2 < max2) {
1694     g_value_init (pv2, GST_TYPE_DOUBLE_RANGE);
1695     gst_value_set_double_range (pv2, min2, max2);
1696   }
1697
1698   if (min1 < max1 && min2 < max2) {
1699     gst_value_list_concat (dest, pv1, pv2);
1700     g_value_unset (pv1);
1701     g_value_unset (pv2);
1702   }
1703   return TRUE;
1704 }
1705
1706 static gboolean
1707 gst_value_subtract_from_list (GValue * dest, const GValue * minuend,
1708     const GValue * subtrahend)
1709 {
1710   guint i, size;
1711   GValue subtraction = { 0, };
1712   gboolean ret = FALSE;
1713
1714   g_return_val_if_fail (GST_VALUE_HOLDS_LIST (minuend), FALSE);
1715
1716   size = gst_value_list_get_size (minuend);
1717   for (i = 0; i < size; i++) {
1718     const GValue *cur = gst_value_list_get_value (minuend, i);
1719
1720     if (gst_value_subtract (&subtraction, cur, subtrahend)) {
1721       if (!ret) {
1722         gst_value_init_and_copy (dest, &subtraction);
1723         ret = TRUE;
1724       } else if (GST_VALUE_HOLDS_LIST (dest)
1725           && GST_VALUE_HOLDS_LIST (&subtraction)) {
1726         /* unroll */
1727         GValue unroll = { 0, };
1728
1729         gst_value_init_and_copy (&unroll, dest);
1730         g_value_unset (dest);
1731         gst_value_list_concat (dest, &unroll, &subtraction);
1732       } else if (GST_VALUE_HOLDS_LIST (dest)) {
1733         gst_value_list_append_value (dest, &subtraction);
1734       } else {
1735         GValue temp = { 0, };
1736
1737         gst_value_init_and_copy (&temp, dest);
1738         g_value_unset (dest);
1739         gst_value_list_concat (dest, &temp, &subtraction);
1740         g_value_unset (&temp);
1741       }
1742       g_value_unset (&subtraction);
1743     }
1744   }
1745   return ret;
1746 }
1747
1748 static gboolean
1749 gst_value_subtract_list (GValue * dest, const GValue * minuend,
1750     const GValue * subtrahend)
1751 {
1752   guint i, size;
1753   GValue data[2] = { {0,}, {0,} };
1754   GValue *subtraction = &data[0], *result = &data[1];
1755
1756   g_return_val_if_fail (GST_VALUE_HOLDS_LIST (subtrahend), FALSE);
1757
1758   gst_value_init_and_copy (result, minuend);
1759   size = gst_value_list_get_size (subtrahend);
1760   for (i = 0; i < size; i++) {
1761     const GValue *cur = gst_value_list_get_value (subtrahend, i);
1762
1763     if (gst_value_subtract (subtraction, result, cur)) {
1764       GValue *temp = result;
1765
1766       result = subtraction;
1767       subtraction = temp;
1768       g_value_unset (subtraction);
1769     } else {
1770       g_value_unset (result);
1771       return FALSE;
1772     }
1773   }
1774   gst_value_init_and_copy (dest, result);
1775   g_value_unset (result);
1776   return TRUE;
1777 }
1778
1779
1780 /**************
1781  * comparison *
1782  **************/
1783
1784 /**
1785  * gst_value_can_compare:
1786  * @value1: a value to compare
1787  * @value2: another value to compare
1788  *
1789  * Determines if @value1 and @value2 can be compared.
1790  *
1791  * Returns: TRUE if the values can be compared
1792  */
1793 gboolean
1794 gst_value_can_compare (const GValue * value1, const GValue * value2)
1795 {
1796   GstValueTable *table;
1797   int i;
1798
1799   if (G_VALUE_TYPE (value1) != G_VALUE_TYPE (value2))
1800     return FALSE;
1801   for (i = 0; i < gst_value_table->len; i++) {
1802     table = &g_array_index (gst_value_table, GstValueTable, i);
1803     if (g_type_is_a (G_VALUE_TYPE (value1), table->type) && table->compare)
1804       return TRUE;
1805   }
1806
1807   return FALSE;
1808 }
1809
1810 /**
1811  * gst_value_compare:
1812  * @value1: a value to compare
1813  * @value2: another value to compare
1814  *
1815  * Compares @value1 and @value2.  If @value1 and @value2 cannot be
1816  * compared, the function returns GST_VALUE_UNORDERED.  Otherwise,
1817  * if @value1 is greater than @value2, GST_VALUE_GREATER is returned.
1818  * If @value1 is less than @value2, GST_VALUE_LESSER is returned.
1819  * If the values are equal, GST_VALUE_EQUAL is returned.
1820  *
1821  * Returns: A GstValueCompareType value
1822  */
1823 int
1824 gst_value_compare (const GValue * value1, const GValue * value2)
1825 {
1826   GstValueTable *table, *best = NULL;
1827   int i;
1828
1829   if (G_VALUE_TYPE (value1) != G_VALUE_TYPE (value2))
1830     return GST_VALUE_UNORDERED;
1831
1832   for (i = 0; i < gst_value_table->len; i++) {
1833     table = &g_array_index (gst_value_table, GstValueTable, i);
1834     if (table->type == G_VALUE_TYPE (value1) && table->compare != NULL) {
1835       best = table;
1836       break;
1837     }
1838     if (g_type_is_a (G_VALUE_TYPE (value1), table->type)) {
1839       if (!best || g_type_is_a (table->type, best->type))
1840         best = table;
1841     }
1842   }
1843   if (best) {
1844     return best->compare (value1, value2);
1845   }
1846
1847   g_critical ("unable to compare values of type %s\n",
1848       g_type_name (G_VALUE_TYPE (value1)));
1849   return GST_VALUE_UNORDERED;
1850 }
1851
1852 /* union */
1853
1854 /**
1855  * gst_value_can_union:
1856  * @value1: a value to union
1857  * @value2: another value to union
1858  *
1859  * Determines if @value1 and @value2 can be non-trivially unioned.
1860  * Any two values can be trivially unioned by adding both of them
1861  * to a GstValueList.  However, certain types have the possibility
1862  * to be unioned in a simpler way.  For example, an integer range
1863  * and an integer can be unioned if the integer is a subset of the
1864  * integer range.  If there is the possibility that two values can
1865  * be unioned, this function returns TRUE.
1866  *
1867  * Returns: TRUE if there is a function allowing the two values to
1868  * be unioned.
1869  */
1870 gboolean
1871 gst_value_can_union (const GValue * value1, const GValue * value2)
1872 {
1873   GstValueUnionInfo *union_info;
1874   int i;
1875
1876   for (i = 0; i < gst_value_union_funcs->len; i++) {
1877     union_info = &g_array_index (gst_value_union_funcs, GstValueUnionInfo, i);
1878     if (union_info->type1 == G_VALUE_TYPE (value1) &&
1879         union_info->type2 == G_VALUE_TYPE (value2))
1880       return TRUE;
1881     if (union_info->type1 == G_VALUE_TYPE (value2) &&
1882         union_info->type2 == G_VALUE_TYPE (value1))
1883       return TRUE;
1884   }
1885
1886   return FALSE;
1887 }
1888
1889 /**
1890  * gst_value_union:
1891  * @dest: the destination value
1892  * @value1: a value to union
1893  * @value2: another value to union
1894  *
1895  * Creates a GValue cooresponding to the union of @value1 and @value2.
1896  *
1897  * Returns: TRUE if the values could be unioned
1898  */
1899 gboolean
1900 gst_value_union (GValue * dest, const GValue * value1, const GValue * value2)
1901 {
1902   GstValueUnionInfo *union_info;
1903   int i;
1904
1905   for (i = 0; i < gst_value_union_funcs->len; i++) {
1906     union_info = &g_array_index (gst_value_union_funcs, GstValueUnionInfo, i);
1907     if (union_info->type1 == G_VALUE_TYPE (value1) &&
1908         union_info->type2 == G_VALUE_TYPE (value2)) {
1909       if (union_info->func (dest, value1, value2)) {
1910         return TRUE;
1911       }
1912     }
1913     if (union_info->type1 == G_VALUE_TYPE (value2) &&
1914         union_info->type2 == G_VALUE_TYPE (value1)) {
1915       if (union_info->func (dest, value2, value1)) {
1916         return TRUE;
1917       }
1918     }
1919   }
1920
1921   gst_value_list_concat (dest, value1, value2);
1922   return TRUE;
1923 }
1924
1925 /**
1926  * gst_value_register_union_func:
1927  * @type1: a type to union
1928  * @type2: another type to union
1929  * @func: a function that implments creating a union between the two types
1930  *
1931  * Registers a union function that can create a union between GValues
1932  * of the type @type1 and @type2.
1933  *
1934  */
1935 void
1936 gst_value_register_union_func (GType type1, GType type2, GstValueUnionFunc func)
1937 {
1938   GstValueUnionInfo union_info;
1939
1940   union_info.type1 = type1;
1941   union_info.type2 = type2;
1942   union_info.func = func;
1943
1944   g_array_append_val (gst_value_union_funcs, union_info);
1945 }
1946
1947 /* intersection */
1948
1949 /*
1950  * gst_value_can_intersect:
1951  * @value1:
1952  * @value2:
1953  *
1954  * Returns:
1955  */
1956 gboolean
1957 gst_value_can_intersect (const GValue * value1, const GValue * value2)
1958 {
1959   GstValueIntersectInfo *intersect_info;
1960   int i;
1961
1962   /* special cases */
1963   if (GST_VALUE_HOLDS_LIST (value1) || GST_VALUE_HOLDS_LIST (value2))
1964     return TRUE;
1965
1966   for (i = 0; i < gst_value_intersect_funcs->len; i++) {
1967     intersect_info = &g_array_index (gst_value_intersect_funcs,
1968         GstValueIntersectInfo, i);
1969     if (intersect_info->type1 == G_VALUE_TYPE (value1) &&
1970         intersect_info->type2 == G_VALUE_TYPE (value2))
1971       if (intersect_info->type2 == G_VALUE_TYPE (value1) &&
1972           intersect_info->type1 == G_VALUE_TYPE (value2))
1973         return TRUE;
1974   }
1975
1976   return gst_value_can_compare (value1, value2);
1977 }
1978
1979 /**
1980  * gst_value_intersect:
1981  * @dest: the destination value for intersection
1982  * @value1: a value to intersect
1983  * @value2: another value to intersect
1984  *
1985  * Calculates the intersection of the two values.
1986  *
1987  * Returns: TRUE if the intersection is non-empty
1988  */
1989 gboolean
1990 gst_value_intersect (GValue * dest, const GValue * value1,
1991     const GValue * value2)
1992 {
1993   GstValueIntersectInfo *intersect_info;
1994   int i;
1995   int ret = FALSE;
1996
1997   /* special cases first */
1998   if (GST_VALUE_HOLDS_LIST (value1))
1999     return gst_value_intersect_list (dest, value1, value2);
2000   if (GST_VALUE_HOLDS_LIST (value2))
2001     return gst_value_intersect_list (dest, value2, value1);
2002
2003   for (i = 0; i < gst_value_intersect_funcs->len; i++) {
2004     intersect_info = &g_array_index (gst_value_intersect_funcs,
2005         GstValueIntersectInfo, i);
2006     if (intersect_info->type1 == G_VALUE_TYPE (value1) &&
2007         intersect_info->type2 == G_VALUE_TYPE (value2)) {
2008       ret = intersect_info->func (dest, value1, value2);
2009       return ret;
2010     }
2011     if (intersect_info->type1 == G_VALUE_TYPE (value2) &&
2012         intersect_info->type2 == G_VALUE_TYPE (value1)) {
2013       ret = intersect_info->func (dest, value2, value1);
2014       return ret;
2015     }
2016   }
2017
2018   if (gst_value_compare (value1, value2) == GST_VALUE_EQUAL) {
2019     gst_value_init_and_copy (dest, value1);
2020     ret = TRUE;
2021   }
2022
2023   return ret;
2024 }
2025
2026 /**
2027  * gst_value_register_intersection_func:
2028  * @type1:
2029  * @type2:
2030  * @func:
2031  *
2032  */
2033 void
2034 gst_value_register_intersect_func (GType type1, GType type2,
2035     GstValueIntersectFunc func)
2036 {
2037   GstValueIntersectInfo intersect_info;
2038
2039   intersect_info.type1 = type1;
2040   intersect_info.type2 = type2;
2041   intersect_info.func = func;
2042
2043   g_array_append_val (gst_value_intersect_funcs, intersect_info);
2044 }
2045
2046
2047 /* subtraction */
2048
2049 /**
2050  * gst_value_subtract:
2051  * @dest: the destination value for the result if the subtraction is not empty
2052  * @minuend: the value to subtract from
2053  * @subtrahend: the value to subtract
2054  *
2055  * Subtracts @subtrahend from @minuend and stores the result in @dest.
2056  * Note that this means subtraction as in sets, not as in mathematics.
2057  *
2058  * Returns: TRUE if the subtraction is not empty
2059  */
2060 gboolean
2061 gst_value_subtract (GValue * dest, const GValue * minuend,
2062     const GValue * subtrahend)
2063 {
2064   GstValueSubtractInfo *info;
2065   int i;
2066
2067   /* special cases first */
2068   if (GST_VALUE_HOLDS_LIST (minuend))
2069     return gst_value_subtract_from_list (dest, minuend, subtrahend);
2070   if (GST_VALUE_HOLDS_LIST (subtrahend))
2071     return gst_value_subtract_list (dest, minuend, subtrahend);
2072
2073   for (i = 0; i < gst_value_subtract_funcs->len; i++) {
2074     info = &g_array_index (gst_value_subtract_funcs, GstValueSubtractInfo, i);
2075     if (info->minuend == G_VALUE_TYPE (minuend) &&
2076         info->subtrahend == G_VALUE_TYPE (subtrahend)) {
2077       return info->func (dest, minuend, subtrahend);
2078     }
2079   }
2080
2081   if (gst_value_compare (minuend, subtrahend) != GST_VALUE_EQUAL) {
2082     gst_value_init_and_copy (dest, minuend);
2083     return TRUE;
2084   }
2085
2086   return FALSE;
2087 }
2088
2089 #if 0
2090 gboolean
2091 gst_value_subtract (GValue * dest, const GValue * minuend,
2092     const GValue * subtrahend)
2093 {
2094   gboolean ret = gst_value_subtract2 (dest, minuend, subtrahend);
2095
2096   g_printerr ("\"%s\"  -  \"%s\"  =  \"%s\"\n", gst_value_serialize (minuend),
2097       gst_value_serialize (subtrahend),
2098       ret ? gst_value_serialize (dest) : "---");
2099   return ret;
2100 }
2101 #endif
2102
2103 /**
2104  * gst_value_can_subtract:
2105  * @minuend: the value to subtract from
2106  * @subtrahend: the value to subtract
2107  *
2108  * Checks if it's possible to subtract @subtrahend from @minuend.
2109  *
2110  * Returns: TRUE if a subtraction is possible
2111  */
2112 gboolean
2113 gst_value_can_subtract (const GValue * minuend, const GValue * subtrahend)
2114 {
2115   GstValueSubtractInfo *info;
2116   int i;
2117
2118   /* special cases */
2119   if (GST_VALUE_HOLDS_LIST (minuend) || GST_VALUE_HOLDS_LIST (subtrahend))
2120     return TRUE;
2121
2122   for (i = 0; i < gst_value_subtract_funcs->len; i++) {
2123     info = &g_array_index (gst_value_subtract_funcs, GstValueSubtractInfo, i);
2124     if (info->minuend == G_VALUE_TYPE (minuend) &&
2125         info->subtrahend == G_VALUE_TYPE (subtrahend))
2126       return TRUE;
2127   }
2128
2129   return gst_value_can_compare (minuend, subtrahend);
2130 }
2131
2132 /**
2133  * gst_value_register_subtract_func:
2134  * @minuend_type: type of the minuend
2135  * @subtrahend_type: type of the subtrahend
2136  * @func: function to use
2137  *
2138  * Registers @func as a function capable of subtracting the values of 
2139  * @subtrahend_type from values of @minuend_type.
2140  */
2141 void
2142 gst_value_register_subtract_func (GType minuend_type, GType subtrahend_type,
2143     GstValueSubtractFunc func)
2144 {
2145   GstValueSubtractInfo info;
2146
2147   /* one type must be unfixed, other subtractions can be done as comparisons */
2148   g_return_if_fail (!gst_type_is_fixed (minuend_type)
2149       || !gst_type_is_fixed (subtrahend_type));
2150
2151   info.minuend = minuend_type;
2152   info.subtrahend = subtrahend_type;
2153   info.func = func;
2154
2155   g_array_append_val (gst_value_subtract_funcs, info);
2156 }
2157
2158 /*
2159  * gst_value_register:
2160  * @table:
2161  *
2162  */
2163 void
2164 gst_value_register (const GstValueTable * table)
2165 {
2166   g_array_append_val (gst_value_table, *table);
2167 }
2168
2169 /*
2170  * gst_value_init_and_copy:
2171  * @dest:
2172  * @src:
2173  *
2174  */
2175 void
2176 gst_value_init_and_copy (GValue * dest, const GValue * src)
2177 {
2178   g_value_init (dest, G_VALUE_TYPE (src));
2179   g_value_copy (src, dest);
2180 }
2181
2182 /*
2183  * gst_value_serialize:
2184  * @value: a #GValue to serialize
2185  *
2186  * tries to transform the given @value into a string representation that allows
2187  * getting back this string later on using gst_value_deserialize().
2188  *
2189  * Returns: the serialization for @value or NULL if none exists
2190  */
2191 gchar *
2192 gst_value_serialize (const GValue * value)
2193 {
2194   int i;
2195   GValue s_val = { 0 };
2196   GstValueTable *table, *best = NULL;
2197   char *s;
2198
2199   g_return_val_if_fail (G_IS_VALUE (value), NULL);
2200
2201   for (i = 0; i < gst_value_table->len; i++) {
2202     table = &g_array_index (gst_value_table, GstValueTable, i);
2203     if (table->serialize == NULL)
2204       continue;
2205     if (table->type == G_VALUE_TYPE (value)) {
2206       best = table;
2207       break;
2208     }
2209     if (g_type_is_a (G_VALUE_TYPE (value), table->type)) {
2210       if (!best || g_type_is_a (table->type, best->type))
2211         best = table;
2212     }
2213   }
2214   if (best)
2215     return best->serialize (value);
2216
2217   g_value_init (&s_val, G_TYPE_STRING);
2218   if (g_value_transform (value, &s_val)) {
2219     s = gst_string_wrap (g_value_get_string (&s_val));
2220   } else {
2221     s = NULL;
2222   }
2223   g_value_unset (&s_val);
2224
2225   return s;
2226 }
2227
2228 /*
2229  * gst_value_deserialize:
2230  * @dest: #GValue to fill with contents of deserialization
2231  * @src: string to deserialize
2232  *
2233  * Tries to deserialize a string into the type specified by the given GValue.
2234  * If the operation succeeds, TRUE is returned, FALSE otherwise.
2235  * 
2236  * Returns: TRUE on success
2237  */
2238 gboolean
2239 gst_value_deserialize (GValue * dest, const gchar * src)
2240 {
2241   GstValueTable *table, *best = NULL;
2242   int i;
2243
2244   g_return_val_if_fail (src != NULL, FALSE);
2245   g_return_val_if_fail (G_IS_VALUE (dest), FALSE);
2246
2247   for (i = 0; i < gst_value_table->len; i++) {
2248     table = &g_array_index (gst_value_table, GstValueTable, i);
2249     if (table->serialize == NULL)
2250       continue;
2251     if (table->type == G_VALUE_TYPE (dest)) {
2252       best = table;
2253       break;
2254     }
2255     if (g_type_is_a (G_VALUE_TYPE (dest), table->type)) {
2256       if (!best || g_type_is_a (table->type, best->type))
2257         best = table;
2258     }
2259   }
2260   if (best)
2261     return best->deserialize (dest, src);
2262
2263   return FALSE;
2264 }
2265
2266 /*
2267  * gst_type_is_fixed:
2268  * @type:
2269  *
2270  * Returns:
2271  */
2272 gboolean
2273 gst_type_is_fixed (GType type)
2274 {
2275   if (type == GST_TYPE_INT_RANGE || type == GST_TYPE_DOUBLE_RANGE ||
2276       type == GST_TYPE_LIST) {
2277     return FALSE;
2278   }
2279   if (G_TYPE_IS_FUNDAMENTAL (type) &&
2280       type < G_TYPE_MAKE_FUNDAMENTAL (G_TYPE_RESERVED_GLIB_LAST)) {
2281     return TRUE;
2282   }
2283   if (type == GST_TYPE_BUFFER || type == GST_TYPE_FOURCC
2284       || type == GST_TYPE_FIXED_LIST) {
2285     return TRUE;
2286   }
2287
2288   return FALSE;
2289 }
2290
2291 void
2292 _gst_value_initialize (void)
2293 {
2294   GTypeInfo info = {
2295     0,
2296     NULL,
2297     NULL,
2298     NULL,
2299     NULL,
2300     NULL,
2301     0,
2302     0,
2303     NULL,
2304     NULL,
2305   };
2306   GTypeFundamentalInfo finfo = {
2307     0
2308   };
2309
2310   //const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
2311
2312   gst_value_table = g_array_new (FALSE, FALSE, sizeof (GstValueTable));
2313   gst_value_union_funcs = g_array_new (FALSE, FALSE,
2314       sizeof (GstValueUnionInfo));
2315   gst_value_intersect_funcs = g_array_new (FALSE, FALSE,
2316       sizeof (GstValueIntersectInfo));
2317   gst_value_subtract_funcs = g_array_new (FALSE, FALSE,
2318       sizeof (GstValueSubtractInfo));
2319
2320   {
2321     static const GTypeValueTable value_table = {
2322       gst_value_init_fourcc,
2323       NULL,
2324       gst_value_copy_fourcc,
2325       NULL,
2326       "i",
2327       gst_value_collect_fourcc,
2328       "p",
2329       gst_value_lcopy_fourcc
2330     };
2331     static GstValueTable gst_value = {
2332       0,
2333       gst_value_compare_fourcc,
2334       gst_value_serialize_fourcc,
2335       gst_value_deserialize_fourcc,
2336     };
2337
2338     info.value_table = &value_table;
2339     gst_type_fourcc = g_type_register_fundamental (g_type_fundamental_next (),
2340         "GstFourcc", &info, &finfo, 0);
2341     gst_value.type = gst_type_fourcc;
2342     gst_value_register (&gst_value);
2343   }
2344
2345   {
2346     static const GTypeValueTable value_table = {
2347       gst_value_init_int_range,
2348       NULL,
2349       gst_value_copy_int_range,
2350       NULL,
2351       "ii",
2352       gst_value_collect_int_range,
2353       "pp",
2354       gst_value_lcopy_int_range
2355     };
2356     static GstValueTable gst_value = {
2357       0,
2358       gst_value_compare_int_range,
2359       gst_value_serialize_int_range,
2360       gst_value_deserialize_int_range,
2361     };
2362
2363     info.value_table = &value_table;
2364     gst_type_int_range =
2365         g_type_register_fundamental (g_type_fundamental_next (), "GstIntRange",
2366         &info, &finfo, 0);
2367     gst_value.type = gst_type_int_range;
2368     gst_value_register (&gst_value);
2369   }
2370
2371   {
2372     static const GTypeValueTable value_table = {
2373       gst_value_init_double_range,
2374       NULL,
2375       gst_value_copy_double_range,
2376       NULL,
2377       "dd",
2378       gst_value_collect_double_range,
2379       "pp",
2380       gst_value_lcopy_double_range
2381     };
2382     static GstValueTable gst_value = {
2383       0,
2384       gst_value_compare_double_range,
2385       gst_value_serialize_double_range,
2386       gst_value_deserialize_double_range,
2387     };
2388
2389     info.value_table = &value_table;
2390     gst_type_double_range =
2391         g_type_register_fundamental (g_type_fundamental_next (),
2392         "GstDoubleRange", &info, &finfo, 0);
2393     gst_value.type = gst_type_double_range;
2394     gst_value_register (&gst_value);
2395   }
2396
2397   {
2398     static const GTypeValueTable value_table = {
2399       gst_value_init_list,
2400       gst_value_free_list,
2401       gst_value_copy_list,
2402       gst_value_list_peek_pointer,
2403       "p",
2404       gst_value_collect_list,
2405       "p",
2406       gst_value_lcopy_list
2407     };
2408     static GstValueTable gst_value = {
2409       0,
2410       gst_value_compare_list,
2411       gst_value_serialize_list,
2412       gst_value_deserialize_list,
2413     };
2414
2415     info.value_table = &value_table;
2416     gst_type_list = g_type_register_fundamental (g_type_fundamental_next (),
2417         "GstValueList", &info, &finfo, 0);
2418     gst_value.type = gst_type_list;
2419     gst_value_register (&gst_value);
2420   }
2421
2422   {
2423     static const GTypeValueTable value_table = {
2424       gst_value_init_list,
2425       gst_value_free_list,
2426       gst_value_copy_list,
2427       gst_value_list_peek_pointer,
2428       "p",
2429       gst_value_collect_list,
2430       "p",
2431       gst_value_lcopy_list
2432     };
2433     static GstValueTable gst_value = {
2434       0,
2435       gst_value_compare_list,
2436       gst_value_serialize_fixed_list,
2437       gst_value_deserialize_fixed_list,
2438     };
2439
2440     info.value_table = &value_table;
2441     gst_type_fixed_list =
2442         g_type_register_fundamental (g_type_fundamental_next (),
2443         "GstValueFixedList", &info, &finfo, 0);
2444     gst_value.type = gst_type_fixed_list;
2445     gst_value_register (&gst_value);
2446   }
2447
2448   {
2449 #if 0
2450     static const GTypeValueTable value_table = {
2451       gst_value_init_buffer,
2452       NULL,
2453       gst_value_copy_buffer,
2454       NULL,
2455       "i",
2456       NULL,                     /*gst_value_collect_buffer, */
2457       "p",
2458       NULL                      /*gst_value_lcopy_buffer */
2459     };
2460 #endif
2461     static GstValueTable gst_value = {
2462       0,
2463       gst_value_compare_buffer,
2464       gst_value_serialize_buffer,
2465       gst_value_deserialize_buffer,
2466     };
2467
2468 #if 0
2469     info.value_table = &value_table;
2470     gst_type_fourcc =
2471         g_type_register_static (G_TYPE_BOXED, "GstFourcc", &info, 0);
2472 #endif
2473     gst_value.type = GST_TYPE_BUFFER;
2474     gst_value_register (&gst_value);
2475   }
2476
2477   REGISTER_SERIALIZATION (G_TYPE_DOUBLE, double);
2478   REGISTER_SERIALIZATION (G_TYPE_FLOAT, float);
2479
2480   REGISTER_SERIALIZATION (G_TYPE_STRING, string);
2481   REGISTER_SERIALIZATION (G_TYPE_BOOLEAN, boolean);
2482   REGISTER_SERIALIZATION (G_TYPE_ENUM, enum);
2483
2484   REGISTER_SERIALIZATION (G_TYPE_INT, int);
2485
2486   REGISTER_SERIALIZATION (G_TYPE_INT64, int64);
2487   REGISTER_SERIALIZATION (G_TYPE_LONG, long);
2488
2489   REGISTER_SERIALIZATION (G_TYPE_UINT, uint);
2490   REGISTER_SERIALIZATION (G_TYPE_UINT64, uint64);
2491   REGISTER_SERIALIZATION (G_TYPE_ULONG, ulong);
2492
2493   g_value_register_transform_func (GST_TYPE_FOURCC, G_TYPE_STRING,
2494       gst_value_transform_fourcc_string);
2495   g_value_register_transform_func (GST_TYPE_INT_RANGE, G_TYPE_STRING,
2496       gst_value_transform_int_range_string);
2497   g_value_register_transform_func (GST_TYPE_DOUBLE_RANGE, G_TYPE_STRING,
2498       gst_value_transform_double_range_string);
2499   g_value_register_transform_func (GST_TYPE_LIST, G_TYPE_STRING,
2500       gst_value_transform_list_string);
2501   g_value_register_transform_func (GST_TYPE_FIXED_LIST, G_TYPE_STRING,
2502       gst_value_transform_fixed_list_string);
2503
2504   gst_value_register_intersect_func (G_TYPE_INT, GST_TYPE_INT_RANGE,
2505       gst_value_intersect_int_int_range);
2506   gst_value_register_intersect_func (GST_TYPE_INT_RANGE, GST_TYPE_INT_RANGE,
2507       gst_value_intersect_int_range_int_range);
2508   gst_value_register_intersect_func (G_TYPE_DOUBLE, GST_TYPE_DOUBLE_RANGE,
2509       gst_value_intersect_double_double_range);
2510   gst_value_register_intersect_func (GST_TYPE_DOUBLE_RANGE,
2511       GST_TYPE_DOUBLE_RANGE, gst_value_intersect_double_range_double_range);
2512
2513   gst_value_register_subtract_func (G_TYPE_INT, GST_TYPE_INT_RANGE,
2514       gst_value_subtract_int_int_range);
2515   gst_value_register_subtract_func (GST_TYPE_INT_RANGE, G_TYPE_INT,
2516       gst_value_subtract_int_range_int);
2517   gst_value_register_subtract_func (GST_TYPE_INT_RANGE, GST_TYPE_INT_RANGE,
2518       gst_value_subtract_int_range_int_range);
2519   gst_value_register_subtract_func (G_TYPE_DOUBLE, GST_TYPE_DOUBLE_RANGE,
2520       gst_value_subtract_double_double_range);
2521   gst_value_register_subtract_func (GST_TYPE_DOUBLE_RANGE, G_TYPE_DOUBLE,
2522       gst_value_subtract_double_range_double);
2523   gst_value_register_subtract_func (GST_TYPE_DOUBLE_RANGE,
2524       GST_TYPE_DOUBLE_RANGE, gst_value_subtract_double_range_double_range);
2525
2526   gst_value_register_union_func (G_TYPE_INT, GST_TYPE_INT_RANGE,
2527       gst_value_union_int_int_range);
2528   gst_value_register_union_func (GST_TYPE_INT_RANGE, GST_TYPE_INT_RANGE,
2529       gst_value_union_int_range_int_range);
2530 }