FCL/sf/mw/gstreamer: comparison gstreamer

equal deleted inserted replaced

-:4b0c6ed43234
+:8e837d1bf446
 } \
 } G_STMT_END
 #define IS_WRITABLE(caps) \
 (g_atomic_int_get (&(caps)->refcount) == 1)
-#if GLIB_CHECK_VERSION (2, 10, 0)
+/* quick way to get a caps structure at an index without doing a type or array
-#define ALLOC_CAPS()    g_slice_new (GstCaps)
+* length check */
-#define FREE_CAPS(caps) g_slice_free (GstCaps, caps)
+#define gst_caps_get_structure_unchecked(caps, index) \
-#else
+((GstStructure *)g_ptr_array_index ((caps)->structs, (index)))
-#define ALLOC_CAPS()    g_new (GstCaps, 1)
-#define FREE_CAPS(caps) g_free (caps)
-#endif
 /* lock to protect multiple invocations of static caps to caps conversion */
 G_LOCK_DEFINE_STATIC (static_caps_lock);
 static void gst_caps_transform_to_string (const GValue * src_value,
 #endif
 GstCaps *
 gst_caps_new_empty (void)
 {
-GstCaps *caps = ALLOC_CAPS ();
+GstCaps *caps = g_slice_new (GstCaps);
 caps->type = GST_TYPE_CAPS;
 caps->refcount = 1;
 caps->flags = 0;
 caps->structs = g_ptr_array_new ();
 GstCaps *
 gst_caps_copy (const GstCaps * caps)
 {
 GstCaps *newcaps;
 GstStructure *structure;
-guint i;
+guint i, n;
 g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
 newcaps = gst_caps_new_empty ();
 newcaps->flags = caps->flags;
+n = caps->structs->len;
-for (i = 0; i < caps->structs->len; i++) {
-structure = gst_caps_get_structure (caps, i);
+for (i = 0; i < n; i++) {
+structure = gst_caps_get_structure_unchecked (caps, i);
 gst_caps_append_structure (newcaps, gst_structure_copy (structure));
 }
 return newcaps;
 }
 static void
 _gst_caps_free (GstCaps * caps)
 {
 GstStructure *structure;
-guint i;
+guint i, len;
 /* The refcount must be 0, but since we're only called by gst_caps_unref,
 * don't bother testing. */
+len = caps->structs->len;
-for (i = 0; i < caps->structs->len; i++) {
+for (i = 0; i < len; i++) {
-structure = (GstStructure *) gst_caps_get_structure (caps, i);
+structure = (GstStructure *) gst_caps_get_structure_unchecked (caps, i);
 gst_structure_set_parent_refcount (structure, NULL);
 gst_structure_free (structure);
 }
 g_ptr_array_free (caps->structs, TRUE);
 #ifdef USE_POISONING
 #endif
 #ifdef DEBUG_REFCOUNT
 GST_CAT_LOG (GST_CAT_CAPS, "freeing caps %p", caps);
 #endif
-FREE_CAPS (caps);
+g_slice_free (GstCaps, caps);
 }
 /**
 * gst_caps_make_writable:
 * @caps: the #GstCaps to make writable
 temp.flags = 0;
 temp.structs = g_ptr_array_new ();
 /* initialize the caps to a refcount of 1 so the caps can be writable for
 * the next statement */
-gst_atomic_int_set (&temp.refcount, 1);
+temp.refcount = 1;
 /* convert to string */
 if (G_UNLIKELY (!gst_caps_from_string_inplace (&temp, string)))
 g_critical ("Could not convert static caps \"%s\"", string);
 /* now copy stuff over to the real caps. */
 caps->type = temp.type;
 caps->flags = temp.flags;
 caps->structs = temp.structs;
 /* and bump the refcount so other threads can now read */
-gst_atomic_int_set (&caps->refcount, 1);
+g_atomic_int_set (&caps->refcount, 1);
 GST_CAT_LOG (GST_CAT_CAPS, "created %p", static_caps);
 done:
 G_UNLOCK (static_caps_lock);
 }
 gpointer data)
 {
 GstStructure *struct1 = (GstStructure *) data;
 const GValue *val1 = gst_structure_id_get_value (struct1, field_id);
-if (val1 == NULL)
+if (G_UNLIKELY (val1 == NULL))
 return FALSE;
 if (gst_value_compare (val1, val2) == GST_VALUE_EQUAL) {
 return TRUE;
 }
 gpointer user_data)
 {
 GstStructure *subtract_from = user_data;
 GValue subtraction = { 0, };
 const GValue *other;
-gint res;
+if (!(other = gst_structure_id_get_value (subtract_from, field_id)))
-other = gst_structure_id_get_value (subtract_from, field_id);
-if (!other) {
 /* field is missing in one set */
 return FALSE;
-}
+/* equal values are subset */
+if (gst_value_compare (other, value) == GST_VALUE_EQUAL)
+return TRUE;
 /*
+* 1 - [1,2] = empty
+* -> !subset
+*
 * [1,2] - 1 = 2
-* 1 - [1,2] = ???
+*  -> 1 - [1,2] = empty
+*  -> subset
+*
+* [1,3] - [1,2] = 3
+* -> [1,2] - [1,3] = empty
+* -> subset
+*
+* {1,2} - {1,3} = 2
+* -> {1,3} - {1,2} = 3
+* -> !subset
+*
+*  First caps subtraction needs to return a non-empty set, second
+*  subtractions needs to give en empty set.
 */
-if (!gst_value_subtract (&subtraction, other, value)) {
+if (gst_value_subtract (&subtraction, other, value)) {
-/* empty result -> values are the same, or first was a value and
+g_value_unset (&subtraction);
-* second was a list
+/* !empty result, swapping must be empty */
-* verify that result is empty by swapping args */
+if (!gst_value_subtract (&subtraction, value, other))
-if (!gst_value_subtract (&subtraction, value, other)) {
 return TRUE;
-}
 g_value_unset (&subtraction);
-return FALSE;
+}
-}
+return FALSE;
-res = gst_value_compare (&subtraction, other);
-g_value_unset (&subtraction);
-if (res == GST_VALUE_EQUAL) {
-/* value was empty ? */
-return FALSE;
-} else {
-return TRUE;
-}
 }
 static gboolean
 gst_caps_structure_is_subset (const GstStructure * minuend,
 const GstStructure * subtrahend)
 g_return_if_fail (IS_WRITABLE (caps2));
 #ifdef USE_POISONING
 CAPS_POISON (caps2);
 #endif
-if (gst_caps_is_any (caps1) || gst_caps_is_any (caps2)) {
+if (G_UNLIKELY (gst_caps_is_any (caps1) || gst_caps_is_any (caps2))) {
 /* FIXME: this leaks */
 caps1->flags |= GST_CAPS_FLAGS_ANY;
 for (i = caps2->structs->len - 1; i >= 0; i--) {
 structure = gst_caps_remove_and_get_structure (caps2, i);
 gst_structure_free (structure);
 }
 } else {
-int len = caps2->structs->len;
+for (i = caps2->structs->len; i; i--) {
-for (i = 0; i < len; i++) {
 structure = gst_caps_remove_and_get_structure (caps2, 0);
 gst_caps_append_structure (caps1, structure);
 }
 }
 gst_caps_unref (caps2);       /* guaranteed to free it */
 g_return_if_fail (IS_WRITABLE (caps2));
 #ifdef USE_POISONING
 CAPS_POISON (caps2);
 #endif
-if (gst_caps_is_any (caps1)) {
+if (G_UNLIKELY (gst_caps_is_any (caps1))) {
 for (i = caps2->structs->len - 1; i >= 0; i--) {
 structure = gst_caps_remove_and_get_structure (caps2, i);
 gst_structure_free (structure);
 }
-} else if (gst_caps_is_any (caps2)) {
+} else if (G_UNLIKELY (gst_caps_is_any (caps2))) {
 caps1->flags |= GST_CAPS_FLAGS_ANY;
 for (i = caps1->structs->len - 1; i >= 0; i--) {
 structure = gst_caps_remove_and_get_structure (caps1, i);
 gst_structure_free (structure);
 }
 } else {
-int len = caps2->structs->len;
+for (i = caps2->structs->len; i; i--) {
-for (i = 0; i < len; i++) {
 structure = gst_caps_remove_and_get_structure (caps2, 0);
 gst_caps_merge_structure (caps1, structure);
 }
 /* this is too naive
 GstCaps *com = gst_caps_intersect (caps1, caps2);
 STRUCTURE_POISON (structure);
 #endif
 #endif
 /* check each structure */
 for (i = caps->structs->len - 1; i >= 0; i--) {
-structure1 = gst_caps_get_structure (caps, i);
+structure1 = gst_caps_get_structure_unchecked (caps, i);
 /* if structure is a subset of structure1, then skip it */
 if (gst_caps_structure_is_subset (structure1, structure)) {
 unique = FALSE;
 break;
 }
 * returns it.
 *
 * WARNING: This function takes a const GstCaps *, but returns a
 * non-const GstStructure *.  This is for programming convenience --
 * the caller should be aware that structures inside a constant
-* #GstCaps should not be modified.
+* #GstCaps should not be modified. However, if you know the caps
+* are writable, either because you have just copied them or made
+* them writable with gst_caps_make_writable(), you may modify the
+* structure returned in the usual way, e.g. with functions like
+* gst_structure_set_simple().
+*
+* You do not need to free or unref the structure returned, it
+* belongs to the #GstCaps.
 *
 * Returns: a pointer to the #GstStructure corresponding to @index
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 gst_caps_get_structure (const GstCaps * caps, guint index)
 {
 g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
 g_return_val_if_fail (index < caps->structs->len, NULL);
-return g_ptr_array_index (caps->structs, index);
+return gst_caps_get_structure_unchecked (caps, index);
 }
 /**
 * gst_caps_copy_nth:
 * @caps: the #GstCaps to copy
 g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
 newcaps = gst_caps_new_empty ();
 newcaps->flags = caps->flags;
-if (caps->structs->len > nth) {
+if (G_LIKELY (caps->structs->len > nth)) {
-structure = gst_caps_get_structure (caps, nth);
+structure = gst_caps_get_structure_unchecked (caps, nth);
 gst_caps_append_structure (newcaps, gst_structure_copy (structure));
 }
 return newcaps;
 }
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
 void
-gst_caps_set_simple (GstCaps * caps, char *field, ...)
+gst_caps_set_simple (GstCaps * caps, const char *field, ...)
 {
 GstStructure *structure;
 va_list var_args;
 g_return_if_fail (GST_IS_CAPS (caps));
 g_return_if_fail (caps->structs->len == 1);
 g_return_if_fail (IS_WRITABLE (caps));
-structure = gst_caps_get_structure (caps, 0);
+structure = gst_caps_get_structure_unchecked (caps, 0);
 va_start (var_args, field);
 gst_structure_set_valist (structure, field, var_args);
 va_end (var_args);
 }
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
 void
-gst_caps_set_simple_valist (GstCaps * caps, char *field, va_list varargs)
+gst_caps_set_simple_valist (GstCaps * caps, const char *field, va_list varargs)
 {
 GstStructure *structure;
 g_return_if_fail (GST_IS_CAPS (caps));
 g_return_if_fail (caps->structs->len == 1);
 g_return_if_fail (IS_WRITABLE (caps));
-structure = gst_caps_get_structure (caps, 0);
+structure = gst_caps_get_structure_unchecked (caps, 0);
 gst_structure_set_valist (structure, field, varargs);
 }
 /* tests */
 g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
 if (caps->structs->len != 1)
 return FALSE;
-structure = gst_caps_get_structure (caps, 0);
+structure = gst_caps_get_structure_unchecked (caps, 0);
 return gst_structure_foreach (structure, gst_caps_is_fixed_foreach, NULL);
 }
 /**
 GstStructure *struct1, *struct2;
 g_return_val_if_fail (gst_caps_is_fixed (caps1), FALSE);
 g_return_val_if_fail (gst_caps_is_fixed (caps2), FALSE);
-struct1 = gst_caps_get_structure (caps1, 0);
+struct1 = gst_caps_get_structure_unchecked (caps1, 0);
-struct2 = gst_caps_get_structure (caps2, 0);
+struct2 = gst_caps_get_structure_unchecked (caps2, 0);
 if (struct1->name != struct2->name) {
 return FALSE;
 }
 if (struct1->fields->len != struct2->fields->len) {
 #endif
 gboolean
 gst_caps_is_equal (const GstCaps * caps1, const GstCaps * caps2)
 {
+/* FIXME 0.11: NULL pointers are no valid Caps but indicate an error
+* So there should be an assertion that caps1 and caps2 != NULL */
 /* NULL <-> NULL is allowed here */
-if (caps1 == caps2)
+if (G_UNLIKELY (caps1 == caps2))
 return TRUE;
 /* one of them NULL => they are different (can't be both NULL because
 * we checked that above) */
-if (caps1 == NULL || caps2 == NULL)
+if (G_UNLIKELY (caps1 == NULL || caps2 == NULL))
 return FALSE;
-if (gst_caps_is_fixed (caps1) && gst_caps_is_fixed (caps2))
+if (G_UNLIKELY (gst_caps_is_fixed (caps1) && gst_caps_is_fixed (caps2)))
 return gst_caps_is_equal_fixed (caps1, caps2);
 return gst_caps_is_subset (caps1, caps2) && gst_caps_is_subset (caps2, caps1);
 }
 {
 IntersectData *idata = (IntersectData *) data;
 GValue dest_value = { 0 };
 const GValue *val2 = gst_structure_id_get_value (idata->intersect, id);
-if (val2 == NULL) {
+if (G_UNLIKELY (val2 == NULL)) {
 gst_structure_id_set_value (idata->dest, id, val1);
 } else if (idata->first_run) {
 if (gst_value_intersect (&dest_value, val1, val2)) {
 gst_structure_id_set_value (idata->dest, id, &dest_value);
 g_value_unset (&dest_value);
 IntersectData data;
 g_return_val_if_fail (struct1 != NULL, NULL);
 g_return_val_if_fail (struct2 != NULL, NULL);
-if (struct1->name != struct2->name)
+if (G_UNLIKELY (struct1->name != struct2->name))
 return NULL;
 data.dest = gst_structure_id_empty_new (struct1->name);
 data.intersect = struct2;
 data.first_run = TRUE;
-if (!gst_structure_foreach ((GstStructure *) struct1,
+if (G_UNLIKELY (!gst_structure_foreach ((GstStructure *) struct1,
-gst_caps_structure_intersect_field, &data))
+gst_caps_structure_intersect_field, &data)))
 goto error;
 data.intersect = struct1;
 data.first_run = FALSE;
-if (!gst_structure_foreach ((GstStructure *) struct2,
+if (G_UNLIKELY (!gst_structure_foreach ((GstStructure *) struct2,
-gst_caps_structure_intersect_field, &data))
+gst_caps_structure_intersect_field, &data)))
 goto error;
 return data.dest;
 error:
 GstCaps *
 gst_caps_intersect (const GstCaps * caps1, const GstCaps * caps2)
 {
 guint64 i;                    /* index can be up to 2 * G_MAX_UINT */
-guint j, k;
+guint j, k, len1, len2;
 GstStructure *struct1;
 GstStructure *struct2;
 GstCaps *dest;
 GstStructure *istruct;
 g_return_val_if_fail (GST_IS_CAPS (caps1), NULL);
 g_return_val_if_fail (GST_IS_CAPS (caps2), NULL);
 /* caps are exactly the same pointers, just copy one caps */
-if (caps1 == caps2)
+if (G_UNLIKELY (caps1 == caps2))
 return gst_caps_copy (caps1);
 /* empty caps on either side, return empty */
-if (gst_caps_is_empty (caps1) || gst_caps_is_empty (caps2))
+if (G_UNLIKELY (gst_caps_is_empty (caps1) || gst_caps_is_empty (caps2)))
 return gst_caps_new_empty ();
 /* one of the caps is any, just copy the other caps */
-if (gst_caps_is_any (caps1))
+if (G_UNLIKELY (gst_caps_is_any (caps1)))
 return gst_caps_copy (caps2);
-if (gst_caps_is_any (caps2))
+if (G_UNLIKELY (gst_caps_is_any (caps2)))
 return gst_caps_copy (caps1);
 dest = gst_caps_new_empty ();
 /* run zigzag on top line then right line, this preserves the caps order
 *
 * First we iterate over the caps1 structures (top line) intersecting
 * the structures diagonally down, then we iterate over the caps2
 * structures.
 */
-for (i = 0; i < caps1->structs->len + caps2->structs->len - 1; i++) {
+len1 = caps1->structs->len;
+len2 = caps2->structs->len;
+for (i = 0; i < len1 + len2 - 1; i++) {
 /* caps1 index goes from 0 to caps1->structs->len-1 */
-j = MIN (i, caps1->structs->len - 1);
+j = MIN (i, len1 - 1);
 /* caps2 index stays 0 until i reaches caps1->structs->len, then it counts
 * up from 1 to caps2->structs->len - 1 */
 k = MAX (0, i - j);
 /* now run the diagonal line, end condition is the left or bottom
 * border */
-while (k < caps2->structs->len) {
+while (k < len2) {
-struct1 = gst_caps_get_structure (caps1, j);
+struct1 = gst_caps_get_structure_unchecked (caps1, j);
-struct2 = gst_caps_get_structure (caps2, k);
+struct2 = gst_caps_get_structure_unchecked (caps2, k);
 istruct = gst_caps_structure_intersect (struct1, struct2);
 gst_caps_append_structure (dest, istruct);
 /* move down left */
 k++;
-if (j == 0)
+if (G_UNLIKELY (j == 0))
 break;                  /* so we don't roll back to G_MAXUINT */
 j--;
 }
 }
 return dest;
 #endif
 GstCaps *
 gst_caps_subtract (const GstCaps * minuend, const GstCaps * subtrahend)
 {
-guint i, j;
+guint i, j, sublen;
 GstStructure *min;
 GstStructure *sub;
 GstCaps *dest = NULL, *src;
 g_return_val_if_fail (minuend != NULL, NULL);
 The reason we need this is that there is no definition about what
 ANY means for specific types, so it's not possible to reduce ANY partially
 You can only remove everything or nothing and that is done above.
 Note: there's a test that checks this behaviour. */
 g_return_val_if_fail (!gst_caps_is_any (minuend), NULL);
-g_assert (subtrahend->structs->len > 0);
+sublen = subtrahend->structs->len;
+g_assert (sublen > 0);
 src = gst_caps_copy (minuend);
-for (i = 0; i < subtrahend->structs->len; i++) {
+for (i = 0; i < sublen; i++) {
-sub = gst_caps_get_structure (subtrahend, i);
+guint srclen;
+sub = gst_caps_get_structure_unchecked (subtrahend, i);
 if (dest) {
 gst_caps_unref (src);
 src = dest;
 }
 dest = gst_caps_new_empty ();
-for (j = 0; j < src->structs->len; j++) {
+srclen = src->structs->len;
-min = gst_caps_get_structure (src, j);
+for (j = 0; j < srclen; j++) {
+min = gst_caps_get_structure_unchecked (src, j);
 if (gst_structure_get_name_id (min) == gst_structure_get_name_id (sub)) {
 GSList *list;
 if (gst_caps_structure_subtract (&list, min, sub)) {
 GSList *walk;
 gst_caps_union (const GstCaps * caps1, const GstCaps * caps2)
 {
 GstCaps *dest1;
 GstCaps *dest2;
+/* NULL pointers are no correct GstCaps */
+g_return_val_if_fail (caps1 != NULL, NULL);
+g_return_val_if_fail (caps2 != NULL, NULL);
+if (gst_caps_is_empty (caps1))
+return gst_caps_copy (caps2);
+if (gst_caps_is_empty (caps2))
+return gst_caps_copy (caps1);
 if (gst_caps_is_any (caps1) || gst_caps_is_any (caps2))
 return gst_caps_new_any ();
 dest1 = gst_caps_copy (caps1);
 dest2 = gst_caps_copy (caps2);
 NormalizeForeach *nf = (NormalizeForeach *) ptr;
 GValue val = { 0 };
 guint i;
 if (G_VALUE_TYPE (value) == GST_TYPE_LIST) {
-for (i = 1; i < gst_value_list_get_size (value); i++) {
+guint len = gst_value_list_get_size (value);
+for (i = 1; i < len; i++) {
 const GValue *v = gst_value_list_get_value (value, i);
 GstStructure *structure = gst_structure_copy (nf->structure);
 gst_structure_id_set_value (structure, field_id, v);
 gst_caps_append_structure (nf->caps, structure);
 GstCaps *
 gst_caps_normalize (const GstCaps * caps)
 {
 NormalizeForeach nf;
 GstCaps *newcaps;
-guint i;
+guint i, nlen;
 g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
 newcaps = gst_caps_copy (caps);
 nf.caps = newcaps;
+nlen = newcaps->structs->len;
-for (i = 0; i < newcaps->structs->len; i++) {
-nf.structure = gst_caps_get_structure (newcaps, i);
+for (i = 0; i < nlen; i++) {
+nf.structure = gst_caps_get_structure_unchecked (newcaps, i);
 while (!gst_structure_foreach (nf.structure,
 gst_caps_normalize_foreach, &nf));
 }
 g_ptr_array_sort (caps->structs, gst_caps_compare_structures);
 start = caps->structs->len - 1;
 for (i = caps->structs->len - 1; i >= 0; i--) {
-simplify = gst_caps_get_structure (caps, i);
+simplify = gst_caps_get_structure_unchecked (caps, i);
 if (gst_structure_get_name_id (simplify) !=
-gst_structure_get_name_id (gst_caps_get_structure (caps, start)))
+gst_structure_get_name_id (gst_caps_get_structure_unchecked (caps,
+start)))
 start = i;
 for (j = start; j >= 0; j--) {
 if (j == i)
 continue;
-compare = gst_caps_get_structure (caps, j);
+compare = gst_caps_get_structure_unchecked (caps, j);
 if (gst_structure_get_name_id (simplify) !=
 gst_structure_get_name_id (compare)) {
 break;
 }
 if (gst_caps_structure_simplify (&result, simplify, compare)) {
 *
 * Converts @caps to a string representation.  This string representation
 * can be converted back to a #GstCaps by gst_caps_from_string().
 *
 * For debugging purposes its easier to do something like this:
-* <programlisting>
+* |[
-*  GST_LOG ("caps are %" GST_PTR_FORMAT, caps);
+* GST_LOG ("caps are %" GST_PTR_FORMAT, caps);
-* </programlisting>
+* ]|
 * This prints the caps in human readble form.
 *
 * Returns: a newly allocated string representing @caps.
 */
 #ifdef __SYMBIAN32__
 #endif
 gchar *
 gst_caps_to_string (const GstCaps * caps)
 {
-guint i, slen;
+guint i, slen, clen;
 GString *s;
 /* NOTE:  This function is potentially called by the debug system,
 * so any calls to gst_log() (and GST_DEBUG(), GST_LOG(), etc.)
 * should be careful to avoid recursion.  This includes any functions
 return g_strdup ("EMPTY");
 }
 /* estimate a rough string length to avoid unnecessary reallocs in GString */
 slen = 0;
-for (i = 0; i < caps->structs->len; i++) {
+clen = caps->structs->len;
-slen += STRUCTURE_ESTIMATED_STRING_LEN (gst_caps_get_structure (caps, i));
+for (i = 0; i < clen; i++) {
+slen +=
+STRUCTURE_ESTIMATED_STRING_LEN (gst_caps_get_structure_unchecked (caps,
+i));
 }
 s = g_string_sized_new (slen);
-for (i = 0; i < caps->structs->len; i++) {
+for (i = 0; i < clen; i++) {
 GstStructure *structure;
 if (i > 0) {
 /* ';' is now added by gst_structure_to_string */
 g_string_append_c (s, ' ');
 }
-structure = gst_caps_get_structure (caps, i);
+structure = gst_caps_get_structure_unchecked (caps, i);
 priv_gst_structure_append_to_gstring (structure, s);
 }
 if (s->len && s->str[s->len - 1] == ';') {
 /* remove latest ';' */
 s->str[--s->len] = '\0';

changeset 16	8e837d1bf446
parent 0	0e761a78d257
child 30	7e817e7e631c