}
/* our fundamental types that are certainly not fixed */
if (type == GST_TYPE_INT_RANGE || type == GST_TYPE_DOUBLE_RANGE ||
+ type == GST_TYPE_INT64_RANGE ||
type == GST_TYPE_LIST || type == GST_TYPE_FRACTION_RANGE) {
return FALSE;
}
return FALSE;
}
+/***************
+ * int64 range *
+ ***************/
+
+static void
+gst_value_init_int64_range (GValue * value)
+{
+ value->data[0].v_int64 = 0;
+ value->data[1].v_int64 = 0;
+}
+
+static void
+gst_value_copy_int64_range (const GValue * src_value, GValue * dest_value)
+{
+ dest_value->data[0].v_int64 = src_value->data[0].v_int64;
+ dest_value->data[1].v_int64 = src_value->data[1].v_int64;
+}
+
+static gchar *
+gst_value_collect_int64_range (GValue * value, guint n_collect_values,
+ GTypeCValue * collect_values, guint collect_flags)
+{
+ if (n_collect_values != 2)
+ return g_strdup_printf ("not enough value locations for `%s' passed",
+ G_VALUE_TYPE_NAME (value));
+ if (collect_values[0].v_int64 >= collect_values[1].v_int64)
+ return g_strdup_printf ("range start is not smaller than end for `%s'",
+ G_VALUE_TYPE_NAME (value));
+
+ value->data[0].v_int64 = collect_values[0].v_int64;
+ value->data[1].v_int64 = collect_values[1].v_int64;
+
+ return NULL;
+}
+
+static gchar *
+gst_value_lcopy_int64_range (const GValue * value, guint n_collect_values,
+ GTypeCValue * collect_values, guint collect_flags)
+{
+ guint64 *int_range_start = collect_values[0].v_pointer;
+ guint64 *int_range_end = collect_values[1].v_pointer;
+
+ if (!int_range_start)
+ return g_strdup_printf ("start value location for `%s' passed as NULL",
+ G_VALUE_TYPE_NAME (value));
+ if (!int_range_end)
+ return g_strdup_printf ("end value location for `%s' passed as NULL",
+ G_VALUE_TYPE_NAME (value));
+
+ *int_range_start = value->data[0].v_int64;
+ *int_range_end = value->data[1].v_int64;
+
+ return NULL;
+}
+
+/**
+ * gst_value_set_int64_range:
+ * @value: a GValue initialized to GST_TYPE_INT64_RANGE
+ * @start: the start of the range
+ * @end: the end of the range
+ *
+ * Sets @value to the range specified by @start and @end.
+ */
+void
+gst_value_set_int64_range (GValue * value, gint64 start, gint64 end)
+{
+ g_return_if_fail (GST_VALUE_HOLDS_INT64_RANGE (value));
+ g_return_if_fail (start < end);
+
+ value->data[0].v_int64 = start;
+ value->data[1].v_int64 = end;
+}
+
+/**
+ * gst_value_get_int64_range_min:
+ * @value: a GValue initialized to GST_TYPE_INT64_RANGE
+ *
+ * Gets the minimum of the range specified by @value.
+ *
+ * Returns: the minimum of the range
+ */
+gint64
+gst_value_get_int64_range_min (const GValue * value)
+{
+ g_return_val_if_fail (GST_VALUE_HOLDS_INT64_RANGE (value), 0);
+
+ return value->data[0].v_int64;
+}
+
+/**
+ * gst_value_get_int64_range_max:
+ * @value: a GValue initialized to GST_TYPE_INT64_RANGE
+ *
+ * Gets the maximum of the range specified by @value.
+ *
+ * Returns: the maxumum of the range
+ */
+gint64
+gst_value_get_int64_range_max (const GValue * value)
+{
+ g_return_val_if_fail (GST_VALUE_HOLDS_INT64_RANGE (value), 0);
+
+ return value->data[1].v_int64;
+}
+
+static void
+gst_value_transform_int64_range_string (const GValue * src_value,
+ GValue * dest_value)
+{
+ dest_value->data[0].v_pointer =
+ g_strdup_printf ("(gint64)[%" G_GINT64_FORMAT ",%" G_GINT64_FORMAT "]",
+ src_value->data[0].v_int64, src_value->data[1].v_int64);
+}
+
+static gint
+gst_value_compare_int64_range (const GValue * value1, const GValue * value2)
+{
+ if (value2->data[0].v_int64 == value1->data[0].v_int64 &&
+ value2->data[1].v_int64 == value1->data[1].v_int64)
+ return GST_VALUE_EQUAL;
+ return GST_VALUE_UNORDERED;
+}
+
+static gchar *
+gst_value_serialize_int64_range (const GValue * value)
+{
+ return g_strdup_printf ("[ %" G_GINT64_FORMAT ", %" G_GINT64_FORMAT " ]",
+ value->data[0].v_int64, value->data[1].v_int64);
+}
+
+static gboolean
+gst_value_deserialize_int64_range (GValue * dest, const gchar * s)
+{
+ g_warning ("unimplemented");
+ return FALSE;
+}
+
/****************
* double range *
****************/
}
static gboolean
+gst_value_intersect_int64_int64_range (GValue * dest, const GValue * src1,
+ const GValue * src2)
+{
+ if (src2->data[0].v_int64 <= src1->data[0].v_int64 &&
+ src2->data[1].v_int64 >= src1->data[0].v_int64) {
+ gst_value_init_and_copy (dest, src1);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+gst_value_intersect_int64_range_int64_range (GValue * dest, const GValue * src1,
+ const GValue * src2)
+{
+ gint64 min;
+ gint64 max;
+
+ min = MAX (src1->data[0].v_int64, src2->data[0].v_int64);
+ max = MIN (src1->data[1].v_int64, src2->data[1].v_int64);
+
+ if (min < max) {
+ g_value_init (dest, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (dest, min, max);
+ return TRUE;
+ }
+ if (min == max) {
+ g_value_init (dest, G_TYPE_INT64);
+ g_value_set_int64 (dest, min);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
gst_value_intersect_double_double_range (GValue * dest, const GValue * src1,
const GValue * src2)
{
}
static gboolean
+gst_value_subtract_int64_int64_range (GValue * dest, const GValue * minuend,
+ const GValue * subtrahend)
+{
+ gint64 min = gst_value_get_int64_range_min (subtrahend);
+ gint64 max = gst_value_get_int64_range_max (subtrahend);
+ gint64 val = g_value_get_int64 (minuend);
+
+ /* subtracting a range from an int64 only works if the int64 is not in the
+ * range */
+ if (val < min || val > max) {
+ /* and the result is the int64 */
+ gst_value_init_and_copy (dest, minuend);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/* creates a new int64 range based on input values.
+ */
+static gboolean
+gst_value_create_new_int64_range (GValue * dest, gint64 min1, gint64 max1,
+ gint64 min2, gint64 max2)
+{
+ GValue v1 = { 0, };
+ GValue v2 = { 0, };
+ GValue *pv1, *pv2; /* yeah, hungarian! */
+
+ if (min1 <= max1 && min2 <= max2) {
+ pv1 = &v1;
+ pv2 = &v2;
+ } else if (min1 <= max1) {
+ pv1 = dest;
+ pv2 = NULL;
+ } else if (min2 <= max2) {
+ pv1 = NULL;
+ pv2 = dest;
+ } else {
+ return FALSE;
+ }
+
+ if (min1 < max1) {
+ g_value_init (pv1, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (pv1, min1, max1);
+ } else if (min1 == max1) {
+ g_value_init (pv1, G_TYPE_INT64);
+ g_value_set_int64 (pv1, min1);
+ }
+ if (min2 < max2) {
+ g_value_init (pv2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (pv2, min2, max2);
+ } else if (min2 == max2) {
+ g_value_init (pv2, G_TYPE_INT64);
+ g_value_set_int64 (pv2, min2);
+ }
+
+ if (min1 <= max1 && min2 <= max2) {
+ gst_value_list_concat (dest, pv1, pv2);
+ g_value_unset (pv1);
+ g_value_unset (pv2);
+ }
+ return TRUE;
+}
+
+static gboolean
+gst_value_subtract_int64_range_int64 (GValue * dest, const GValue * minuend,
+ const GValue * subtrahend)
+{
+ gint64 min = gst_value_get_int64_range_min (minuend);
+ gint64 max = gst_value_get_int64_range_max (minuend);
+ gint64 val = g_value_get_int64 (subtrahend);
+
+ g_return_val_if_fail (min < max, FALSE);
+
+ /* value is outside of the range, return range unchanged */
+ if (val < min || val > max) {
+ gst_value_init_and_copy (dest, minuend);
+ return TRUE;
+ } else {
+ /* max must be MAXINT64 too as val <= max */
+ if (val == G_MAXINT64) {
+ max--;
+ val--;
+ }
+ /* min must be MININT64 too as val >= max */
+ if (val == G_MININT64) {
+ min++;
+ val++;
+ }
+ gst_value_create_new_int64_range (dest, min, val - 1, val + 1, max);
+ }
+ return TRUE;
+}
+
+static gboolean
+gst_value_subtract_int64_range_int64_range (GValue * dest,
+ const GValue * minuend, const GValue * subtrahend)
+{
+ gint64 min1 = gst_value_get_int64_range_min (minuend);
+ gint64 max1 = gst_value_get_int64_range_max (minuend);
+ gint64 min2 = gst_value_get_int64_range_min (subtrahend);
+ gint64 max2 = gst_value_get_int64_range_max (subtrahend);
+
+ if (max2 == G_MAXINT64 && min2 == G_MININT64) {
+ return FALSE;
+ } else if (max2 == G_MAXINT64) {
+ return gst_value_create_new_int64_range (dest, min1, MIN (min2 - 1, max1),
+ 1, 0);
+ } else if (min2 == G_MININT64) {
+ return gst_value_create_new_int64_range (dest, MAX (max2 + 1, min1), max1,
+ 1, 0);
+ } else {
+ return gst_value_create_new_int64_range (dest, min1, MIN (min2 - 1, max1),
+ MAX (max2 + 1, min1), max1);
+ }
+}
+
+static gboolean
gst_value_subtract_double_double_range (GValue * dest, const GValue * minuend,
const GValue * subtrahend)
{
FUNC_VALUE_GET_TYPE (int_range, "GstIntRange");
+static const GTypeValueTable _gst_int64_range_value_table = {
+ gst_value_init_int64_range,
+ NULL,
+ gst_value_copy_int64_range,
+ NULL,
+ (char *) "qq",
+ gst_value_collect_int64_range,
+ (char *) "pp",
+ gst_value_lcopy_int64_range
+};
+
+FUNC_VALUE_GET_TYPE (int64_range, "GstInt64Range");
+
static const GTypeValueTable _gst_double_range_value_table = {
gst_value_init_double_range,
NULL,
{
static GstValueTable gst_value = {
0,
+ gst_value_compare_int64_range,
+ gst_value_serialize_int64_range,
+ gst_value_deserialize_int64_range,
+ };
+
+ gst_value.type = gst_int64_range_get_type ();
+ gst_value_register (&gst_value);
+ }
+
+ {
+ static GstValueTable gst_value = {
+ 0,
gst_value_compare_double_range,
gst_value_serialize_double_range,
gst_value_deserialize_double_range,
gst_value_transform_fourcc_string);
g_value_register_transform_func (GST_TYPE_INT_RANGE, G_TYPE_STRING,
gst_value_transform_int_range_string);
+ g_value_register_transform_func (GST_TYPE_INT64_RANGE, G_TYPE_STRING,
+ gst_value_transform_int64_range_string);
g_value_register_transform_func (GST_TYPE_DOUBLE_RANGE, G_TYPE_STRING,
gst_value_transform_double_range_string);
g_value_register_transform_func (GST_TYPE_FRACTION_RANGE, G_TYPE_STRING,
gst_value_intersect_int_int_range);
gst_value_register_intersect_func (GST_TYPE_INT_RANGE, GST_TYPE_INT_RANGE,
gst_value_intersect_int_range_int_range);
+ gst_value_register_intersect_func (G_TYPE_INT64, GST_TYPE_INT64_RANGE,
+ gst_value_intersect_int64_int64_range);
+ gst_value_register_intersect_func (GST_TYPE_INT64_RANGE, GST_TYPE_INT64_RANGE,
+ gst_value_intersect_int64_range_int64_range);
gst_value_register_intersect_func (G_TYPE_DOUBLE, GST_TYPE_DOUBLE_RANGE,
gst_value_intersect_double_double_range);
gst_value_register_intersect_func (GST_TYPE_DOUBLE_RANGE,
gst_value_subtract_int_range_int);
gst_value_register_subtract_func (GST_TYPE_INT_RANGE, GST_TYPE_INT_RANGE,
gst_value_subtract_int_range_int_range);
+ gst_value_register_subtract_func (G_TYPE_INT64, GST_TYPE_INT64_RANGE,
+ gst_value_subtract_int64_int64_range);
+ gst_value_register_subtract_func (GST_TYPE_INT64_RANGE, G_TYPE_INT64,
+ gst_value_subtract_int64_range_int64);
+ gst_value_register_subtract_func (GST_TYPE_INT64_RANGE, GST_TYPE_INT64_RANGE,
+ gst_value_subtract_int64_range_int64_range);
gst_value_register_subtract_func (G_TYPE_DOUBLE, GST_TYPE_DOUBLE_RANGE,
gst_value_subtract_double_double_range);
gst_value_register_subtract_func (GST_TYPE_DOUBLE_RANGE, G_TYPE_DOUBLE,
GST_END_TEST;
+GST_START_TEST (test_value_subtract_int64)
+{
+ GValue dest = { 0 };
+ GValue src1 = { 0 };
+ GValue src2 = { 0 };
+ const GValue *tmp;
+ gboolean ret;
+
+ /* int64 <-> int64
+ */
+ g_value_init (&src1, G_TYPE_INT64);
+ g_value_set_int64 (&src1, 10);
+ g_value_init (&src2, G_TYPE_INT64);
+ g_value_set_int64 (&src2, 20);
+ /* subtract as in sets, result is 10 */
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == TRUE);
+ fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
+ g_value_unset (&dest);
+
+ /* same values, yields empty set */
+ ret = gst_value_subtract (&dest, &src1, &src1);
+ fail_unless (ret == FALSE);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* int64 <-> int64_range
+ */
+
+ /* would yield an empty set */
+ g_value_init (&src1, G_TYPE_INT64);
+ g_value_set_int64 (&src1, 10);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 0, 20);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == FALSE);
+
+ /* and the other way around, should create a list of two ranges. */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
+ tmp = gst_value_list_get_value (&dest, 0);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (tmp) == 0);
+ fail_unless (gst_value_get_int64_range_max (tmp) == 9);
+ tmp = gst_value_list_get_value (&dest, 1);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (tmp) == 11);
+ fail_unless (gst_value_get_int64_range_max (tmp) == 20);
+ g_value_unset (&dest);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* border case 1, empty set */
+ g_value_init (&src1, G_TYPE_INT64);
+ g_value_set_int64 (&src1, 10);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 10, 20);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == FALSE);
+
+ /* and the other way around, should create a new range. */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (&dest) == 11);
+ fail_unless (gst_value_get_int64_range_max (&dest) == 20);
+ g_value_unset (&dest);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* border case 2, empty set */
+ g_value_init (&src1, G_TYPE_INT64);
+ g_value_set_int64 (&src1, 20);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 10, 20);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == FALSE);
+
+ /* and the other way around, should create a new range. */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (&dest) == 10);
+ fail_unless (gst_value_get_int64_range_max (&dest) == 19);
+ g_value_unset (&dest);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* case 3, valid set */
+ g_value_init (&src1, G_TYPE_INT64);
+ g_value_set_int64 (&src1, 0);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 10, 20);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == TRUE);
+ fail_unless (G_VALUE_HOLDS_INT64 (&dest) == TRUE);
+ fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
+ g_value_unset (&dest);
+
+ /* and the other way around, should keep the range. */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (&dest) == 10);
+ fail_unless (gst_value_get_int64_range_max (&dest) == 20);
+ g_value_unset (&dest);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* int64_range <-> int64_range
+ */
+
+ /* same range, empty set */
+ g_value_init (&src1, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src1, 10, 20);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 10, 20);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == FALSE);
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == FALSE);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* non overlapping ranges */
+ g_value_init (&src1, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src1, 10, 20);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 30, 40);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (&dest) == 10);
+ fail_unless (gst_value_get_int64_range_max (&dest) == 20);
+ g_value_unset (&dest);
+ /* the other way */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (&dest) == 30);
+ fail_unless (gst_value_get_int64_range_max (&dest) == 40);
+ g_value_unset (&dest);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* completely overlapping ranges */
+ g_value_init (&src1, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src1, 10, 20);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 10, 30);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == FALSE);
+ /* the other way */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (&dest) == 21);
+ fail_unless (gst_value_get_int64_range_max (&dest) == 30);
+ g_value_unset (&dest);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* partially overlapping ranges */
+ g_value_init (&src1, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src1, 10, 20);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 15, 30);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (&dest) == 10);
+ fail_unless (gst_value_get_int64_range_max (&dest) == 14);
+ g_value_unset (&dest);
+ /* the other way */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (&dest) == 21);
+ fail_unless (gst_value_get_int64_range_max (&dest) == 30);
+ g_value_unset (&dest);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* create a hole { int64_range, int64_range } */
+ g_value_init (&src1, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src1, 10, 30);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 15, 20);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
+ tmp = gst_value_list_get_value (&dest, 0);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (tmp) == 10);
+ fail_unless (gst_value_get_int64_range_max (tmp) == 14);
+ tmp = gst_value_list_get_value (&dest, 1);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (tmp) == 21);
+ fail_unless (gst_value_get_int64_range_max (tmp) == 30);
+ g_value_unset (&dest);
+ /* the other way */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == FALSE);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* create a hole, { int64, int64 } */
+ g_value_init (&src1, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src1, 10, 30);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 11, 29);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
+ tmp = gst_value_list_get_value (&dest, 0);
+ fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
+ fail_unless (g_value_get_int64 (tmp) == 10);
+ tmp = gst_value_list_get_value (&dest, 1);
+ fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
+ fail_unless (g_value_get_int64 (tmp) == 30);
+ g_value_unset (&dest);
+ /* the other way */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == FALSE);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* create a hole, { int64, int64_range } */
+ g_value_init (&src1, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src1, 10, 30);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 11, 28);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
+ tmp = gst_value_list_get_value (&dest, 0);
+ fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
+ fail_unless (g_value_get_int64 (tmp) == 10);
+ tmp = gst_value_list_get_value (&dest, 1);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (tmp) == 29);
+ fail_unless (gst_value_get_int64_range_max (tmp) == 30);
+ g_value_unset (&dest);
+ /* the other way */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == FALSE);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+
+ /* create a hole, { int64_range, int64 } */
+ g_value_init (&src1, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src1, 10, 30);
+ g_value_init (&src2, GST_TYPE_INT64_RANGE);
+ gst_value_set_int64_range (&src2, 12, 29);
+ ret = gst_value_subtract (&dest, &src1, &src2);
+ fail_unless (ret == TRUE);
+ fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
+ tmp = gst_value_list_get_value (&dest, 0);
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (tmp) == 10);
+ fail_unless (gst_value_get_int64_range_max (tmp) == 11);
+ tmp = gst_value_list_get_value (&dest, 1);
+ fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
+ fail_unless (g_value_get_int64 (tmp) == 30);
+ g_value_unset (&dest);
+ /* the other way */
+ ret = gst_value_subtract (&dest, &src2, &src1);
+ fail_unless (ret == FALSE);
+ g_value_unset (&src1);
+ g_value_unset (&src2);
+}
+
+GST_END_TEST;
+
GST_START_TEST (test_value_subtract_double)
{
GValue dest = { 0 };
GST_END_TEST;
-static Suite *
+GST_START_TEST (test_int_range)
+{
+ GValue range = { 0, };
+ GValue start = { 0, };
+ GValue end = { 0, };
+ GValue src = { 0, };
+ GValue dest = { 0, };
+ GValue range2 = { 0, };
+
+ g_value_init (&range, GST_TYPE_INT_RANGE);
+ g_value_init (&range2, GST_TYPE_INT_RANGE);
+ g_value_init (&start, G_TYPE_INT);
+ g_value_init (&end, G_TYPE_INT);
+ g_value_init (&src, G_TYPE_INT);
+
+ g_value_set_int (&src, 2);
+
+ /* Check that a intersection of int & range = int */
+ gst_value_set_int_range (&range, 1, 5);
+
+ fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
+ fail_unless (G_VALUE_TYPE (&dest) == G_TYPE_INT);
+ fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
+
+ /* Check that a intersection selects the overlapping range */
+ gst_value_set_int_range (&range2, 2, 3);
+ g_value_unset (&dest);
+ fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
+ fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
+
+ fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
+
+ /* Check that non intersection ranges don't intersect */
+ gst_value_set_int_range (&range2, 6, 7);
+ g_value_unset (&dest);
+ fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
+
+ g_value_unset (&start);
+ g_value_unset (&end);
+ g_value_unset (&range);
+ g_value_unset (&range2);
+ g_value_unset (&src);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_int64_range)
+{
+ GValue range = { 0, };
+ GValue start = { 0, };
+ GValue end = { 0, };
+ GValue src = { 0, };
+ GValue dest = { 0, };
+ GValue range2 = { 0, };
+
+ g_value_init (&range, GST_TYPE_INT64_RANGE);
+ g_value_init (&range2, GST_TYPE_INT64_RANGE);
+ g_value_init (&start, G_TYPE_INT64);
+ g_value_init (&end, G_TYPE_INT64);
+ g_value_init (&src, G_TYPE_INT64);
+
+ g_value_set_int64 (&src, 2);
+
+ /* Check that a intersection of int64 & range = int64 */
+ gst_value_set_int64_range (&range, 1, 5);
+
+ fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
+ fail_unless (G_VALUE_TYPE (&dest) == G_TYPE_INT64);
+ fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
+
+ /* Check that a intersection selects the overlapping range */
+ gst_value_set_int64_range (&range2, 2, 3);
+ g_value_unset (&dest);
+ fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
+ fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
+
+ fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
+
+ /* Check that non intersection ranges don't intersect */
+ gst_value_set_int64_range (&range2, 6, 7);
+ g_value_unset (&dest);
+ fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
+
+ g_value_unset (&start);
+ g_value_unset (&end);
+ g_value_unset (&range);
+ g_value_unset (&range2);
+ g_value_unset (&src);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_serialize_int64_range)
+{
+ int i = 0;
+
+ gint64 int64_ranges[] = {
+ 0, 5,
+ 0, G_MAXINT,
+ 5, G_MAXINT32,
+ 5, G_MAXINT64,
+ };
+ gint int64_ranges_size = sizeof (int64_ranges) / sizeof (int64_ranges[0]) / 2;
+
+ gchar *int64_range_strings[] = {
+ g_strdup ("[ 0, 5 ]"),
+ g_strdup_printf ("[ 0, %" G_GINT64_FORMAT " ]", (gint64) G_MAXINT),
+ g_strdup_printf ("[ 5, %" G_GINT64_FORMAT " ]", (gint64) G_MAXINT32),
+ g_strdup_printf ("[ 5, %" G_GINT64_FORMAT " ]", G_MAXINT64),
+ };
+ gint int64_range_strings_size =
+ sizeof (int64_range_strings) / sizeof (int64_range_strings[0]);
+
+ fail_unless (int64_ranges_size == int64_range_strings_size);
+
+ while (i < (int64_ranges_size * 2)) {
+ if ((i + 1) % 2) {
+ gchar *str;
+ gchar *str2;
+ GValue value = { 0 };
+ const GValue *deserialized_value;
+ int idx = i / 2;
+ GstStructure *s;
+
+ g_value_init (&value, GST_TYPE_INT64_RANGE);
+
+ /* check serialization */
+ gst_value_set_int64_range (&value, int64_ranges[i], int64_ranges[i + 1]);
+ str = gst_value_serialize (&value);
+ fail_unless (strcmp (str, int64_range_strings[idx]) == 0);
+ g_free (int64_range_strings[idx]);
+
+ /* now deserialize again to an int64 range */
+ s = gst_structure_new ("foo/bar", "range", GST_TYPE_INT64_RANGE,
+ int64_ranges[i], int64_ranges[i + 1], NULL);
+ deserialized_value = gst_structure_get_value (s, "range");
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (deserialized_value) == TRUE);
+ str2 = gst_value_serialize (deserialized_value);
+
+ fail_unless (gst_value_get_int64_range_min (deserialized_value) ==
+ int64_ranges[i]);
+ fail_unless (gst_value_get_int64_range_max (deserialized_value) ==
+ int64_ranges[i + 1]);
+
+ gst_structure_free (s);
+ g_free (str);
+ g_free (str2);
+ }
+ i++;
+ }
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_deserialize_int_range)
+{
+ GstStructure *s;
+ gchar *str;
+ gchar *end = NULL;
+ const GValue *deserialized_value;
+
+ /* check a valid int_range deserialization */
+ str = g_strdup_printf ("foo/bar, range=[ 1, %d ];", G_MAXINT);
+ s = gst_structure_from_string (str, &end);
+ fail_unless (*end == '\0');
+ deserialized_value = gst_structure_get_value (s, "range");
+ fail_unless (GST_VALUE_HOLDS_INT_RANGE (deserialized_value) == TRUE);
+ fail_unless (gst_value_get_int_range_min (deserialized_value) == 1);
+ fail_unless (gst_value_get_int_range_max (deserialized_value) == G_MAXINT);
+ gst_structure_free (s);
+ end = NULL;
+ g_free (str);
+
+ /* check invalid int_range deserialization */
+ str =
+ g_strdup_printf ("foo/bar, range=[ 1, %" G_GINT64_FORMAT " ];",
+ (gint64) G_MAXINT + 1);
+ ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
+ g_free (str);
+ str =
+ g_strdup_printf ("foo/bar, range=[ %" G_GINT64_FORMAT ", %"
+ G_GINT64_FORMAT " ];", (gint64) G_MAXINT, (gint64) G_MAXINT + 1);
+ ASSERT_CRITICAL (s = gst_structure_from_string (str, NULL));
+ end = NULL;
+ g_free (str);
+
+ /* check a valid int64_range deserialization. Those ranges need to
+ * be explicit about their storage type. */
+ str = g_strdup_printf ("foo/bar, range=(gint64)[ 1, %d ];", G_MAXINT);
+ s = gst_structure_from_string (str, &end);
+ fail_unless (*end == '\0');
+ deserialized_value = gst_structure_get_value (s, "range");
+ fail_unless (GST_VALUE_HOLDS_INT64_RANGE (deserialized_value) == TRUE);
+ fail_unless (gst_value_get_int64_range_min (deserialized_value) == 1);
+ fail_unless (gst_value_get_int64_range_max (deserialized_value) == G_MAXINT);
+ fail_unless (strcmp (str, gst_structure_to_string (s)) == 0);
+ gst_structure_free (s);
+ end = NULL;
+ g_free (str);
+
+ /* check invalid int64_range (starting with a gint) deserialization */
+ str =
+ g_strdup_printf ("foo/bar, range=(gint64)[ 1, %" G_GUINT64_FORMAT " ];",
+ (guint64) G_MAXINT64 + 1);
+ ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
+ fail_unless (*end == '\0');
+ gst_structure_free (s);
+ end = NULL;
+ g_free (str);
+
+ /* check invalid int64_range deserialization into a int64_range */
+ str =
+ g_strdup_printf ("foo/bar, range=(gint64)[ %" G_GINT64_FORMAT ", %"
+ G_GUINT64_FORMAT " ];", (gint64) G_MAXINT, (guint64) G_MAXINT64 + 1);
+ ASSERT_CRITICAL (s = gst_structure_from_string (str, NULL));
+ g_free (str);
+
+ /* check invalid int64_range deserialization into a int_range */
+ str =
+ g_strdup_printf ("foo/bar, range=[ %" G_GINT64_FORMAT ", %"
+ G_GUINT64_FORMAT " ];", (gint64) G_MAXINT, (guint64) G_MAXINT64 + 1);
+ s = gst_structure_from_string (str, &end);
+ fail_unless (s == NULL);
+ fail_unless (end == NULL);
+ g_free (str);
+}
+
+GST_END_TEST static Suite *
gst_value_suite (void)
{
Suite *s = suite_create ("GstValue");
tcase_add_test (tc_chain, test_value_compare);
tcase_add_test (tc_chain, test_value_intersect);
tcase_add_test (tc_chain, test_value_subtract_int);
+ tcase_add_test (tc_chain, test_value_subtract_int64);
tcase_add_test (tc_chain, test_value_subtract_double);
tcase_add_test (tc_chain, test_value_subtract_fraction);
tcase_add_test (tc_chain, test_value_subtract_fraction_range);
tcase_add_test (tc_chain, test_date_time);
tcase_add_test (tc_chain, test_fraction_range);
tcase_add_test (tc_chain, test_serialize_deserialize_caps);
+ tcase_add_test (tc_chain, test_int_range);
+ tcase_add_test (tc_chain, test_int64_range);
+ tcase_add_test (tc_chain, test_serialize_int64_range);
+ tcase_add_test (tc_chain, test_deserialize_int_range);
return s;
}
projects / platform / upstream / gstreamer.git / commitdiff