| /* GStreamer |
| * Copyright (C) <2003> David A. Schleef <ds@schleef.org> |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public |
| * License along with this library; if not, write to the |
| * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| * Boston, MA 02111-1307, USA. |
| */ |
| |
| /** |
| * SECTION:gstcaps |
| * @short_description: Structure describing sets of media formats |
| * @see_also: #GstStructure |
| * |
| * Caps (capabilities) are lighweight refcounted objects describing media types. |
| * They are composed of an array of #GstStructure. |
| * |
| * Caps are exposed on #GstPadTemplate to describe all possible types a |
| * given pad can handle. They are also stored in the #GstRegistry along with |
| * a description of the #GstElement. |
| * |
| * Caps are exposed on the element pads using the gst_pad_get_caps() pad |
| * function. This function describes the possible types that the pad can |
| * handle or produce at runtime. |
| * |
| * Caps are also attached to buffers to describe to content of the data |
| * pointed to by the buffer with gst_buffer_set_caps(). Caps attached to |
| * a #GstBuffer allow for format negotiation upstream and downstream. |
| * |
| * A #GstCaps can be constructed with the following code fragment: |
| * |
| * <example> |
| * <title>Creating caps</title> |
| * <programlisting> |
| * GstCaps *caps; |
| * caps = gst_caps_new_simple ("video/x-raw-yuv", |
| * "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'), |
| * "framerate", GST_TYPE_FRACTION, 25, 1, |
| * "pixel-aspect-ratio", GST_TYPE_FRACTION, 1, 1, |
| * "width", G_TYPE_INT, 320, |
| * "height", G_TYPE_INT, 240, |
| * NULL); |
| * </programlisting> |
| * </example> |
| * |
| * A #GstCaps is fixed when it has no properties with ranges or lists. Use |
| * gst_caps_is_fixed() to test for fixed caps. Only fixed caps can be |
| * set on a #GstPad or #GstBuffer. |
| * |
| * Various methods exist to work with the media types such as subtracting |
| * or intersecting. |
| * |
| * Last reviewed on 2007-02-13 (0.10.10) |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| #include <string.h> |
| #include <signal.h> |
| |
| #include "gst_private.h" |
| #include <gst/gst.h> |
| |
| #define DEBUG_REFCOUNT |
| |
| #define CAPS_POISON(caps) G_STMT_START{ \ |
| if (caps) { \ |
| GstCaps *_newcaps = gst_caps_copy (caps); \ |
| gst_caps_unref(caps); \ |
| caps = _newcaps; \ |
| } \ |
| } G_STMT_END |
| #define STRUCTURE_POISON(structure) G_STMT_START{ \ |
| if (structure) { \ |
| GstStructure *_newstruct = gst_structure_copy (structure); \ |
| gst_structure_free(structure); \ |
| structure = _newstruct; \ |
| } \ |
| } G_STMT_END |
| #define IS_WRITABLE(caps) \ |
| (g_atomic_int_get (&(caps)->refcount) == 1) |
| |
| #if GLIB_CHECK_VERSION (2, 10, 0) |
| #define ALLOC_CAPS() g_slice_new (GstCaps) |
| #define FREE_CAPS(caps) g_slice_free (GstCaps, caps) |
| #else |
| #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, |
| GValue * dest_value); |
| static gboolean gst_caps_from_string_inplace (GstCaps * caps, |
| const gchar * string); |
| static GstCaps *gst_caps_copy_conditional (GstCaps * src); |
| |
| GType |
| gst_caps_get_type (void) |
| { |
| static GType gst_caps_type = 0; |
| |
| if (G_UNLIKELY (gst_caps_type == 0)) { |
| gst_caps_type = g_boxed_type_register_static ("GstCaps", |
| (GBoxedCopyFunc) gst_caps_copy_conditional, |
| (GBoxedFreeFunc) gst_caps_unref); |
| |
| g_value_register_transform_func (gst_caps_type, |
| G_TYPE_STRING, gst_caps_transform_to_string); |
| } |
| |
| return gst_caps_type; |
| } |
| |
| /* creation/deletion */ |
| |
| /** |
| * gst_caps_new_empty: |
| * |
| * Creates a new #GstCaps that is empty. That is, the returned |
| * #GstCaps contains no media formats. |
| * Caller is responsible for unreffing the returned caps. |
| * |
| * Returns: the new #GstCaps |
| */ |
| GstCaps * |
| gst_caps_new_empty (void) |
| { |
| GstCaps *caps = ALLOC_CAPS (); |
| |
| caps->type = GST_TYPE_CAPS; |
| caps->refcount = 1; |
| caps->flags = 0; |
| caps->structs = g_ptr_array_new (); |
| |
| #ifdef DEBUG_REFCOUNT |
| GST_CAT_LOG (GST_CAT_CAPS, "created caps %p", caps); |
| #endif |
| |
| return caps; |
| } |
| |
| /** |
| * gst_caps_new_any: |
| * |
| * Creates a new #GstCaps that indicates that it is compatible with |
| * any media format. |
| * |
| * Returns: the new #GstCaps |
| */ |
| GstCaps * |
| gst_caps_new_any (void) |
| { |
| GstCaps *caps = gst_caps_new_empty (); |
| |
| caps->flags = GST_CAPS_FLAGS_ANY; |
| |
| return caps; |
| } |
| |
| /** |
| * gst_caps_new_simple: |
| * @media_type: the media type of the structure |
| * @fieldname: first field to set |
| * @...: additional arguments |
| * |
| * Creates a new #GstCaps that contains one #GstStructure. The |
| * structure is defined by the arguments, which have the same format |
| * as gst_structure_new(). |
| * Caller is responsible for unreffing the returned caps. |
| * |
| * Returns: the new #GstCaps |
| */ |
| GstCaps * |
| gst_caps_new_simple (const char *media_type, const char *fieldname, ...) |
| { |
| GstCaps *caps; |
| GstStructure *structure; |
| va_list var_args; |
| |
| caps = gst_caps_new_empty (); |
| |
| va_start (var_args, fieldname); |
| structure = gst_structure_new_valist (media_type, fieldname, var_args); |
| va_end (var_args); |
| |
| gst_caps_append_structure (caps, structure); |
| |
| return caps; |
| } |
| |
| /** |
| * gst_caps_new_full: |
| * @struct1: the first structure to add |
| * @...: additional structures to add |
| * |
| * Creates a new #GstCaps and adds all the structures listed as |
| * arguments. The list must be NULL-terminated. The structures |
| * are not copied; the returned #GstCaps owns the structures. |
| * |
| * Returns: the new #GstCaps |
| */ |
| GstCaps * |
| gst_caps_new_full (GstStructure * struct1, ...) |
| { |
| GstCaps *caps; |
| va_list var_args; |
| |
| va_start (var_args, struct1); |
| caps = gst_caps_new_full_valist (struct1, var_args); |
| va_end (var_args); |
| |
| return caps; |
| } |
| |
| /** |
| * gst_caps_new_full_valist: |
| * @structure: the first structure to add |
| * @var_args: additional structures to add |
| * |
| * Creates a new #GstCaps and adds all the structures listed as |
| * arguments. The list must be NULL-terminated. The structures |
| * are not copied; the returned #GstCaps owns the structures. |
| * |
| * Returns: the new #GstCaps |
| */ |
| GstCaps * |
| gst_caps_new_full_valist (GstStructure * structure, va_list var_args) |
| { |
| GstCaps *caps; |
| |
| caps = gst_caps_new_empty (); |
| |
| while (structure) { |
| gst_caps_append_structure (caps, structure); |
| structure = va_arg (var_args, GstStructure *); |
| } |
| |
| return caps; |
| } |
| |
| /** |
| * gst_caps_copy: |
| * @caps: the #GstCaps to copy |
| * |
| * Creates a new #GstCaps as a copy of the old @caps. The new caps will have a |
| * refcount of 1, owned by the caller. The structures are copied as well. |
| * |
| * Note that this function is the semantic equivalent of a gst_caps_ref() |
| * followed by a gst_caps_make_writable(). If you only want to hold on to a |
| * reference to the data, you should use gst_caps_ref(). |
| * |
| * When you are finished with the caps, call gst_caps_unref() on it. |
| * |
| * Returns: the new #GstCaps |
| */ |
| GstCaps * |
| gst_caps_copy (const GstCaps * caps) |
| { |
| GstCaps *newcaps; |
| GstStructure *structure; |
| guint i; |
| |
| g_return_val_if_fail (GST_IS_CAPS (caps), NULL); |
| |
| newcaps = gst_caps_new_empty (); |
| newcaps->flags = caps->flags; |
| |
| for (i = 0; i < caps->structs->len; i++) { |
| structure = gst_caps_get_structure (caps, i); |
| gst_caps_append_structure (newcaps, gst_structure_copy (structure)); |
| } |
| |
| return newcaps; |
| } |
| |
| static void |
| _gst_caps_free (GstCaps * caps) |
| { |
| GstStructure *structure; |
| guint i; |
| |
| /* The refcount must be 0, but since we're only called by gst_caps_unref, |
| * don't bother testing. */ |
| |
| for (i = 0; i < caps->structs->len; i++) { |
| structure = (GstStructure *) gst_caps_get_structure (caps, i); |
| gst_structure_set_parent_refcount (structure, NULL); |
| gst_structure_free (structure); |
| } |
| g_ptr_array_free (caps->structs, TRUE); |
| #ifdef USE_POISONING |
| memset (caps, 0xff, sizeof (GstCaps)); |
| #endif |
| |
| #ifdef DEBUG_REFCOUNT |
| GST_CAT_LOG (GST_CAT_CAPS, "freeing caps %p", caps); |
| #endif |
| FREE_CAPS (caps); |
| } |
| |
| /** |
| * gst_caps_make_writable: |
| * @caps: the #GstCaps to make writable |
| * |
| * Returns a writable copy of @caps. |
| * |
| * If there is only one reference count on @caps, the caller must be the owner, |
| * and so this function will return the caps object unchanged. If on the other |
| * hand there is more than one reference on the object, a new caps object will |
| * be returned. The caller's reference on @caps will be removed, and instead the |
| * caller will own a reference to the returned object. |
| * |
| * In short, this function unrefs the caps in the argument and refs the caps |
| * that it returns. Don't access the argument after calling this function. See |
| * also: gst_caps_ref(). |
| * |
| * Returns: the same #GstCaps object. |
| */ |
| GstCaps * |
| gst_caps_make_writable (GstCaps * caps) |
| { |
| GstCaps *copy; |
| |
| g_return_val_if_fail (caps != NULL, NULL); |
| |
| /* we are the only instance reffing this caps */ |
| if (g_atomic_int_get (&caps->refcount) == 1) |
| return caps; |
| |
| /* else copy */ |
| copy = gst_caps_copy (caps); |
| gst_caps_unref (caps); |
| |
| return copy; |
| } |
| |
| /** |
| * gst_caps_ref: |
| * @caps: the #GstCaps to reference |
| * |
| * Add a reference to a #GstCaps object. |
| * |
| * From this point on, until the caller calls gst_caps_unref() or |
| * gst_caps_make_writable(), it is guaranteed that the caps object will not |
| * change. This means its structures won't change, etc. To use a #GstCaps |
| * object, you must always have a refcount on it -- either the one made |
| * implicitly by gst_caps_new(), or via taking one explicitly with this |
| * function. |
| * |
| * Returns: the same #GstCaps object. |
| */ |
| GstCaps * |
| gst_caps_ref (GstCaps * caps) |
| { |
| g_return_val_if_fail (caps != NULL, NULL); |
| |
| #ifdef DEBUG_REFCOUNT |
| GST_CAT_LOG (GST_CAT_REFCOUNTING, "%p %d->%d", caps, |
| GST_CAPS_REFCOUNT_VALUE (caps), GST_CAPS_REFCOUNT_VALUE (caps) + 1); |
| #endif |
| g_return_val_if_fail (GST_CAPS_REFCOUNT_VALUE (caps) > 0, NULL); |
| |
| g_atomic_int_inc (&caps->refcount); |
| |
| return caps; |
| } |
| |
| /** |
| * gst_caps_unref: |
| * @caps: the #GstCaps to unref |
| * |
| * Unref a #GstCaps and and free all its structures and the |
| * structures' values when the refcount reaches 0. |
| */ |
| void |
| gst_caps_unref (GstCaps * caps) |
| { |
| g_return_if_fail (caps != NULL); |
| |
| #ifdef DEBUG_REFCOUNT |
| GST_CAT_LOG (GST_CAT_REFCOUNTING, "%p %d->%d", caps, |
| GST_CAPS_REFCOUNT_VALUE (caps), GST_CAPS_REFCOUNT_VALUE (caps) - 1); |
| #endif |
| |
| g_return_if_fail (GST_CAPS_REFCOUNT_VALUE (caps) > 0); |
| |
| /* if we ended up with the refcount at zero, free the caps */ |
| if (G_UNLIKELY (g_atomic_int_dec_and_test (&caps->refcount))) |
| _gst_caps_free (caps); |
| } |
| |
| GType |
| gst_static_caps_get_type (void) |
| { |
| static GType staticcaps_type = 0; |
| |
| if (G_UNLIKELY (staticcaps_type == 0)) { |
| staticcaps_type = g_pointer_type_register_static ("GstStaticCaps"); |
| } |
| return staticcaps_type; |
| } |
| |
| |
| /** |
| * gst_static_caps_get: |
| * @static_caps: the #GstStaticCaps to convert |
| * |
| * Converts a #GstStaticCaps to a #GstCaps. |
| * |
| * Returns: A pointer to the #GstCaps. Unref after usage. Since the |
| * core holds an additional ref to the returned caps, |
| * use gst_caps_make_writable() on the returned caps to modify it. |
| */ |
| GstCaps * |
| gst_static_caps_get (GstStaticCaps * static_caps) |
| { |
| GstCaps *caps; |
| |
| g_return_val_if_fail (static_caps != NULL, NULL); |
| |
| caps = (GstCaps *) static_caps; |
| |
| /* refcount is 0 when we need to convert */ |
| if (G_UNLIKELY (g_atomic_int_get (&caps->refcount) == 0)) { |
| const char *string; |
| GstCaps temp; |
| |
| G_LOCK (static_caps_lock); |
| /* check if other thread already updated */ |
| if (G_UNLIKELY (g_atomic_int_get (&caps->refcount) > 0)) |
| goto done; |
| |
| string = static_caps->string; |
| |
| if (G_UNLIKELY (string == NULL)) |
| goto no_string; |
| |
| GST_CAT_LOG (GST_CAT_CAPS, "creating %p", static_caps); |
| |
| /* we construct the caps on the stack, then copy over the struct into our |
| * real caps, refcount last. We do this because we must leave the refcount |
| * of the result caps to 0 so that other threads don't run away with the |
| * caps while we are constructing it. */ |
| temp.type = GST_TYPE_CAPS; |
| 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); |
| |
| /* 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); |
| |
| GST_CAT_LOG (GST_CAT_CAPS, "created %p", static_caps); |
| done: |
| G_UNLOCK (static_caps_lock); |
| } |
| /* ref the caps, makes it not writable */ |
| gst_caps_ref (caps); |
| |
| return caps; |
| |
| /* ERRORS */ |
| no_string: |
| { |
| G_UNLOCK (static_caps_lock); |
| g_warning ("static caps %p string is NULL", static_caps); |
| return NULL; |
| } |
| } |
| |
| /* manipulation */ |
| static GstStructure * |
| gst_caps_remove_and_get_structure (GstCaps * caps, guint idx) |
| { |
| /* don't use index_fast, gst_caps_do_simplify relies on the order */ |
| GstStructure *s = g_ptr_array_remove_index (caps->structs, idx); |
| |
| gst_structure_set_parent_refcount (s, NULL); |
| return s; |
| } |
| |
| static gboolean |
| gst_structure_is_equal_foreach (GQuark field_id, const GValue * val2, |
| gpointer data) |
| { |
| GstStructure *struct1 = (GstStructure *) data; |
| const GValue *val1 = gst_structure_id_get_value (struct1, field_id); |
| |
| if (val1 == NULL) |
| return FALSE; |
| if (gst_value_compare (val1, val2) == GST_VALUE_EQUAL) { |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| static gboolean |
| gst_caps_structure_is_subset_field (GQuark field_id, const GValue * value, |
| gpointer user_data) |
| { |
| GstStructure *subtract_from = user_data; |
| GValue subtraction = { 0, }; |
| const GValue *other; |
| gint res; |
| |
| other = gst_structure_id_get_value (subtract_from, field_id); |
| if (!other) { |
| /* field is missing in one set */ |
| return FALSE; |
| } |
| /* |
| * [1,2] - 1 = 2 |
| * 1 - [1,2] = ??? |
| */ |
| if (!gst_value_subtract (&subtraction, other, value)) { |
| /* empty result -> values are the same, or first was a value and |
| * second was a list |
| * verify that result is empty by swapping args */ |
| if (!gst_value_subtract (&subtraction, value, other)) { |
| return TRUE; |
| } |
| g_value_unset (&subtraction); |
| 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) |
| { |
| if ((minuend->name != subtrahend->name) || |
| (gst_structure_n_fields (minuend) != |
| gst_structure_n_fields (subtrahend))) { |
| return FALSE; |
| } |
| |
| return gst_structure_foreach ((GstStructure *) subtrahend, |
| gst_caps_structure_is_subset_field, (gpointer) minuend); |
| } |
| |
| /** |
| * gst_caps_append: |
| * @caps1: the #GstCaps that will be appended to |
| * @caps2: the #GstCaps to append |
| * |
| * Appends the structures contained in @caps2 to @caps1. The structures in |
| * @caps2 are not copied -- they are transferred to @caps1, and then @caps2 is |
| * freed. If either caps is ANY, the resulting caps will be ANY. |
| */ |
| void |
| gst_caps_append (GstCaps * caps1, GstCaps * caps2) |
| { |
| GstStructure *structure; |
| int i; |
| |
| g_return_if_fail (GST_IS_CAPS (caps1)); |
| g_return_if_fail (GST_IS_CAPS (caps2)); |
| g_return_if_fail (IS_WRITABLE (caps1)); |
| 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)) { |
| /* 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 = 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 */ |
| } |
| |
| /** |
| * gst_caps_merge: |
| * @caps1: the #GstCaps that will take the new entries |
| * @caps2: the #GstCaps to merge in |
| * |
| * Appends the structures contained in @caps2 to @caps1 if they are not yet |
| * expressed by @caps1. The structures in @caps2 are not copied -- they are |
| * transferred to @caps1, and then @caps2 is freed. |
| * If either caps is ANY, the resulting caps will be ANY. |
| * |
| * Since: 0.10.10 |
| */ |
| void |
| gst_caps_merge (GstCaps * caps1, GstCaps * caps2) |
| { |
| GstStructure *structure; |
| int i; |
| |
| g_return_if_fail (GST_IS_CAPS (caps1)); |
| g_return_if_fail (GST_IS_CAPS (caps2)); |
| g_return_if_fail (IS_WRITABLE (caps1)); |
| g_return_if_fail (IS_WRITABLE (caps2)); |
| |
| #ifdef USE_POISONING |
| CAPS_POISON (caps2); |
| #endif |
| if (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)) { |
| 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 = 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); |
| GstCaps *add = gst_caps_subtract (caps2, com); |
| |
| GST_DEBUG ("common : %d", gst_caps_get_size (com)); |
| GST_DEBUG ("adding : %d", gst_caps_get_size (add)); |
| gst_caps_append (caps1, add); |
| gst_caps_unref (com); |
| */ |
| } |
| gst_caps_unref (caps2); /* guaranteed to free it */ |
| } |
| |
| /** |
| * gst_caps_append_structure: |
| * @caps: the #GstCaps that will be appended to |
| * @structure: the #GstStructure to append |
| * |
| * Appends @structure to @caps. The structure is not copied; @caps |
| * becomes the owner of @structure. |
| */ |
| void |
| gst_caps_append_structure (GstCaps * caps, GstStructure * structure) |
| { |
| g_return_if_fail (GST_IS_CAPS (caps)); |
| g_return_if_fail (IS_WRITABLE (caps)); |
| |
| if (G_LIKELY (structure)) { |
| g_return_if_fail (structure->parent_refcount == NULL); |
| #if 0 |
| #ifdef USE_POISONING |
| STRUCTURE_POISON (structure); |
| #endif |
| #endif |
| gst_structure_set_parent_refcount (structure, &caps->refcount); |
| g_ptr_array_add (caps->structs, structure); |
| } |
| } |
| |
| /** |
| * gst_caps_remove_structure: |
| * @caps: the #GstCaps to remove from |
| * @idx: Index of the structure to remove |
| * |
| * removes the stucture with the given index from the list of structures |
| * contained in @caps. |
| */ |
| void |
| gst_caps_remove_structure (GstCaps * caps, guint idx) |
| { |
| GstStructure *structure; |
| |
| g_return_if_fail (caps != NULL); |
| g_return_if_fail (idx <= gst_caps_get_size (caps)); |
| g_return_if_fail (IS_WRITABLE (caps)); |
| |
| structure = gst_caps_remove_and_get_structure (caps, idx); |
| gst_structure_free (structure); |
| } |
| |
| /** |
| * gst_caps_merge_structure: |
| * @caps: the #GstCaps that will the the new structure |
| * @structure: the #GstStructure to merge |
| * |
| * Appends @structure to @caps if its not already expressed by @caps. The |
| * structure is not copied; @caps becomes the owner of @structure. |
| */ |
| void |
| gst_caps_merge_structure (GstCaps * caps, GstStructure * structure) |
| { |
| g_return_if_fail (GST_IS_CAPS (caps)); |
| g_return_if_fail (IS_WRITABLE (caps)); |
| |
| if (G_LIKELY (structure)) { |
| GstStructure *structure1; |
| int i; |
| gboolean unique = TRUE; |
| |
| g_return_if_fail (structure->parent_refcount == NULL); |
| #if 0 |
| #ifdef USE_POISONING |
| STRUCTURE_POISON (structure); |
| #endif |
| #endif |
| /* check each structure */ |
| for (i = caps->structs->len - 1; i >= 0; i--) { |
| structure1 = gst_caps_get_structure (caps, i); |
| /* if structure is a subset of structure1, then skip it */ |
| if (gst_caps_structure_is_subset (structure1, structure)) { |
| unique = FALSE; |
| break; |
| } |
| } |
| if (unique) { |
| gst_structure_set_parent_refcount (structure, &caps->refcount); |
| g_ptr_array_add (caps->structs, structure); |
| } else { |
| gst_structure_free (structure); |
| } |
| } |
| } |
| |
| |
| /** |
| * gst_caps_get_size: |
| * @caps: a #GstCaps |
| * |
| * Gets the number of structures contained in @caps. |
| * |
| * Returns: the number of structures that @caps contains |
| */ |
| guint |
| gst_caps_get_size (const GstCaps * caps) |
| { |
| g_return_val_if_fail (GST_IS_CAPS (caps), 0); |
| |
| return caps->structs->len; |
| } |
| |
| /** |
| * gst_caps_get_structure: |
| * @caps: a #GstCaps |
| * @index: the index of the structure |
| * |
| * Finds the structure in @caps that has the index @index, and |
| * 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. |
| * |
| * Returns: a pointer to the #GstStructure corresponding to @index |
| */ |
| GstStructure * |
| 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); |
| } |
| |
| /** |
| * gst_caps_copy_nth: |
| * @caps: the #GstCaps to copy |
| * @nth: the nth structure to copy |
| * |
| * Creates a new #GstCaps and appends a copy of the nth structure |
| * contained in @caps. |
| * |
| * Returns: the new #GstCaps |
| */ |
| GstCaps * |
| gst_caps_copy_nth (const GstCaps * caps, guint nth) |
| { |
| GstCaps *newcaps; |
| GstStructure *structure; |
| |
| g_return_val_if_fail (GST_IS_CAPS (caps), NULL); |
| |
| newcaps = gst_caps_new_empty (); |
| newcaps->flags = caps->flags; |
| |
| if (caps->structs->len > nth) { |
| structure = gst_caps_get_structure (caps, nth); |
| gst_caps_append_structure (newcaps, gst_structure_copy (structure)); |
| } |
| |
| return newcaps; |
| } |
| |
| /** |
| * gst_caps_truncate: |
| * @caps: the #GstCaps to truncate |
| * |
| * Destructively discard all but the first structure from @caps. Useful when |
| * fixating. @caps must be writable. |
| */ |
| void |
| gst_caps_truncate (GstCaps * caps) |
| { |
| gint i; |
| |
| g_return_if_fail (GST_IS_CAPS (caps)); |
| g_return_if_fail (IS_WRITABLE (caps)); |
| |
| i = caps->structs->len - 1; |
| |
| while (i > 0) |
| gst_caps_remove_structure (caps, i--); |
| } |
| |
| /** |
| * gst_caps_set_simple: |
| * @caps: the #GstCaps to set |
| * @field: first field to set |
| * @...: additional parameters |
| * |
| * Sets fields in a simple #GstCaps. A simple #GstCaps is one that |
| * only has one structure. The arguments must be passed in the same |
| * manner as gst_structure_set(), and be NULL-terminated. |
| */ |
| void |
| gst_caps_set_simple (GstCaps * caps, 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); |
| |
| va_start (var_args, field); |
| gst_structure_set_valist (structure, field, var_args); |
| va_end (var_args); |
| } |
| |
| /** |
| * gst_caps_set_simple_valist: |
| * @caps: the #GstCaps to copy |
| * @field: first field to set |
| * @varargs: additional parameters |
| * |
| * Sets fields in a simple #GstCaps. A simple #GstCaps is one that |
| * only has one structure. The arguments must be passed in the same |
| * manner as gst_structure_set(), and be NULL-terminated. |
| */ |
| void |
| gst_caps_set_simple_valist (GstCaps * caps, 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); |
| |
| gst_structure_set_valist (structure, field, varargs); |
| } |
| |
| /* tests */ |
| |
| /** |
| * gst_caps_is_any: |
| * @caps: the #GstCaps to test |
| * |
| * Determines if @caps represents any media format. |
| * |
| * Returns: TRUE if @caps represents any format. |
| */ |
| gboolean |
| gst_caps_is_any (const GstCaps * caps) |
| { |
| g_return_val_if_fail (GST_IS_CAPS (caps), FALSE); |
| |
| return (caps->flags & GST_CAPS_FLAGS_ANY); |
| } |
| |
| /** |
| * gst_caps_is_empty: |
| * @caps: the #GstCaps to test |
| * |
| * Determines if @caps represents no media formats. |
| * |
| * Returns: TRUE if @caps represents no formats. |
| */ |
| gboolean |
| gst_caps_is_empty (const GstCaps * caps) |
| { |
| g_return_val_if_fail (GST_IS_CAPS (caps), FALSE); |
| |
| if (caps->flags & GST_CAPS_FLAGS_ANY) |
| return FALSE; |
| |
| return (caps->structs == NULL) || (caps->structs->len == 0); |
| } |
| |
| static gboolean |
| gst_caps_is_fixed_foreach (GQuark field_id, const GValue * value, |
| gpointer unused) |
| { |
| return gst_value_is_fixed (value); |
| } |
| |
| /** |
| * gst_caps_is_fixed: |
| * @caps: the #GstCaps to test |
| * |
| * Fixed #GstCaps describe exactly one format, that is, they have exactly |
| * one structure, and each field in the structure describes a fixed type. |
| * Examples of non-fixed types are GST_TYPE_INT_RANGE and GST_TYPE_LIST. |
| * |
| * Returns: TRUE if @caps is fixed |
| */ |
| gboolean |
| gst_caps_is_fixed (const GstCaps * caps) |
| { |
| GstStructure *structure; |
| |
| g_return_val_if_fail (GST_IS_CAPS (caps), FALSE); |
| |
| if (caps->structs->len != 1) |
| return FALSE; |
| |
| structure = gst_caps_get_structure (caps, 0); |
| |
| return gst_structure_foreach (structure, gst_caps_is_fixed_foreach, NULL); |
| } |
| |
| /** |
| * gst_caps_is_equal_fixed: |
| * @caps1: the #GstCaps to test |
| * @caps2: the #GstCaps to test |
| * |
| * Tests if two #GstCaps are equal. This function only works on fixed |
| * #GstCaps. |
| * |
| * Returns: TRUE if the arguments represent the same format |
| */ |
| gboolean |
| gst_caps_is_equal_fixed (const GstCaps * caps1, const GstCaps * caps2) |
| { |
| 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); |
| struct2 = gst_caps_get_structure (caps2, 0); |
| |
| if (struct1->name != struct2->name) { |
| return FALSE; |
| } |
| if (struct1->fields->len != struct2->fields->len) { |
| return FALSE; |
| } |
| |
| return gst_structure_foreach (struct1, gst_structure_is_equal_foreach, |
| struct2); |
| } |
| |
| /** |
| * gst_caps_is_always_compatible: |
| * @caps1: the #GstCaps to test |
| * @caps2: the #GstCaps to test |
| * |
| * A given #GstCaps structure is always compatible with another if |
| * every media format that is in the first is also contained in the |
| * second. That is, @caps1 is a subset of @caps2. |
| * |
| * Returns: TRUE if @caps1 is a subset of @caps2. |
| */ |
| gboolean |
| gst_caps_is_always_compatible (const GstCaps * caps1, const GstCaps * caps2) |
| { |
| g_return_val_if_fail (GST_IS_CAPS (caps1), FALSE); |
| g_return_val_if_fail (GST_IS_CAPS (caps2), FALSE); |
| |
| return gst_caps_is_subset (caps1, caps2); |
| } |
| |
| /** |
| * gst_caps_is_subset: |
| * @subset: a #GstCaps |
| * @superset: a potentially greater #GstCaps |
| * |
| * Checks if all caps represented by @subset are also represented by @superset. |
| * <note>This function does not work reliably if optional properties for caps |
| * are included on one caps and omitted on the other.</note> |
| * |
| * Returns: %TRUE if @subset is a subset of @superset |
| */ |
| gboolean |
| gst_caps_is_subset (const GstCaps * subset, const GstCaps * superset) |
| { |
| GstCaps *caps; |
| gboolean ret; |
| |
| g_return_val_if_fail (subset != NULL, FALSE); |
| g_return_val_if_fail (superset != NULL, FALSE); |
| |
| if (gst_caps_is_empty (subset) || gst_caps_is_any (superset)) |
| return TRUE; |
| if (gst_caps_is_any (subset) || gst_caps_is_empty (superset)) |
| return FALSE; |
| |
| caps = gst_caps_subtract (subset, superset); |
| ret = gst_caps_is_empty (caps); |
| gst_caps_unref (caps); |
| return ret; |
| } |
| |
| /** |
| * gst_caps_is_equal: |
| * @caps1: a #GstCaps |
| * @caps2: another #GstCaps |
| * |
| * Checks if the given caps represent the same set of caps. |
| * <note>This function does not work reliably if optional properties for caps |
| * are included on one caps and omitted on the other.</note> |
| * |
| * This function deals correctly with passing NULL for any of the caps. |
| * |
| * Returns: TRUE if both caps are equal. |
| */ |
| gboolean |
| gst_caps_is_equal (const GstCaps * caps1, const GstCaps * caps2) |
| { |
| /* NULL <-> NULL is allowed here */ |
| if (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) |
| return FALSE; |
| |
| if (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); |
| } |
| |
| typedef struct |
| { |
| GstStructure *dest; |
| const GstStructure *intersect; |
| gboolean first_run; |
| } |
| IntersectData; |
| |
| static gboolean |
| gst_caps_structure_intersect_field (GQuark id, const GValue * val1, |
| gpointer data) |
| { |
| IntersectData *idata = (IntersectData *) data; |
| GValue dest_value = { 0 }; |
| const GValue *val2 = gst_structure_id_get_value (idata->intersect, id); |
| |
| if (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); |
| } else { |
| return FALSE; |
| } |
| } |
| |
| return TRUE; |
| } |
| |
| static GstStructure * |
| gst_caps_structure_intersect (const GstStructure * struct1, |
| const GstStructure * struct2) |
| { |
| IntersectData data; |
| |
| g_return_val_if_fail (struct1 != NULL, NULL); |
| g_return_val_if_fail (struct2 != NULL, NULL); |
| |
| if (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, |
| gst_caps_structure_intersect_field, &data)) |
| goto error; |
| |
| data.intersect = struct1; |
| data.first_run = FALSE; |
| if (!gst_structure_foreach ((GstStructure *) struct2, |
| gst_caps_structure_intersect_field, &data)) |
| goto error; |
| |
| return data.dest; |
| |
| error: |
| gst_structure_free (data.dest); |
| return NULL; |
| } |
| |
| #if 0 |
| static GstStructure * |
| gst_caps_structure_union (const GstStructure * struct1, |
| const GstStructure * struct2) |
| { |
| int i; |
| GstStructure *dest; |
| const GstStructureField *field1; |
| const GstStructureField *field2; |
| int ret; |
| |
| /* FIXME this doesn't actually work */ |
| |
| if (struct1->name != struct2->name) |
| return NULL; |
| |
| dest = gst_structure_id_empty_new (struct1->name); |
| |
| for (i = 0; i < struct1->fields->len; i++) { |
| GValue dest_value = { 0 }; |
| |
| field1 = GST_STRUCTURE_FIELD (struct1, i); |
| field2 = gst_structure_id_get_field (struct2, field1->name); |
| |
| if (field2 == NULL) { |
| continue; |
| } else { |
| if (gst_value_union (&dest_value, &field1->value, &field2->value)) { |
| gst_structure_set_value (dest, g_quark_to_string (field1->name), |
| &dest_value); |
| } else { |
| ret = gst_value_compare (&field1->value, &field2->value); |
| } |
| } |
| } |
| |
| return dest; |
| } |
| #endif |
| |
| /* operations */ |
| |
| /** |
| * gst_caps_intersect: |
| * @caps1: a #GstCaps to intersect |
| * @caps2: a #GstCaps to intersect |
| * |
| * Creates a new #GstCaps that contains all the formats that are common |
| * to both @caps1 and @caps2. |
| * |
| * Returns: the new #GstCaps |
| */ |
| GstCaps * |
| gst_caps_intersect (const GstCaps * caps1, const GstCaps * caps2) |
| { |
| guint64 i; /* index can be up to 2 * G_MAX_UINT */ |
| guint j, k; |
| |
| 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) |
| return gst_caps_copy (caps1); |
| |
| /* empty caps on either side, return empty */ |
| if (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)) |
| return gst_caps_copy (caps2); |
| if (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 |
| * much better than a simple loop. |
| * |
| * This algorithm zigzags over the caps structures as demonstrated in |
| * the folowing matrix: |
| * |
| * caps1 |
| * +------------- |
| * | 1 2 4 7 |
| * caps2 | 3 5 8 10 |
| * | 6 9 11 12 |
| * |
| * 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++) { |
| /* caps1 index goes from 0 to caps1->structs->len-1 */ |
| j = MIN (i, caps1->structs->len - 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) { |
| struct1 = gst_caps_get_structure (caps1, j); |
| struct2 = gst_caps_get_structure (caps2, k); |
| |
| istruct = gst_caps_structure_intersect (struct1, struct2); |
| |
| gst_caps_append_structure (dest, istruct); |
| /* move down left */ |
| k++; |
| if (j == 0) |
| break; /* so we don't roll back to G_MAXUINT */ |
| j--; |
| } |
| } |
| return dest; |
| } |
| |
| typedef struct |
| { |
| const GstStructure *subtract_from; |
| GSList *put_into; |
| } |
| SubtractionEntry; |
| |
| |
| static gboolean |
| gst_caps_structure_subtract_field (GQuark field_id, const GValue * value, |
| gpointer user_data) |
| { |
| SubtractionEntry *e = user_data; |
| GValue subtraction = { 0, }; |
| const GValue *other; |
| GstStructure *structure; |
| |
| other = gst_structure_id_get_value (e->subtract_from, field_id); |
| if (!other) { |
| return FALSE; |
| } |
| if (!gst_value_subtract (&subtraction, other, value)) |
| return TRUE; |
| if (gst_value_compare (&subtraction, other) == GST_VALUE_EQUAL) { |
| g_value_unset (&subtraction); |
| return FALSE; |
| } else { |
| structure = gst_structure_copy (e->subtract_from); |
| gst_structure_id_set_value (structure, field_id, &subtraction); |
| g_value_unset (&subtraction); |
| e->put_into = g_slist_prepend (e->put_into, structure); |
| return TRUE; |
| } |
| } |
| |
| static gboolean |
| gst_caps_structure_subtract (GSList ** into, const GstStructure * minuend, |
| const GstStructure * subtrahend) |
| { |
| SubtractionEntry e; |
| gboolean ret; |
| |
| e.subtract_from = minuend; |
| e.put_into = NULL; |
| |
| ret = gst_structure_foreach ((GstStructure *) subtrahend, |
| gst_caps_structure_subtract_field, &e); |
| if (ret) { |
| *into = e.put_into; |
| } else { |
| GSList *walk; |
| |
| for (walk = e.put_into; walk; walk = g_slist_next (walk)) { |
| gst_structure_free (walk->data); |
| } |
| g_slist_free (e.put_into); |
| } |
| return ret; |
| } |
| |
| /** |
| * gst_caps_subtract: |
| * @minuend: #GstCaps to substract from |
| * @subtrahend: #GstCaps to substract |
| * |
| * Subtracts the @subtrahend from the @minuend. |
| * <note>This function does not work reliably if optional properties for caps |
| * are included on one caps and omitted on the other.</note> |
| * |
| * Returns: the resulting caps |
| */ |
| GstCaps * |
| gst_caps_subtract (const GstCaps * minuend, const GstCaps * subtrahend) |
| { |
| guint i, j; |
| GstStructure *min; |
| GstStructure *sub; |
| GstCaps *dest = NULL, *src; |
| |
| g_return_val_if_fail (minuend != NULL, NULL); |
| g_return_val_if_fail (subtrahend != NULL, NULL); |
| |
| if (gst_caps_is_empty (minuend) || gst_caps_is_any (subtrahend)) { |
| return gst_caps_new_empty (); |
| } |
| if (gst_caps_is_empty (subtrahend)) |
| return gst_caps_copy (minuend); |
| |
| /* FIXME: Do we want this here or above? |
| 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); |
| |
| src = gst_caps_copy (minuend); |
| for (i = 0; i < subtrahend->structs->len; i++) { |
| sub = gst_caps_get_structure (subtrahend, i); |
| if (dest) { |
| gst_caps_unref (src); |
| src = dest; |
| } |
| dest = gst_caps_new_empty (); |
| for (j = 0; j < src->structs->len; j++) { |
| min = gst_caps_get_structure (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; |
| |
| for (walk = list; walk; walk = g_slist_next (walk)) { |
| gst_caps_append_structure (dest, (GstStructure *) walk->data); |
| } |
| g_slist_free (list); |
| } else { |
| gst_caps_append_structure (dest, gst_structure_copy (min)); |
| } |
| } else { |
| gst_caps_append_structure (dest, gst_structure_copy (min)); |
| } |
| } |
| if (gst_caps_is_empty (dest)) { |
| gst_caps_unref (src); |
| return dest; |
| } |
| } |
| |
| gst_caps_unref (src); |
| gst_caps_do_simplify (dest); |
| return dest; |
| } |
| |
| /** |
| * gst_caps_union: |
| * @caps1: a #GstCaps to union |
| * @caps2: a #GstCaps to union |
| * |
| * Creates a new #GstCaps that contains all the formats that are in |
| * either @caps1 and @caps2. |
| * |
| * Returns: the new #GstCaps |
| */ |
| GstCaps * |
| gst_caps_union (const GstCaps * caps1, const GstCaps * caps2) |
| { |
| GstCaps *dest1; |
| GstCaps *dest2; |
| |
| 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); |
| gst_caps_append (dest1, dest2); |
| |
| gst_caps_do_simplify (dest1); |
| return dest1; |
| } |
| |
| typedef struct _NormalizeForeach |
| { |
| GstCaps *caps; |
| GstStructure *structure; |
| } |
| NormalizeForeach; |
| |
| static gboolean |
| gst_caps_normalize_foreach (GQuark field_id, const GValue * value, gpointer ptr) |
| { |
| 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++) { |
| 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); |
| } |
| |
| gst_value_init_and_copy (&val, gst_value_list_get_value (value, 0)); |
| gst_structure_id_set_value (nf->structure, field_id, &val); |
| g_value_unset (&val); |
| |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| /** |
| * gst_caps_normalize: |
| * @caps: a #GstCaps to normalize |
| * |
| * Creates a new #GstCaps that represents the same set of formats as |
| * @caps, but contains no lists. Each list is expanded into separate |
| * @GstStructures. |
| * |
| * Returns: the new #GstCaps |
| */ |
| GstCaps * |
| gst_caps_normalize (const GstCaps * caps) |
| { |
| NormalizeForeach nf; |
| GstCaps *newcaps; |
| guint i; |
| |
| g_return_val_if_fail (GST_IS_CAPS (caps), NULL); |
| |
| newcaps = gst_caps_copy (caps); |
| nf.caps = newcaps; |
| |
| for (i = 0; i < newcaps->structs->len; i++) { |
| nf.structure = gst_caps_get_structure (newcaps, i); |
| |
| while (!gst_structure_foreach (nf.structure, |
| gst_caps_normalize_foreach, &nf)); |
| } |
| |
| return newcaps; |
| } |
| |
| static gint |
| gst_caps_compare_structures (gconstpointer one, gconstpointer two) |
| { |
| gint ret; |
| const GstStructure *struct1 = *((const GstStructure **) one); |
| const GstStructure *struct2 = *((const GstStructure **) two); |
| |
| /* FIXME: this orders alphabetically, but ordering the quarks might be faster |
| So what's the best way? */ |
| ret = strcmp (gst_structure_get_name (struct1), |
| gst_structure_get_name (struct2)); |
| if (ret) |
| return ret; |
| |
| return gst_structure_n_fields (struct2) - gst_structure_n_fields (struct1); |
| } |
| |
| typedef struct |
| { |
| GQuark name; |
| GValue value; |
| GstStructure *compare; |
| } |
| UnionField; |
| |
| static gboolean |
| gst_caps_structure_figure_out_union (GQuark field_id, const GValue * value, |
| gpointer user_data) |
| { |
| UnionField *u = user_data; |
| const GValue *val = gst_structure_id_get_value (u->compare, field_id); |
| |
| if (!val) { |
| if (u->name) |
| g_value_unset (&u->value); |
| return FALSE; |
| } |
| if (gst_value_compare (val, value) == GST_VALUE_EQUAL) |
| return TRUE; |
| if (u->name) { |
| g_value_unset (&u->value); |
| return FALSE; |
| } |
| u->name = field_id; |
| gst_value_union (&u->value, val, value); |
| return TRUE; |
| } |
| |
| static gboolean |
| gst_caps_structure_simplify (GstStructure ** result, |
| const GstStructure * simplify, GstStructure * compare) |
| { |
| GSList *list; |
| UnionField field = { 0, {0,}, NULL }; |
| |
| /* try to subtract to get a real subset */ |
| if (gst_caps_structure_subtract (&list, simplify, compare)) { |
| switch (g_slist_length (list)) { |
| case 0: |
| *result = NULL; |
| return TRUE; |
| case 1: |
| *result = list->data; |
| g_slist_free (list); |
| return TRUE; |
| default: |
| { |
| GSList *walk; |
| |
| for (walk = list; walk; walk = g_slist_next (walk)) { |
| gst_structure_free (walk->data); |
| } |
| g_slist_free (list); |
| break; |
| } |
| } |
| } |
| |
| /* try to union both structs */ |
| field.compare = compare; |
| if (gst_structure_foreach ((GstStructure *) simplify, |
| gst_caps_structure_figure_out_union, &field)) { |
| gboolean ret = FALSE; |
| |
| /* now we know all of simplify's fields are the same in compare |
| * but at most one field: field.name */ |
| if (G_IS_VALUE (&field.value)) { |
| if (gst_structure_n_fields (simplify) == gst_structure_n_fields (compare)) { |
| gst_structure_id_set_value (compare, field.name, &field.value); |
| *result = NULL; |
| ret = TRUE; |
| } |
| g_value_unset (&field.value); |
| } else if (gst_structure_n_fields (simplify) <= |
| gst_structure_n_fields (compare)) { |
| /* compare is just more specific, will be optimized away later */ |
| /* FIXME: do this here? */ |
| GST_LOG ("found a case that will be optimized later."); |
| } else { |
| gchar *one = gst_structure_to_string (simplify); |
| gchar *two = gst_structure_to_string (compare); |
| |
| GST_ERROR |
| ("caps mismatch: structures %s and %s claim to be possible to unify, but aren't", |
| one, two); |
| g_free (one); |
| g_free (two); |
| } |
| return ret; |
| } |
| |
| return FALSE; |
| } |
| |
| static void |
| gst_caps_switch_structures (GstCaps * caps, GstStructure * old, |
| GstStructure * new, gint i) |
| { |
| gst_structure_set_parent_refcount (old, NULL); |
| gst_structure_free (old); |
| gst_structure_set_parent_refcount (new, &caps->refcount); |
| g_ptr_array_index (caps->structs, i) = new; |
| } |
| |
| /** |
| * gst_caps_do_simplify: |
| * @caps: a #GstCaps to simplify |
| * |
| * Modifies the given @caps inplace into a representation that represents the |
| * same set of formats, but in a simpler form. Component structures that are |
| * identical are merged. Component structures that have values that can be |
| * merged are also merged. |
| * |
| * Returns: TRUE, if the caps could be simplified |
| */ |
| gboolean |
| gst_caps_do_simplify (GstCaps * caps) |
| { |
| GstStructure *simplify, *compare, *result = NULL; |
| gint i, j, start; |
| gboolean changed = FALSE; |
| |
| g_return_val_if_fail (caps != NULL, FALSE); |
| g_return_val_if_fail (IS_WRITABLE (caps), FALSE); |
| |
| if (gst_caps_get_size (caps) < 2) |
| return FALSE; |
| |
| 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); |
| if (gst_structure_get_name_id (simplify) != |
| gst_structure_get_name_id (gst_caps_get_structure (caps, start))) |
| start = i; |
| for (j = start; j >= 0; j--) { |
| if (j == i) |
| continue; |
| compare = gst_caps_get_structure (caps, j); |
| if (gst_structure_get_name_id (simplify) != |
| gst_structure_get_name_id (compare)) { |
| break; |
| } |
| if (gst_caps_structure_simplify (&result, simplify, compare)) { |
| if (result) { |
| gst_caps_switch_structures (caps, simplify, result, i); |
| simplify = result; |
| } else { |
| gst_caps_remove_structure (caps, i); |
| start--; |
| break; |
| } |
| changed = TRUE; |
| } |
| } |
| } |
| |
| if (!changed) |
| return FALSE; |
| |
| /* gst_caps_do_simplify (caps); */ |
| return TRUE; |
| } |
| |
| #ifndef GST_DISABLE_LOADSAVE |
| /** |
| * gst_caps_save_thyself: |
| * @caps: a #GstCaps structure |
| * @parent: a XML parent node |
| * |
| * Serializes a #GstCaps to XML and adds it as a child node of @parent. |
| * |
| * Returns: a XML node pointer |
| */ |
| xmlNodePtr |
| gst_caps_save_thyself (const GstCaps * caps, xmlNodePtr parent) |
| { |
| char *s = gst_caps_to_string (caps); |
| |
| xmlNewChild (parent, NULL, (xmlChar *) "caps", (xmlChar *) s); |
| g_free (s); |
| return parent; |
| } |
| |
| /** |
| * gst_caps_load_thyself: |
| * @parent: a XML node |
| * |
| * Creates a #GstCaps from its XML serialization. |
| * |
| * Returns: a new #GstCaps structure |
| */ |
| GstCaps * |
| gst_caps_load_thyself (xmlNodePtr parent) |
| { |
| if (strcmp ("caps", (char *) parent->name) == 0) { |
| return gst_caps_from_string ((gchar *) xmlNodeGetContent (parent)); |
| } |
| |
| return NULL; |
| } |
| #endif |
| |
| /* utility */ |
| |
| /** |
| * gst_caps_replace: |
| * @caps: a pointer to #GstCaps |
| * @newcaps: a #GstCaps to replace *caps |
| * |
| * Replaces *caps with @newcaps. Unrefs the #GstCaps in the location |
| * pointed to by @caps, if applicable, then modifies @caps to point to |
| * @newcaps. An additional ref on @newcaps is taken. |
| * |
| * This function does not take any locks so you might want to lock |
| * the object owning @caps pointer. |
| */ |
| void |
| gst_caps_replace (GstCaps ** caps, GstCaps * newcaps) |
| { |
| GstCaps *oldcaps; |
| |
| g_return_if_fail (caps != NULL); |
| |
| oldcaps = *caps; |
| |
| if (newcaps != oldcaps) { |
| if (newcaps) |
| gst_caps_ref (newcaps); |
| |
| *caps = newcaps; |
| |
| if (oldcaps) |
| gst_caps_unref (oldcaps); |
| } |
| } |
| |
| /** |
| * gst_caps_to_string: |
| * @caps: a #GstCaps |
| * |
| * 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); |
| * </programlisting> |
| * This prints the caps in human readble form. |
| * |
| * Returns: a newly allocated string representing @caps. |
| */ |
| gchar * |
| gst_caps_to_string (const GstCaps * caps) |
| { |
| guint i; |
| 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 |
| * called by gst_caps_to_string. In particular, calls should |
| * not use the GST_PTR_FORMAT extension. */ |
| |
| if (caps == NULL) { |
| return g_strdup ("NULL"); |
| } |
| if (gst_caps_is_any (caps)) { |
| return g_strdup ("ANY"); |
| } |
| if (gst_caps_is_empty (caps)) { |
| return g_strdup ("EMPTY"); |
| } |
| |
| s = g_string_new (""); |
| for (i = 0; i < caps->structs->len; i++) { |
| GstStructure *structure; |
| char *sstr; |
| |
| if (i > 0) |
| g_string_append (s, "; "); |
| |
| structure = gst_caps_get_structure (caps, i); |
| sstr = gst_structure_to_string (structure); |
| g_string_append (s, sstr); |
| g_free (sstr); |
| } |
| |
| return g_string_free (s, FALSE); |
| } |
| |
| static gboolean |
| gst_caps_from_string_inplace (GstCaps * caps, const gchar * string) |
| { |
| GstStructure *structure; |
| gchar *s; |
| |
| g_return_val_if_fail (string, FALSE); |
| if (strcmp ("ANY", string) == 0) { |
| caps->flags = GST_CAPS_FLAGS_ANY; |
| return TRUE; |
| } |
| if (strcmp ("EMPTY", string) == 0) { |
| return TRUE; |
| } |
| |
| structure = gst_structure_from_string (string, &s); |
| if (structure == NULL) { |
| return FALSE; |
| } |
| gst_caps_append_structure (caps, structure); |
| |
| while (*s == ';') { |
| s++; |
| while (g_ascii_isspace (*s)) |
| s++; |
| structure = gst_structure_from_string (s, &s); |
| if (structure == NULL) { |
| return FALSE; |
| } |
| gst_caps_append_structure (caps, structure); |
| while (g_ascii_isspace (*s)) |
| s++; |
| } |
| |
| if (*s != 0) { |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| /** |
| * gst_caps_from_string: |
| * @string: a string to convert to #GstCaps |
| * |
| * Converts @caps from a string representation. |
| * |
| * Returns: a newly allocated #GstCaps |
| */ |
| GstCaps * |
| gst_caps_from_string (const gchar * string) |
| { |
| GstCaps *caps; |
| |
| caps = gst_caps_new_empty (); |
| if (gst_caps_from_string_inplace (caps, string)) { |
| return caps; |
| } else { |
| gst_caps_unref (caps); |
| return NULL; |
| } |
| } |
| |
| static void |
| gst_caps_transform_to_string (const GValue * src_value, GValue * dest_value) |
| { |
| g_return_if_fail (G_IS_VALUE (src_value)); |
| g_return_if_fail (G_IS_VALUE (dest_value)); |
| g_return_if_fail (G_VALUE_HOLDS (src_value, GST_TYPE_CAPS)); |
| g_return_if_fail (G_VALUE_HOLDS (dest_value, G_TYPE_STRING) |
| || G_VALUE_HOLDS (dest_value, G_TYPE_POINTER)); |
| |
| dest_value->data[0].v_pointer = |
| gst_caps_to_string (src_value->data[0].v_pointer); |
| } |
| |
| static GstCaps * |
| gst_caps_copy_conditional (GstCaps * src) |
| { |
| if (src) { |
| return gst_caps_ref (src); |
| } else { |
| return NULL; |
| } |
| } |