gst/gstcapsfeatures.c

   1 /* GStreamer
   2  * Copyright (C) 2013 Collabora Ltd.
   3  *   Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * SECTION:gstcapsfeatures
  23  * @short_description: A set of features in caps
  24  * @see_also: #GstCaps
  25  *
  26  * #GstCapsFeatures can optionally be set on a #GstCaps to add requirements
  27  * for additional features for a specific #GstStructure. Caps structures with
  28  * the same name but with a non-equal set of caps features are not compatible.
  29  * If a pad supports multiple sets of features it has to add multiple equal
  30  * structures with different feature sets to the caps.
  31  *
  32  * Empty #GstCapsFeatures are equivalent with the #GstCapsFeatures that only
  33  * contain #GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY.
  34  *
  35  * Examples for caps features would be the requirement of a specific #GstMemory
  36  * types or the requirement of having a specific #GstMeta on the buffer. Features
  37  * are given as a string of the format "memory:GstMemoryTypeName" or
  38  * "meta:GstMetaAPIName".
  39  */
  40
  41 #ifdef HAVE_CONFIG_H
  42 #include "config.h"
  43 #endif
  44
  45 #include <string.h>
  46 #include "gst_private.h"
  47 #include "gstcapsfeatures.h"
  48 #include <gst/gst.h>
  49
  50 GST_DEBUG_CATEGORY_STATIC (gst_caps_features_debug);
  51 #define GST_CAT_DEFAULT gst_caps_features_debug
  52
  53 struct _GstCapsFeatures
  54 {
  55   GType type;
  56   gint *parent_refcount;
  57   GArray *array;
  58   gboolean is_any;
  59 };
  60
  61 GType _gst_caps_features_type = 0;
  62 GstCapsFeatures *_gst_caps_features_any = NULL;
  63 GstCapsFeatures *_gst_caps_features_memory_system_memory = NULL;
  64 static GQuark _gst_caps_feature_memory_system_memory = 0;
  65
  66 G_DEFINE_BOXED_TYPE (GstCapsFeatures, gst_caps_features,
  67     gst_caps_features_copy, gst_caps_features_free);
  68
  69 #define IS_MUTABLE(features) \
  70     (!features->parent_refcount || \
  71      g_atomic_int_get (features->parent_refcount) == 1)
  72
  73 static void
  74 gst_caps_features_transform_to_string (const GValue * src_value,
  75     GValue * dest_value);
  76
  77 void
  78 _priv_gst_caps_features_initialize (void)
  79 {
  80   _gst_caps_features_type = gst_caps_features_get_type ();
  81   _gst_caps_feature_memory_system_memory =
  82       g_quark_from_static_string (GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY);
  83
  84   g_value_register_transform_func (_gst_caps_features_type, G_TYPE_STRING,
  85       gst_caps_features_transform_to_string);
  86
  87   _gst_caps_features_any = gst_caps_features_new_any ();
  88   _gst_caps_features_memory_system_memory =
  89       gst_caps_features_new_id (_gst_caps_feature_memory_system_memory, 0);
  90
  91   GST_DEBUG_CATEGORY_INIT (gst_caps_features_debug, "caps-features", 0,
  92       "GstCapsFeatures debug");
  93 }
  94
  95 gboolean
  96 gst_is_caps_features (gconstpointer obj)
  97 {
  98   const GstCapsFeatures *features = obj;
  99
 100   return (obj != NULL && features->type == _gst_caps_features_type);
 101 }
 102
 103 static gboolean
 104 gst_caps_feature_name_is_valid (const gchar * feature)
 105 {
 106 #ifndef G_DISABLE_CHECKS
 107   while (TRUE) {
 108     if (g_ascii_isalpha (*feature))
 109       feature++;
 110     else if (*feature == ':')
 111       break;
 112     else
 113       return FALSE;
 114   }
 115
 116   if (*feature != ':')
 117     return FALSE;
 118
 119   feature++;
 120   if (*feature == '\0' || !g_ascii_isalpha (*feature))
 121     return FALSE;
 122
 123   while (TRUE) {
 124     if (g_ascii_isalnum (*feature))
 125       feature++;
 126     else if (*feature == '\0')
 127       break;
 128     else
 129       return FALSE;
 130   }
 131 #endif
 132
 133   return TRUE;
 134 }
 135
 136 /**
 137  * gst_caps_features_new_empty:
 138  *
 139  * Creates a new, empty #GstCapsFeatures.
 140  *
 141  * Free-function: gst_caps_features_free
 142  *
 143  * Returns: (transfer full): a new, empty #GstCapsFeatures
 144  */
 145 GstCapsFeatures *
 146 gst_caps_features_new_empty (void)
 147 {
 148   GstCapsFeatures *features;
 149
 150   features = g_slice_new (GstCapsFeatures);
 151   features->type = _gst_caps_features_type;
 152   features->parent_refcount = NULL;
 153   features->array = g_array_new (FALSE, FALSE, sizeof (GQuark));
 154   features->is_any = FALSE;
 155
 156   GST_TRACE ("created caps features %p", features);
 157
 158   return features;
 159 }
 160
 161 /**
 162  * gst_caps_features_new_any:
 163  *
 164  * Creates a new, ANY #GstCapsFeatures. This will be equal
 165  * to any other #GstCapsFeatures but caps with these are
 166  * unfixed.
 167  *
 168  * Free-function: gst_caps_features_free
 169  *
 170  * Returns: (transfer full): a new, ANY #GstCapsFeatures
 171  */
 172 GstCapsFeatures *
 173 gst_caps_features_new_any (void)
 174 {
 175   GstCapsFeatures *features;
 176
 177   features = gst_caps_features_new_empty ();
 178   features->is_any = TRUE;
 179
 180   return features;
 181 }
 182
 183 /**
 184  * gst_caps_features_new:
 185  * @feature1: name of first feature to set
 186  * @...: additional features
 187  *
 188  * Creates a new #GstCapsFeatures with the given features.
 189  * The last argument must be NULL.
 190  *
 191  * Free-function: gst_caps_features_free
 192  *
 193  * Returns: (transfer full): a new, empty #GstCapsFeatures
 194  */
 195 GstCapsFeatures *
 196 gst_caps_features_new (const gchar * feature1, ...)
 197 {
 198   GstCapsFeatures *features;
 199   va_list varargs;
 200
 201   g_return_val_if_fail (feature1 != NULL, NULL);
 202
 203   va_start (varargs, feature1);
 204   features = gst_caps_features_new_valist (feature1, varargs);
 205   va_end (varargs);
 206
 207   return features;
 208 }
 209
 210 /**
 211  * gst_caps_features_new_valist:
 212  * @feature1: name of first feature to set
 213  * @varargs: variable argument list
 214  *
 215  * Creates a new #GstCapsFeatures with the given features.
 216  *
 217  * Free-function: gst_caps_features_free
 218  *
 219  * Returns: (transfer full): a new, empty #GstCapsFeatures
 220  */
 221 GstCapsFeatures *
 222 gst_caps_features_new_valist (const gchar * feature1, va_list varargs)
 223 {
 224   GstCapsFeatures *features;
 225
 226   g_return_val_if_fail (feature1 != NULL, NULL);
 227
 228   features = gst_caps_features_new_empty ();
 229
 230   while (feature1) {
 231     gst_caps_features_add (features, feature1);
 232     feature1 = va_arg (varargs, const gchar *);
 233   }
 234
 235   return features;
 236 }
 237
 238 /**
 239  * gst_caps_features_new_id:
 240  * @feature1: name of first feature to set
 241  * @...: additional features
 242  *
 243  * Creates a new #GstCapsFeatures with the given features.
 244  * The last argument must be 0.
 245  *
 246  * Free-function: gst_caps_features_free
 247  *
 248  * Returns: (transfer full): a new, empty #GstCapsFeatures
 249  */
 250 GstCapsFeatures *
 251 gst_caps_features_new_id (GQuark feature1, ...)
 252 {
 253   GstCapsFeatures *features;
 254   va_list varargs;
 255
 256   g_return_val_if_fail (feature1 != 0, NULL);
 257
 258   va_start (varargs, feature1);
 259   features = gst_caps_features_new_id_valist (feature1, varargs);
 260   va_end (varargs);
 261
 262   return features;
 263 }
 264
 265 /**
 266  * gst_caps_features_new_id_valist:
 267  * @feature1: name of first feature to set
 268  * @varargs: variable argument list
 269  *
 270  * Creates a new #GstCapsFeatures with the given features.
 271  *
 272  * Free-function: gst_caps_features_free
 273  *
 274  * Returns: (transfer full): a new, empty #GstCapsFeatures
 275  */
 276 GstCapsFeatures *
 277 gst_caps_features_new_id_valist (GQuark feature1, va_list varargs)
 278 {
 279   GstCapsFeatures *features;
 280
 281   g_return_val_if_fail (feature1 != 0, NULL);
 282
 283   features = gst_caps_features_new_empty ();
 284
 285   while (feature1) {
 286     gst_caps_features_add_id (features, feature1);
 287     feature1 = va_arg (varargs, GQuark);
 288   }
 289
 290   return features;
 291 }
 292
 293 /**
 294  * gst_caps_features_set_parent_refcount:
 295  * @features: a #GstCapsFeatures
 296  * @refcount: (in): a pointer to the parent's refcount
 297  *
 298  * Sets the parent_refcount field of #GstCapsFeatures. This field is used to
 299  * determine whether a caps features is mutable or not. This function should only be
 300  * called by code implementing parent objects of #GstCapsFeatures, as described in
 301  * the MT Refcounting section of the design documents.
 302  *
 303  * Returns: %TRUE if the parent refcount could be set.
 304  */
 305 gboolean
 306 gst_caps_features_set_parent_refcount (GstCapsFeatures * features,
 307     gint * refcount)
 308 {
 309   g_return_val_if_fail (features != NULL, FALSE);
 310
 311   /* if we have a parent_refcount already, we can only clear
 312    * if with a NULL refcount */
 313   if (features->parent_refcount) {
 314     if (refcount != NULL) {
 315       g_return_val_if_fail (refcount == NULL, FALSE);
 316       return FALSE;
 317     }
 318   } else {
 319     if (refcount == NULL) {
 320       g_return_val_if_fail (refcount != NULL, FALSE);
 321       return FALSE;
 322     }
 323   }
 324
 325   features->parent_refcount = refcount;
 326
 327   return TRUE;
 328 }
 329
 330 /**
 331  * gst_caps_features_copy:
 332  * @features: a #GstCapsFeatures to duplicate
 333  *
 334  * Duplicates a #GstCapsFeatures and all its values.
 335  *
 336  * Free-function: gst_caps_features_free
 337  *
 338  * Returns: (transfer full): a new #GstCapsFeatures.
 339  */
 340 GstCapsFeatures *
 341 gst_caps_features_copy (const GstCapsFeatures * features)
 342 {
 343   GstCapsFeatures *copy;
 344   guint i, n;
 345
 346   g_return_val_if_fail (features != NULL, NULL);
 347
 348   copy = gst_caps_features_new_empty ();
 349   n = gst_caps_features_get_size (features);
 350   for (i = 0; i < n; i++)
 351     gst_caps_features_add_id (copy, gst_caps_features_get_nth_id (features, i));
 352
 353   return copy;
 354 }
 355
 356 /**
 357  * gst_caps_features_free:
 358  * @features: (in) (transfer full): the #GstCapsFeatures to free
 359  *
 360  * Frees a #GstCapsFeatures and all its values. The caps features must not
 361  * have a parent when this function is called.
 362  */
 363 void
 364 gst_caps_features_free (GstCapsFeatures * features)
 365 {
 366   g_return_if_fail (features != NULL);
 367   g_return_if_fail (features->parent_refcount == NULL);
 368
 369   g_array_free (features->array, TRUE);
 370 #ifdef USE_POISONING
 371   memset (features, 0xff, sizeof (GstCapsFeatures));
 372 #endif
 373   GST_TRACE ("free caps features %p", features);
 374
 375   g_slice_free (GstCapsFeatures, features);
 376 }
 377
 378 /**
 379  * gst_caps_features_to_string:
 380  * @features: a #GstCapsFeatures
 381  *
 382  * Converts @features to a human-readable string representation.
 383  *
 384  * For debugging purposes its easier to do something like this:
 385  * |[
 386  * GST_LOG ("features is %" GST_PTR_FORMAT, features);
 387  * ]|
 388  * This prints the features in human readble form.
 389  *
 390  * Free-function: g_free
 391  *
 392  * Returns: (transfer full): a pointer to string allocated by g_malloc().
 393  *     g_free() after usage.
 394  */
 395 gchar *
 396 gst_caps_features_to_string (const GstCapsFeatures * features)
 397 {
 398   GString *s;
 399
 400   g_return_val_if_fail (features != NULL, NULL);
 401
 402   s = g_string_sized_new (FEATURES_ESTIMATED_STRING_LEN (features));
 403
 404   priv_gst_caps_features_append_to_gstring (features, s);
 405
 406   return g_string_free (s, FALSE);
 407 }
 408
 409 void
 410 priv_gst_caps_features_append_to_gstring (const GstCapsFeatures * features,
 411     GString * s)
 412 {
 413   guint i, n;
 414
 415   g_return_if_fail (features != NULL);
 416
 417   if (features->array->len == 0 && features->is_any) {
 418     g_string_append (s, "ANY");
 419     return;
 420   }
 421
 422   n = features->array->len;
 423   for (i = 0; i < n; i++) {
 424     GQuark *quark = &g_array_index (features->array, GQuark, i);
 425
 426     g_string_append (s, g_quark_to_string (*quark));
 427     if (i + 1 < n)
 428       g_string_append (s, ", ");
 429   }
 430 }
 431
 432 /**
 433  * gst_caps_features_from_string:
 434  * @features: a string representation of a #GstCapsFeatures.
 435  *
 436  * Creates a #GstCapsFeatures from a string representation.
 437  *
 438  * Free-function: gst_caps_features_free
 439  *
 440  * Returns: (transfer full): a new #GstCapsFeatures or NULL when the string could
 441  *     not be parsed. Free with gst_caps_features_free() after use.
 442  */
 443 GstCapsFeatures *
 444 gst_caps_features_from_string (const gchar * features)
 445 {
 446   GstCapsFeatures *ret;
 447   gboolean escape = FALSE;
 448   const gchar *features_orig = features;
 449   const gchar *feature;
 450
 451   ret = gst_caps_features_new_empty ();
 452
 453   if (!features || *features == '\0')
 454     return ret;
 455
 456   if (strcmp (features, "ANY") == 0) {
 457     ret->is_any = TRUE;
 458     return ret;
 459   }
 460
 461   /* Skip trailing spaces */
 462   while (*features == ' ')
 463     features++;
 464
 465   feature = features;
 466   while (TRUE) {
 467     gchar c = *features;
 468
 469     if (c == '\\') {
 470       escape = TRUE;
 471       features++;
 472       continue;
 473     } else if ((!escape && c == ',') || c == '\0') {
 474       guint len = features - feature + 1;
 475       gchar *tmp;
 476       gchar *p;
 477
 478       if (len == 1) {
 479         g_warning ("Failed deserialize caps features '%s'", features_orig);
 480         gst_caps_features_free (ret);
 481         return NULL;
 482       }
 483
 484       tmp = g_malloc (len);
 485       memcpy (tmp, feature, len - 1);
 486       tmp[len - 1] = '\0';
 487
 488       p = tmp + len - 1;
 489       while (*p == ' ') {
 490         *p = '\0';
 491         p--;
 492       }
 493
 494       if (strstr (tmp, " ") != NULL || *tmp == '\0') {
 495         g_free (tmp);
 496         g_warning ("Failed deserialize caps features '%s'", features_orig);
 497         gst_caps_features_free (ret);
 498         return NULL;
 499       }
 500
 501       gst_caps_features_add (ret, tmp);
 502       g_free (tmp);
 503
 504       if (c == '\0')
 505         break;
 506
 507       /* Skip to the next value */
 508       features++;
 509       while (*features == ' ')
 510         features++;
 511       feature = features;
 512     } else {
 513       escape = FALSE;
 514       features++;
 515     }
 516   }
 517
 518   return ret;
 519 }
 520
 521 /**
 522  * gst_caps_features_get_size:
 523  * @features: a #GstCapsFeatures.
 524  *
 525  * Returns the number of features in @features.
 526  *
 527  * Returns: The number of features in @features.
 528  */
 529 guint
 530 gst_caps_features_get_size (const GstCapsFeatures * features)
 531 {
 532   g_return_val_if_fail (features != NULL, 0);
 533
 534   return features->array->len;
 535 }
 536
 537 /**
 538  * gst_caps_features_get_nth:
 539  * @features: a #GstCapsFeatures.
 540  * @i: index of the feature
 541  *
 542  * Returns the @i-th feature of @features.
 543  *
 544  * Returns: The @i-th feature of @features.
 545  */
 546 const gchar *
 547 gst_caps_features_get_nth (const GstCapsFeatures * features, guint i)
 548 {
 549   const gchar *feature;
 550   GQuark quark;
 551
 552   g_return_val_if_fail (features != NULL, NULL);
 553
 554   quark = gst_caps_features_get_nth_id (features, i);
 555   if (!quark)
 556     return NULL;
 557
 558   feature = g_quark_to_string (quark);
 559   return feature;
 560 }
 561
 562 /**
 563  * gst_caps_features_get_nth_id:
 564  * @features: a #GstCapsFeatures.
 565  * @i: index of the feature
 566  *
 567  * Returns the @i-th feature of @features.
 568  *
 569  * Returns: The @i-th feature of @features.
 570  */
 571 GQuark
 572 gst_caps_features_get_nth_id (const GstCapsFeatures * features, guint i)
 573 {
 574   GQuark *quark;
 575
 576   g_return_val_if_fail (features != NULL, 0);
 577   g_return_val_if_fail (i < features->array->len, 0);
 578
 579   quark = &g_array_index (features->array, GQuark, i);
 580
 581   return *quark;
 582 }
 583
 584 /**
 585  * gst_caps_features_contains:
 586  * @features: a #GstCapsFeatures.
 587  * @feature: a feature
 588  *
 589  * Returns %TRUE if @features contains @feature.
 590  *
 591  * Returns: %TRUE if @features contains @feature.
 592  */
 593 gboolean
 594 gst_caps_features_contains (const GstCapsFeatures * features,
 595     const gchar * feature)
 596 {
 597   g_return_val_if_fail (features != NULL, FALSE);
 598   g_return_val_if_fail (feature != NULL, FALSE);
 599
 600   return gst_caps_features_contains_id (features,
 601       g_quark_from_string (feature));
 602 }
 603
 604 /**
 605  * gst_caps_features_contains_id:
 606  * @features: a #GstCapsFeatures.
 607  * @feature: a feature
 608  *
 609  * Returns %TRUE if @features contains @feature.
 610  *
 611  * Returns: %TRUE if @features contains @feature.
 612  */
 613 gboolean
 614 gst_caps_features_contains_id (const GstCapsFeatures * features, GQuark feature)
 615 {
 616   guint i, n;
 617
 618   g_return_val_if_fail (features != NULL, FALSE);
 619   g_return_val_if_fail (feature != 0, FALSE);
 620
 621   if (features->is_any)
 622     return TRUE;
 623
 624   n = features->array->len;
 625   if (n == 0)
 626     return feature == _gst_caps_feature_memory_system_memory;
 627
 628   for (i = 0; i < n; i++) {
 629     if (gst_caps_features_get_nth_id (features, i) == feature)
 630       return TRUE;
 631   }
 632
 633   return FALSE;
 634 }
 635
 636 /**
 637  * gst_caps_features_is_equal:
 638  * @features1: a #GstCapsFeatures.
 639  * @features2: a #GstCapsFeatures.
 640  *
 641  * Returns %TRUE if @features1 and @features2 are equal.
 642  *
 643  * Returns: %TRUE if @features1 and @features2 are equal.
 644  */
 645 gboolean
 646 gst_caps_features_is_equal (const GstCapsFeatures * features1,
 647     const GstCapsFeatures * features2)
 648 {
 649   guint i, n;
 650
 651   g_return_val_if_fail (features1 != NULL, FALSE);
 652   g_return_val_if_fail (features2 != NULL, FALSE);
 653
 654   if (features1->is_any || features2->is_any)
 655     return TRUE;
 656
 657   /* Check for the sysmem==empty case */
 658   if (features1->array->len == 0 && features2->array->len == 0)
 659     return TRUE;
 660   if (features1->array->len == 0 && features2->array->len == 1
 661       && gst_caps_features_contains_id (features2,
 662           _gst_caps_feature_memory_system_memory))
 663     return TRUE;
 664   if (features2->array->len == 0 && features1->array->len == 1
 665       && gst_caps_features_contains_id (features1,
 666           _gst_caps_feature_memory_system_memory))
 667     return TRUE;
 668
 669   if (features1->array->len != features2->array->len)
 670     return FALSE;
 671
 672   n = features1->array->len;
 673   for (i = 0; i < n; i++)
 674     if (!gst_caps_features_contains_id (features2,
 675             gst_caps_features_get_nth_id (features1, i)))
 676       return FALSE;
 677
 678   return TRUE;
 679 }
 680
 681 /**
 682  * gst_caps_features_is_any:
 683  * @features: a #GstCapsFeatures.
 684  *
 685  * Returns %TRUE if @features is %GST_CAPS_FEATURES_ANY.
 686  *
 687  * Returns: %TRUE if @features is %GST_CAPS_FEATURES_ANY.
 688  */
 689 gboolean
 690 gst_caps_features_is_any (const GstCapsFeatures * features)
 691 {
 692   g_return_val_if_fail (features != NULL, FALSE);
 693
 694   return features->is_any;
 695 }
 696
 697 /**
 698  * gst_caps_features_add:
 699  * @features: a #GstCapsFeatures.
 700  * @feature: a feature.
 701  *
 702  * Adds @feature to @features.
 703  */
 704 void
 705 gst_caps_features_add (GstCapsFeatures * features, const gchar * feature)
 706 {
 707   g_return_if_fail (features != NULL);
 708   g_return_if_fail (IS_MUTABLE (features));
 709   g_return_if_fail (feature != NULL);
 710   g_return_if_fail (!features->is_any);
 711
 712   gst_caps_features_add_id (features, g_quark_from_string (feature));
 713 }
 714
 715 /**
 716  * gst_caps_features_add_id:
 717  * @features: a #GstCapsFeatures.
 718  * @feature: a feature.
 719  *
 720  * Adds @feature to @features.
 721  */
 722 void
 723 gst_caps_features_add_id (GstCapsFeatures * features, GQuark feature)
 724 {
 725   g_return_if_fail (features != NULL);
 726   g_return_if_fail (IS_MUTABLE (features));
 727   g_return_if_fail (feature != 0);
 728   g_return_if_fail (!features->is_any);
 729
 730   if (!gst_caps_feature_name_is_valid (g_quark_to_string (feature))) {
 731     g_warning ("Invalid caps feature name: %s", g_quark_to_string (feature));
 732     return;
 733   }
 734
 735   /* If features is empty it will contain sysmem, however
 736    * we want to add it explicitely if it is tried to be
 737    * added as first features
 738    */
 739   if (features->array->len > 0
 740       && gst_caps_features_contains_id (features, feature))
 741     return;
 742
 743   g_array_append_val (features->array, feature);
 744 }
 745
 746 /**
 747  * gst_caps_features_remove:
 748  * @features: a #GstCapsFeatures.
 749  * @feature: a feature.
 750  *
 751  * Removes @feature from @features.
 752  */
 753 void
 754 gst_caps_features_remove (GstCapsFeatures * features, const gchar * feature)
 755 {
 756   g_return_if_fail (features != NULL);
 757   g_return_if_fail (IS_MUTABLE (features));
 758   g_return_if_fail (feature != NULL);
 759
 760   gst_caps_features_remove_id (features, g_quark_from_string (feature));
 761 }
 762
 763 /**
 764  * gst_caps_features_remove_id:
 765  * @features: a #GstCapsFeatures.
 766  * @feature: a feature.
 767  *
 768  * Removes @feature from @features.
 769  */
 770 void
 771 gst_caps_features_remove_id (GstCapsFeatures * features, GQuark feature)
 772 {
 773   guint i, n;
 774
 775   g_return_if_fail (features != NULL);
 776   g_return_if_fail (IS_MUTABLE (features));
 777   g_return_if_fail (feature != 0);
 778
 779   n = features->array->len;
 780   for (i = 0; i < n; i++) {
 781     GQuark quark = gst_caps_features_get_nth_id (features, i);
 782
 783     if (quark == feature) {
 784       g_array_remove_index_fast (features->array, i);
 785       return;
 786     }
 787   }
 788 }
 789
 790 static void
 791 gst_caps_features_transform_to_string (const GValue * src_value,
 792     GValue * dest_value)
 793 {
 794   g_return_if_fail (src_value != NULL);
 795   g_return_if_fail (dest_value != NULL);
 796
 797   dest_value->data[0].v_pointer =
 798       gst_caps_features_to_string (src_value->data[0].v_pointer);
 799 }