/* 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., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstcaps

 * @title: GstCaps

 * @short_description: Structure describing sets of media formats

 * @see_also: #GstStructure, #GstMiniObject

 *

 * Caps (capabilities) are lightweight 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_query_caps() pad

 * function. This function describes the possible types that the pad can

 * handle or produce at runtime.

 *

 * A #GstCaps can be constructed with the following code fragment:

 * |[

 *   GstCaps *caps = gst_caps_new_simple ("video/x-raw",

 *      "format", G_TYPE_STRING, "I420",

 *      "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);

 * ]|

 *

 * A #GstCaps is fixed when it has no properties with ranges or lists. Use

 * gst_caps_is_fixed() to test for fixed caps. Fixed caps can be used in a

 * caps event to notify downstream elements of the current media type.

 *

 * Various methods exist to work with the media types such as subtracting

 * or intersecting.

 *

 * Be aware that the current #GstCaps / #GstStructure serialization into string

 * has limited support for nested #GstCaps / #GstStructure fields. It can only

 * support one level of nesting. Using more levels will lead to unexpected

 * behavior when using serialization features, such as gst_caps_to_string() or

 * gst_value_serialize() and their counterparts.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <signal.h>

#include "gst_private.h"

#include <gst/gst.h>

#include <gobject/gvaluecollector.h>

#define DEBUG_REFCOUNT

typedef struct _GstCapsArrayElement

{

  GstStructure *structure;

  GstCapsFeatures *features;

} GstCapsArrayElement;

typedef struct _GstCapsImpl

{

  GstCaps caps;

  GArray *array;

} GstCapsImpl;

#define GST_CAPS_ARRAY(c) (((GstCapsImpl *)(c))->array)

#define GST_CAPS_LEN(c)   (GST_CAPS_ARRAY(c)->len)

#define IS_WRITABLE(caps) \

  (GST_CAPS_REFCOUNT_VALUE (caps) == 1)

/* same as gst_caps_is_any () */

#define CAPS_IS_ANY(caps)				\

  (!!(GST_CAPS_FLAGS(caps) & GST_CAPS_FLAG_ANY))

/* same as gst_caps_is_empty () */

#define CAPS_IS_EMPTY(caps)				\

  (!CAPS_IS_ANY(caps) && CAPS_IS_EMPTY_SIMPLE(caps))

#define CAPS_IS_EMPTY_SIMPLE(caps)					\

  ((GST_CAPS_ARRAY (caps) == NULL) || (GST_CAPS_LEN (caps) == 0))

#define gst_caps_features_copy_conditional(f) ((f && (gst_caps_features_is_any (f) || !gst_caps_features_is_equal (f, GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY))) ? gst_caps_features_copy (f) : NULL)

/* quick way to get a caps structure at an index without doing a type or array

 * length check */

#define gst_caps_get_structure_unchecked(caps, index) \

     (g_array_index (GST_CAPS_ARRAY (caps), GstCapsArrayElement, (index)).structure)

#define gst_caps_get_features_storage_unchecked(caps, index) \

     (&g_array_index (GST_CAPS_ARRAY (caps), GstCapsArrayElement, (index)).features)

#define gst_caps_get_features_unchecked(caps, index) \

     (g_atomic_pointer_get (gst_caps_get_features_storage_unchecked (caps, index)))

/* quick way to append a structure without checking the args */

#define gst_caps_append_structure_unchecked(caps, s, f) G_STMT_START{\

  GstCapsArrayElement __e={s, f};                                      \

  if (gst_structure_set_parent_refcount (__e.structure, &GST_MINI_OBJECT_REFCOUNT(caps)) && \

      (!__e.features || gst_caps_features_set_parent_refcount (__e.features, &GST_MINI_OBJECT_REFCOUNT(caps))))         \

    g_array_append_val (GST_CAPS_ARRAY (caps), __e);                             \

}G_STMT_END

/* 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);

GType _gst_caps_type = 0;

GstCaps *_gst_caps_any;

GstCaps *_gst_caps_none;

GST_DEFINE_MINI_OBJECT_TYPE (GstCaps, gst_caps);

void

_priv_gst_caps_initialize (void)

{

  _gst_caps_type = gst_caps_get_type ();

  _gst_caps_any = gst_caps_new_any ();

  _gst_caps_none = gst_caps_new_empty ();

  g_value_register_transform_func (_gst_caps_type,

      G_TYPE_STRING, gst_caps_transform_to_string);

}

void

_priv_gst_caps_cleanup (void)

{

  gst_caps_unref (_gst_caps_any);

  _gst_caps_any = NULL;

  gst_caps_unref (_gst_caps_none);

  _gst_caps_none = NULL;

}

GstCapsFeatures *

__gst_caps_get_features_unchecked (const GstCaps * caps, guint idx)

{

  return gst_caps_get_features_unchecked (caps, idx);

}

static GstCaps *

_gst_caps_copy (const GstCaps * caps)

{

  GstCaps *newcaps;

  GstStructure *structure;

  GstCapsFeatures *features;

  guint i, n;

  g_return_val_if_fail (GST_IS_CAPS (caps), NULL);

  newcaps = gst_caps_new_empty ();

  GST_CAPS_FLAGS (newcaps) = GST_CAPS_FLAGS (caps);

  n = GST_CAPS_LEN (caps);

  GST_CAT_DEBUG_OBJECT (GST_CAT_PERFORMANCE, caps, "doing copy %p -> %p",

      caps, newcaps);

  for (i = 0; i < n; i++) {

    structure = gst_caps_get_structure_unchecked (caps, i);

    features = gst_caps_get_features_unchecked (caps, i);

    gst_caps_append_structure_full (newcaps, gst_structure_copy (structure),

        gst_caps_features_copy_conditional (features));

  }

  return newcaps;

}

/* creation/deletion */

static void

_gst_caps_free (GstCaps * caps)

{

  GstStructure *structure;

  GstCapsFeatures *features;

  guint i, len;

  /* The refcount must be 0, but since we're only called by gst_caps_unref,

   * don't bother testing. */

  len = GST_CAPS_LEN (caps);

  /* This can be used to get statistics about caps sizes */

  /*GST_CAT_INFO (GST_CAT_CAPS, "caps size: %d", len); */

  for (i = 0; i < len; i++) {

    structure = gst_caps_get_structure_unchecked (caps, i);

    gst_structure_set_parent_refcount (structure, NULL);

    gst_structure_free (structure);

    features = gst_caps_get_features_unchecked (caps, i);

    if (features) {

      gst_caps_features_set_parent_refcount (features, NULL);

      gst_caps_features_free (features);

    }

  }

  g_array_free (GST_CAPS_ARRAY (caps), TRUE);

#ifdef DEBUG_REFCOUNT

  GST_CAT_TRACE (GST_CAT_CAPS, "freeing caps %p", caps);

#endif

  g_slice_free1 (sizeof (GstCapsImpl), caps);

}

static void

gst_caps_init (GstCaps * caps)

{

  gst_mini_object_init (GST_MINI_OBJECT_CAST (caps), 0, _gst_caps_type,

      (GstMiniObjectCopyFunction) _gst_caps_copy, NULL,

      (GstMiniObjectFreeFunction) _gst_caps_free);

  /* the 32 has been determined by logging caps sizes in _gst_caps_free

   * but g_ptr_array uses 16 anyway if it expands once, so this does not help

   * in practice

   * GST_CAPS_ARRAY (caps) = g_ptr_array_sized_new (32);

   */

  GST_CAPS_ARRAY (caps) =

      g_array_new (FALSE, TRUE, sizeof (GstCapsArrayElement));

}

/**

 * gst_caps_new_empty:

 *

 * Creates a new #GstCaps that is empty.  That is, the returned

 * #GstCaps contains no media formats.

 * The #GstCaps is guaranteed to be writable.

 * Caller is responsible for unreffing the returned caps.

 *

 * Returns: (transfer full): the new #GstCaps

 */

GstCaps *

gst_caps_new_empty (void)

{

  GstCaps *caps;

  caps = (GstCaps *) g_slice_new (GstCapsImpl);

  gst_caps_init (caps);

#ifdef DEBUG_REFCOUNT

  GST_CAT_TRACE (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: (transfer full): the new #GstCaps

 */

GstCaps *

gst_caps_new_any (void)

{

  GstCaps *caps = gst_caps_new_empty ();

  GST_CAPS_FLAG_SET (caps, GST_CAPS_FLAG_ANY);

  return caps;

}

/**

 * gst_caps_new_empty_simple:

 * @media_type: the media type of the structure

 *

 * Creates a new #GstCaps that contains one #GstStructure with name

 * @media_type.

 * Caller is responsible for unreffing the returned caps.

 *

 * Returns: (transfer full): the new #GstCaps

 */

GstCaps *

gst_caps_new_empty_simple (const char *media_type)

{

  GstCaps *caps;

  GstStructure *structure;

  caps = gst_caps_new_empty ();

  structure = gst_structure_new_empty (media_type);

  if (structure)

    gst_caps_append_structure_unchecked (caps, structure, NULL);

  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: (transfer full): 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);

  if (structure)

    gst_caps_append_structure_unchecked (caps, structure, NULL);

  else

    gst_caps_replace (&caps, NULL);

  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: (transfer full): 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: (transfer full): 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_unchecked (caps, structure, NULL);

    structure = va_arg (var_args, GstStructure *);

  }

  return caps;

}

G_DEFINE_POINTER_TYPE (GstStaticCaps, gst_static_caps);

/**

 * gst_static_caps_get:

 * @static_caps: the #GstStaticCaps to convert

 *

 * Converts a #GstStaticCaps to a #GstCaps.

 *

 * Returns: (transfer full) (nullable): 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 = &static_caps->caps;

  /* refcount is 0 when we need to convert */

  if (G_UNLIKELY (*caps == NULL)) {

    const char *string;

    G_LOCK (static_caps_lock);

    /* check if other thread already updated */

    if (G_UNLIKELY (*caps != NULL))

      goto done;

    string = static_caps->string;

    if (G_UNLIKELY (string == NULL))

      goto no_string;

    *caps = gst_caps_from_string (string);

    /* convert to string */

    if (G_UNLIKELY (*caps == NULL)) {

      g_critical ("Could not convert static caps \"%s\"", string);

      goto done;

    }

    /* Caps generated from static caps are usually leaked */

    GST_MINI_OBJECT_FLAG_SET (*caps, GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);

    GST_CAT_TRACE (GST_CAT_CAPS, "created %p from string %s", static_caps,

        string);

  done:

    G_UNLOCK (static_caps_lock);

  }

  /* ref the caps, makes it not writable */

  if (G_LIKELY (*caps != NULL))

    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;

  }

}

/**

 * gst_static_caps_cleanup:

 * @static_caps: the #GstStaticCaps to clean

 *

 * Clean up the cached caps contained in @static_caps.

 */

void

gst_static_caps_cleanup (GstStaticCaps * static_caps)

{

  G_LOCK (static_caps_lock);

  gst_caps_replace (&static_caps->caps, NULL);

  G_UNLOCK (static_caps_lock);

}

/* manipulation */

static void

gst_caps_remove_and_get_structure_and_features (GstCaps * caps, guint idx,

    GstStructure ** s, GstCapsFeatures ** f)

{

  GstStructure *s_;

  GstCapsFeatures *f_;

  s_ = gst_caps_get_structure_unchecked (caps, idx);

  f_ = gst_caps_get_features_unchecked (caps, idx);

  /* don't use index_fast, gst_caps_simplify relies on the order */

  g_array_remove_index (GST_CAPS_ARRAY (caps), idx);

  gst_structure_set_parent_refcount (s_, NULL);

  if (f_) {

    gst_caps_features_set_parent_refcount (f_, NULL);

  }

  *s = s_;

  *f = f_;

}

static GstStructure *

gst_caps_remove_and_get_structure (GstCaps * caps, guint idx)

{

  GstStructure *s;

  GstCapsFeatures *f;

  gst_caps_remove_and_get_structure_and_features (caps, idx, &s, &f);

  if (f)

    gst_caps_features_free (f);

  return s;

}

/**

 * gst_caps_steal_structure:

 * @caps: the #GstCaps to retrieve from

 * @index: Index of the structure to retrieve

 *

 * Retrieves the structure with the given index from the list of structures

 * contained in @caps. The caller becomes the owner of the returned structure.

 *

 * Returns: (transfer full) (nullable): a pointer to the #GstStructure

 *     corresponding to @index.

 */

GstStructure *

gst_caps_steal_structure (GstCaps * caps, guint index)

{

  g_return_val_if_fail (caps != NULL, NULL);

  g_return_val_if_fail (IS_WRITABLE (caps), NULL);

  if (G_UNLIKELY (index >= GST_CAPS_LEN (caps)))

    return NULL;

  return gst_caps_remove_and_get_structure (caps, index);

}

/**

 * gst_caps_append:

 * @caps1: the #GstCaps that will be appended to

 * @caps2: (transfer full): 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;

  GstCapsFeatures *features;

  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));

  if (G_UNLIKELY (CAPS_IS_ANY (caps1) || CAPS_IS_ANY (caps2))) {

    GST_CAPS_FLAGS (caps1) |= GST_CAPS_FLAG_ANY;

    gst_caps_unref (caps2);

  } else {

    caps2 = gst_caps_make_writable (caps2);

    for (i = GST_CAPS_LEN (caps2); i; i--) {

      gst_caps_remove_and_get_structure_and_features (caps2, 0, &structure,

          &features);

      gst_caps_append_structure_unchecked (caps1, structure, features);

    }

    gst_caps_unref (caps2);     /* guaranteed to free it */

  }

}

/**

 * gst_caps_merge:

 * @caps1: (transfer full): the #GstCaps that will take the new entries

 * @caps2: (transfer full): 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 a writable copy of @caps1, and then @caps2 is freed.

 * If either caps is ANY, the resulting caps will be ANY.

 *

 * Returns: (transfer full): the merged caps.

 */

GstCaps *

gst_caps_merge (GstCaps * caps1, GstCaps * caps2)

{

  GstStructure *structure;

  GstCapsFeatures *features;

  int i;

  GstCaps *result;

  g_return_val_if_fail (GST_IS_CAPS (caps1), NULL);

  g_return_val_if_fail (GST_IS_CAPS (caps2), NULL);

  if (G_UNLIKELY (CAPS_IS_ANY (caps1))) {

    gst_caps_unref (caps2);

    result = caps1;

  } else if (G_UNLIKELY (CAPS_IS_ANY (caps2))) {

    gst_caps_unref (caps1);

    result = caps2;

  } else {

    caps2 = gst_caps_make_writable (caps2);

    for (i = GST_CAPS_LEN (caps2); i; i--) {

      gst_caps_remove_and_get_structure_and_features (caps2, 0, &structure,

          &features);

      caps1 = gst_caps_merge_structure_full (caps1, structure, features);

    }

    gst_caps_unref (caps2);

    result = caps1;

    /* 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);

     */

  }

  return result;

}

/**

 * gst_caps_append_structure:

 * @caps: the #GstCaps that will be appended to

 * @structure: (transfer full): 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)) {

    gst_caps_append_structure_unchecked (caps, structure, NULL);

  }

}

/**

 * gst_caps_append_structure_full:

 * @caps: the #GstCaps that will be appended to

 * @structure: (transfer full): the #GstStructure to append

 * @features: (transfer full) (allow-none): the #GstCapsFeatures to append

 *

 * Appends @structure with @features to @caps.  The structure is not copied; @caps

 * becomes the owner of @structure.

 *

 * Since: 1.2

 */

void

gst_caps_append_structure_full (GstCaps * caps, GstStructure * structure,

    GstCapsFeatures * features)

{

  g_return_if_fail (GST_IS_CAPS (caps));

  g_return_if_fail (IS_WRITABLE (caps));

  if (G_LIKELY (structure)) {

    gst_caps_append_structure_unchecked (caps, structure, features);

  }

}

/**

 * gst_caps_remove_structure:

 * @caps: the #GstCaps to remove from

 * @idx: Index of the structure to remove

 *

 * removes the structure 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: (transfer full): the #GstCaps to merge into

 * @structure: (transfer full): the #GstStructure to merge

 *

 * Appends @structure to @caps if its not already expressed by @caps.

 *

 * Returns: (transfer full): the merged caps.

 */

GstCaps *

gst_caps_merge_structure (GstCaps * caps, GstStructure * structure)

{

  GstStructure *structure1;

  GstCapsFeatures *features1;

  int i;

  gboolean unique = TRUE;

  g_return_val_if_fail (GST_IS_CAPS (caps), NULL);

  if (G_UNLIKELY (structure == NULL))

    return caps;

  /* check each structure */

  for (i = GST_CAPS_LEN (caps) - 1; i >= 0; i--) {

    structure1 = gst_caps_get_structure_unchecked (caps, i);

    features1 = gst_caps_get_features_unchecked (caps, i);

    if (!features1)

      features1 = GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY;

    /* if structure is a subset of structure1 and the

     * there are no existing features, then skip it */

    if (gst_caps_features_is_equal (features1,

            GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY)

        && gst_structure_is_subset (structure, structure1)) {

      unique = FALSE;

      break;

    }

  }

  if (unique) {

    caps = gst_caps_make_writable (caps);

    gst_caps_append_structure_unchecked (caps, structure, NULL);

  } else {

    gst_structure_free (structure);

  }

  return caps;

}

/**

 * gst_caps_merge_structure_full:

 * @caps: (transfer full): the #GstCaps to merge into

 * @structure: (transfer full): the #GstStructure to merge

 * @features: (transfer full) (allow-none): the #GstCapsFeatures to merge

 *

 * Appends @structure with @features to @caps if its not already expressed by @caps.

 *

 * Returns: (transfer full): the merged caps.

 *

 * Since: 1.2

 */

GstCaps *

gst_caps_merge_structure_full (GstCaps * caps, GstStructure * structure,

    GstCapsFeatures * features)

{

  GstStructure *structure1;

  GstCapsFeatures *features1, *features_tmp;

  int i;

  gboolean unique = TRUE;

  g_return_val_if_fail (GST_IS_CAPS (caps), NULL);

  if (G_UNLIKELY (structure == NULL))

    return caps;

  /* To make comparisons easier below */

  features_tmp = features ? features : GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY;

  /* check each structure */

  for (i = GST_CAPS_LEN (caps) - 1; i >= 0; i--) {

    structure1 = gst_caps_get_structure_unchecked (caps, i);

    features1 = gst_caps_get_features_unchecked (caps, i);

    if (!features1)

      features1 = GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY;

    /* if structure is a subset of structure1 and the

     * the features are a subset, then skip it */

    /* FIXME: We only skip if none of the features are

     * ANY and are still equal. That way all ANY structures

     * show up in the caps and no non-ANY structures are

     * swallowed by ANY structures

     */

    if (((!gst_caps_features_is_any (features_tmp)

                || gst_caps_features_is_any (features1))

            && gst_caps_features_is_equal (features_tmp, features1))

        && gst_structure_is_subset (structure, structure1)) {

      unique = FALSE;

      break;

    }

  }

  if (unique) {

    caps = gst_caps_make_writable (caps);

    gst_caps_append_structure_unchecked (caps, structure, features);

  } else {

    gst_structure_free (structure);

    if (features)

      gst_caps_features_free (features);

  }

  return caps;

}

/**

 * 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 GST_CAPS_LEN (caps);

}

/**

 * 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. 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().

 *

 * You do not need to free or unref the structure returned, it

 * belongs to the #GstCaps.

 *

 * Returns: (transfer none): 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 < GST_CAPS_LEN (caps), NULL);

  return gst_caps_get_structure_unchecked (caps, index);

}

/**

 * gst_caps_get_features:

 * @caps: a #GstCaps

 * @index: the index of the structure

 *

 * Finds the features in @caps that has the index @index, and

 * returns it.

 *

 * WARNING: This function takes a const GstCaps *, but returns a

 * non-const GstCapsFeatures *.  This is for programming convenience --

 * the caller should be aware that structures inside a constant

 * #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

 * features returned in the usual way, e.g. with functions like

 * gst_caps_features_add().

 *

 * You do not need to free or unref the structure returned, it

 * belongs to the #GstCaps.

 *

 * Returns: (transfer none) (nullable): a pointer to the #GstCapsFeatures

 *     corresponding to @index

 *

 * Since: 1.2

 */

GstCapsFeatures *

gst_caps_get_features (const GstCaps * caps, guint index)

{

  GstCapsFeatures *features;

  g_return_val_if_fail (GST_IS_CAPS (caps), NULL);

  g_return_val_if_fail (index < GST_CAPS_LEN (caps), NULL);

  features = gst_caps_get_features_unchecked (caps, index);

  if (!features) {

    GstCapsFeatures **storage;

    /* We have to do some atomic pointer magic here as the caps

     * might not be writable and someone else calls this function

     * at the very same time */

    features = gst_caps_features_copy (GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY);