gst/gstcaps.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wtay@chello.be>
   4  *
   5  * gstcaps.c: Element capabilities subsystem
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /* #define GST_DEBUG_ENABLED */
  24 #include "gst_private.h"
  25
  26 #include "gstcaps.h"
  27 #include "gsttype.h"
  28
  29 #include "gstpropsprivate.h"
  30
  31 static GMemChunk *_gst_caps_chunk;
  32 static GMutex *_gst_caps_chunk_lock;
  33
  34 void
  35 _gst_caps_initialize (void)
  36 {
  37   _gst_caps_chunk = g_mem_chunk_new ("GstCaps",
  38                   sizeof (GstCaps), sizeof (GstCaps) * 256,
  39                   G_ALLOC_AND_FREE);
  40   _gst_caps_chunk_lock = g_mutex_new ();
  41 }
  42
  43 static guint16
  44 get_type_for_mime (const gchar *mime)
  45 {
  46   guint16 typeid;
  47
  48   typeid = gst_type_find_by_mime (mime);
  49   if (typeid == 0) {
  50      GstTypeDefinition definition;
  51      GstTypeFactory *factory;
  52
  53      definition.name = "capstype";
  54      definition.mime = g_strdup (mime);
  55      definition.exts = NULL;
  56      definition.typefindfunc = NULL;
  57
  58      factory = gst_typefactory_new (&definition);
  59
  60      typeid = gst_type_register (factory);
  61   }
  62   return typeid;
  63 }
  64
  65 /**
  66  * gst_caps_new:
  67  * @name: the name of this capability
  68  * @mime: the mime type to attach to the capability
  69  * @props: the properties to add to this capability
  70  *
  71  * Create a new capability with the given mime typei and properties.
  72  *
  73  * Returns: a new capability
  74  */
  75 GstCaps*
  76 gst_caps_new (const gchar *name, const gchar *mime, GstProps *props)
  77 {
  78   g_return_val_if_fail (mime != NULL, NULL);
  79
  80   return gst_caps_new_id (name, get_type_for_mime (mime), props);
  81 }
  82
  83 /**
  84  * gst_caps_new_id:
  85  * @name: the name of this capability
  86  * @id: the id of the mime type
  87  * @props: the properties to add to this capability
  88  *
  89  * Create a new capability with the given mime typeid and properties.
  90  *
  91  * Returns: a new capability
  92  */
  93 GstCaps*
  94 gst_caps_new_id (const gchar *name, const guint16 id, GstProps *props)
  95 {
  96   GstCaps *caps;
  97
  98   g_mutex_lock (_gst_caps_chunk_lock);
  99   caps = g_mem_chunk_alloc (_gst_caps_chunk);
 100   g_mutex_unlock (_gst_caps_chunk_lock);
 101
 102   caps->name = g_strdup (name);
 103   caps->id = id;
 104   caps->properties = props;
 105   caps->next = NULL;
 106   caps->refcount = 1;
 107   caps->lock = g_mutex_new ();
 108   if (props)
 109     caps->fixed = props->fixed;
 110   else
 111     caps->fixed = TRUE;
 112
 113   return caps;
 114 }
 115
 116 /**
 117  * gst_caps_destroy:
 118  * @caps: the caps to destroy
 119  *
 120  * Frees the memory used by this caps structure and all
 121  * the chained caps and properties.
 122  */
 123 void
 124 gst_caps_destroy (GstCaps *caps)
 125 {
 126   GstCaps *next;
 127
 128   if (caps == NULL)
 129     return;
 130
 131   GST_CAPS_LOCK (caps);
 132   next = caps->next;
 133   GST_CAPS_UNLOCK (caps);
 134
 135   g_mutex_free (caps->lock);
 136   gst_props_unref (caps->properties);
 137   g_free (caps->name);
 138   g_mutex_lock (_gst_caps_chunk_lock);
 139   g_mem_chunk_free (_gst_caps_chunk, caps);
 140   g_mutex_unlock (_gst_caps_chunk_lock);
 141
 142   if (next)
 143     gst_caps_unref (next);
 144 }
 145
 146 void
 147 gst_caps_debug (GstCaps *caps)
 148 {
 149   GST_DEBUG_ENTER ("caps debug");
 150   while (caps) {
 151     GST_DEBUG (GST_CAT_CAPS, "caps: %p %s %s\n", caps, caps->name, gst_caps_get_mime (caps));
 152
 153     if (caps->properties) {
 154       gst_props_debug (caps->properties);
 155     }
 156     else {
 157       GST_DEBUG (GST_CAT_CAPS, "no properties\n");
 158     }
 159
 160     caps = caps->next;
 161   }
 162   GST_DEBUG_LEAVE ("caps debug");
 163 }
 164
 165 /**
 166  * gst_caps_unref:
 167  * @caps: the caps to unref
 168  *
 169  * Decrease the refcount of this caps structure,
 170  * destroying it when the refcount is 0
 171  *
 172  * Returns: caps or NULL if the refcount reached 0
 173  */
 174 GstCaps*
 175 gst_caps_unref (GstCaps *caps)
 176 {
 177   gboolean zero;
 178   GstCaps **next;
 179
 180   if (caps == NULL)
 181     return NULL;
 182
 183   g_return_val_if_fail (caps->refcount > 0, NULL);
 184
 185   GST_CAPS_LOCK (caps);
 186   caps->refcount--;
 187   zero = (caps->refcount == 0);
 188   next = &caps->next;
 189   GST_CAPS_UNLOCK (caps);
 190
 191   if (*next)
 192     *next = gst_caps_unref (*next);
 193
 194   if (zero) {
 195     gst_caps_destroy (caps);
 196     caps = NULL;
 197   }
 198   return caps;
 199 }
 200
 201 /**
 202  * gst_caps_ref:
 203  * @caps: the caps to ref
 204  *
 205  * Increase the refcount of this caps structure
 206  *
 207  * Returns: the caps with the refcount incremented
 208  */
 209 GstCaps*
 210 gst_caps_ref (GstCaps *caps)
 211 {
 212   g_return_val_if_fail (caps != NULL, NULL);
 213
 214   GST_CAPS_LOCK (caps);
 215   caps->refcount++;
 216   GST_CAPS_UNLOCK (caps);
 217
 218   return caps;
 219 }
 220
 221 /**
 222  * gst_caps_copy:
 223  * @caps: the caps to copy
 224  *
 225  * Copies the caps.
 226  *
 227  * Returns: a copy of the GstCaps structure.
 228  */
 229 GstCaps*
 230 gst_caps_copy (GstCaps *caps)
 231 {
 232   GstCaps *new = NULL, *walk = NULL;
 233
 234   while (caps) {
 235     GstCaps *newcaps;
 236
 237     newcaps = gst_caps_new_id (
 238                   caps->name,
 239                   caps->id,
 240                   gst_props_copy (caps->properties));
 241
 242     if (new == NULL) {
 243       new = walk = newcaps;
 244     }
 245     else {
 246       walk = walk->next = newcaps;
 247     }
 248     caps = caps->next;
 249   }
 250
 251   return new;
 252 }
 253
 254 /**
 255  * gst_caps_copy_on_write:
 256  * @caps: the caps to copy
 257  *
 258  * Copies the caps if the refcount is greater than 1
 259  *
 260  * Returns: a pointer to a GstCaps strcuture that can
 261  * be safely written to
 262  */
 263 GstCaps*
 264 gst_caps_copy_on_write (GstCaps *caps)
 265 {
 266   GstCaps *new = caps;
 267   gboolean needcopy;
 268
 269   g_return_val_if_fail (caps != NULL, NULL);
 270
 271   GST_CAPS_LOCK (caps);
 272   needcopy = (caps->refcount > 1);
 273   GST_CAPS_UNLOCK (caps);
 274
 275   if (needcopy) {
 276     new = gst_caps_copy (caps);
 277     gst_caps_unref (caps);
 278   }
 279
 280   return new;
 281 }
 282
 283 /**
 284  * gst_caps_get_name:
 285  * @caps: the caps to get the name from
 286  *
 287  * Get the name of a GstCaps structure.
 288  *
 289  * Returns: the name of the caps
 290  */
 291 const gchar*
 292 gst_caps_get_name (GstCaps *caps)
 293 {
 294   g_return_val_if_fail (caps != NULL, NULL);
 295
 296   return (const gchar *)caps->name;
 297 }
 298
 299 /**
 300  * gst_caps_set_name:
 301  * @caps: the caps to set the name to
 302  * @name: the name to set
 303  *
 304  * Set the name of a caps.
 305  */
 306 void
 307 gst_caps_set_name (GstCaps *caps, const gchar *name)
 308 {
 309   g_return_if_fail (caps != NULL);
 310
 311   if (caps->name)
 312     g_free (caps->name);
 313
 314   caps->name = g_strdup (name);
 315 }
 316
 317 /**
 318  * gst_caps_get_mime:
 319  * @caps: the caps to get the mime type from
 320  *
 321  * Get the mime type of the caps as a string.
 322  *
 323  * Returns: the mime type of the caps
 324  */
 325 const gchar*
 326 gst_caps_get_mime (GstCaps *caps)
 327 {
 328   GstType *type;
 329
 330   g_return_val_if_fail (caps != NULL, NULL);
 331
 332   type = gst_type_find_by_id (caps->id);
 333
 334   if (type)
 335     return type->mime;
 336   else
 337     return "unknown/unknown";
 338 }
 339
 340 /**
 341  * gst_caps_set_mime:
 342  * @caps: the caps to set the mime type to
 343  * @mime: the mime type to attach to the caps
 344  *
 345  * Set the mime type of the caps as a string.
 346  */
 347 void
 348 gst_caps_set_mime (GstCaps *caps, const gchar *mime)
 349 {
 350   g_return_if_fail (caps != NULL);
 351   g_return_if_fail (mime != NULL);
 352
 353   caps->id = get_type_for_mime (mime);
 354 }
 355
 356 /**
 357  * gst_caps_get_type_id:
 358  * @caps: the caps to get the type id from
 359  *
 360  * Get the type id of the caps.
 361  *
 362  * Returns: the type id of the caps
 363  */
 364 guint16
 365 gst_caps_get_type_id (GstCaps *caps)
 366 {
 367   g_return_val_if_fail (caps != NULL, 0);
 368
 369   return caps->id;
 370 }
 371
 372 /**
 373  * gst_caps_set_type_id:
 374  * @caps: the caps to set the type id to
 375  * @type_id: the type id to set
 376  *
 377  * Set the type id of the caps.
 378  */
 379 void
 380 gst_caps_set_type_id (GstCaps *caps, guint16 type_id)
 381 {
 382   g_return_if_fail (caps != NULL);
 383
 384   caps->id = type_id;
 385 }
 386
 387 /**
 388  * gst_caps_set_props:
 389  * @caps: the caps to attach the properties to
 390  * @props: the properties to attach
 391  *
 392  * Set the properties to the given caps.
 393  *
 394  * Returns: the new caps structure
 395  */
 396 GstCaps*
 397 gst_caps_set_props (GstCaps *caps, GstProps *props)
 398 {
 399   g_return_val_if_fail (caps != NULL, caps);
 400   g_return_val_if_fail (props != NULL, caps);
 401   g_return_val_if_fail (caps->properties == NULL, caps);
 402
 403   caps->properties = props;
 404
 405   return caps;
 406 }
 407
 408 /**
 409  * gst_caps_get_props:
 410  * @caps: the caps to get the properties from
 411  *
 412  * Get the properties of the given caps.
 413  *
 414  * Returns: the properties of the caps
 415  */
 416 GstProps*
 417 gst_caps_get_props (GstCaps *caps)
 418 {
 419   g_return_val_if_fail (caps != NULL, NULL);
 420
 421   return caps->properties;
 422 }
 423
 424 /**
 425  * gst_caps_chain:
 426  * @caps: a capabilty
 427  * @...: more capabilities
 428  *
 429  * chains the given capabilities
 430  *
 431  * Returns: the new capability
 432  */
 433 GstCaps*
 434 gst_caps_chain (GstCaps *caps, ...)
 435 {
 436   GstCaps *orig = caps;
 437   va_list var_args;
 438
 439   va_start (var_args, caps);
 440
 441   while (caps) {
 442     GstCaps *toadd;
 443
 444     toadd = va_arg (var_args, GstCaps*);
 445     gst_caps_append (caps, toadd);
 446
 447     caps = toadd;
 448   }
 449   va_end (var_args);
 450
 451   return orig;
 452 }
 453
 454 /**
 455  * gst_caps_append:
 456  * @caps: a capabilty
 457  * @capstoadd: the capability to append
 458  *
 459  * Appends a capability to the existing capability.
 460  *
 461  * Returns: the new capability
 462  */
 463 GstCaps*
 464 gst_caps_append (GstCaps *caps, GstCaps *capstoadd)
 465 {
 466   GstCaps *orig = caps;
 467
 468   g_return_val_if_fail (caps != capstoadd, caps);
 469
 470   if (caps == NULL)
 471     return capstoadd;
 472
 473   while (caps->next) {
 474     caps = caps->next;
 475   }
 476   caps->next = capstoadd;
 477
 478   return orig;
 479 }
 480
 481 /**
 482  * gst_caps_prepend:
 483  * @caps: a capabilty
 484  * @capstoadd: a capabilty to prepend
 485  *
 486  * prepend the capability to the list of capabilities
 487  *
 488  * Returns: the new capability
 489  */
 490 GstCaps*
 491 gst_caps_prepend (GstCaps *caps, GstCaps *capstoadd)
 492 {
 493   GstCaps *orig = capstoadd;
 494
 495   if (capstoadd == NULL)
 496     return caps;
 497
 498   g_return_val_if_fail (caps != capstoadd, caps);
 499
 500   while (capstoadd->next) {
 501     capstoadd = capstoadd->next;
 502   }
 503   capstoadd->next = caps;
 504
 505   return orig;
 506 }
 507
 508 /**
 509  * gst_caps_get_by_name:
 510  * @caps: a capabilty
 511  * @name: the name of the capability to get
 512  *
 513  * Get the capability with the given name from this
 514  * chain of capabilities.
 515  *
 516  * Returns: the first capability in the chain with the
 517  * given name
 518  */
 519 GstCaps*
 520 gst_caps_get_by_name (GstCaps *caps, const gchar *name)
 521 {
 522   g_return_val_if_fail (caps != NULL, NULL);
 523   g_return_val_if_fail (name != NULL, NULL);
 524
 525   while (caps) {
 526     if (!strcmp (caps->name, name))
 527       return caps;
 528     caps = caps->next;
 529   }
 530
 531   return NULL;
 532 }
 533
 534 static gboolean
 535 gst_caps_check_compatibility_func (GstCaps *fromcaps, GstCaps *tocaps)
 536 {
 537   if (fromcaps->id != tocaps->id) {
 538     GST_DEBUG (GST_CAT_CAPS,"mime types differ (%s to %s)\n",
 539                gst_type_find_by_id (fromcaps->id)->mime,
 540                gst_type_find_by_id (tocaps->id)->mime);
 541     return FALSE;
 542   }
 543
 544   if (tocaps->properties) {
 545     if (fromcaps->properties) {
 546       return gst_props_check_compatibility (fromcaps->properties, tocaps->properties);
 547     }
 548     else {
 549       GST_DEBUG (GST_CAT_CAPS,"no source caps\n");
 550       return FALSE;
 551     }
 552   }
 553   else {
 554     /* assume it accepts everything */
 555     GST_DEBUG (GST_CAT_CAPS,"no caps\n");
 556     return TRUE;
 557   }
 558 }
 559
 560 /**
 561  * gst_caps_check_compatibility:
 562  * @fromcaps: a capabilty
 563  * @tocaps: a capabilty
 564  *
 565  * Checks whether two capabilities are compatible.
 566  *
 567  * Returns: TRUE if compatible, FALSE otherwise
 568  */
 569 gboolean
 570 gst_caps_check_compatibility (GstCaps *fromcaps, GstCaps *tocaps)
 571 {
 572   if (fromcaps == NULL) {
 573     if (tocaps == NULL) {
 574       GST_DEBUG (GST_CAT_CAPS,"no caps\n");
 575       return TRUE;
 576     }
 577     else {
 578       GST_DEBUG (GST_CAT_CAPS,"no source but destination caps\n");
 579       return FALSE;
 580     }
 581   }
 582   else {
 583     if (tocaps == NULL) {
 584       GST_DEBUG (GST_CAT_CAPS,"source caps and no destination caps\n");
 585       return TRUE;
 586     }
 587   }
 588
 589   while (fromcaps) {
 590     GstCaps *destcaps = tocaps;
 591
 592     while (destcaps) {
 593       if (gst_caps_check_compatibility_func (fromcaps, destcaps))
 594         return TRUE;
 595
 596       destcaps =  destcaps->next;
 597     }
 598     fromcaps =  fromcaps->next;
 599   }
 600   return FALSE;
 601 }
 602
 603 static GstCaps*
 604 gst_caps_intersect_func (GstCaps *caps1, GstCaps *caps2)
 605 {
 606   GstCaps *result = NULL;
 607   GstProps *props;
 608
 609   if (caps1->id != caps2->id) {
 610     GST_DEBUG (GST_CAT_CAPS,"mime types differ (%s to %s)\n",
 611                gst_type_find_by_id (caps1->id)->mime,
 612                gst_type_find_by_id (caps2->id)->mime);
 613     return NULL;
 614   }
 615
 616   if (caps1->properties == NULL) {
 617     return gst_caps_ref (caps2);
 618   }
 619   if (caps2->properties == NULL) {
 620     return gst_caps_ref (caps1);
 621   }
 622
 623   props = gst_props_intersect (caps1->properties, caps2->properties);
 624   if (props) {
 625     result = gst_caps_new_id ("intersect", caps1->id, props);
 626   }
 627
 628   return result;
 629 }
 630
 631 /**
 632  * gst_caps_intersect:
 633  * @caps1: a capabilty
 634  * @caps2: a capabilty
 635  *
 636  * Make the intersection between two caps.
 637  *
 638  * Returns: The intersection of the two caps or NULL if the intersection
 639  * is empty.
 640  */
 641 GstCaps*
 642 gst_caps_intersect (GstCaps *caps1, GstCaps *caps2)
 643 {
 644   GstCaps *result = NULL, *walk = NULL;
 645
 646   if (caps1 == NULL) {
 647     GST_DEBUG (GST_CAT_CAPS, "first caps is NULL, return other caps\n");
 648     return gst_caps_copy (caps2);
 649   }
 650   if (caps2 == NULL) {
 651     GST_DEBUG (GST_CAT_CAPS, "second caps is NULL, return other caps\n");
 652     return gst_caps_copy (caps1);
 653   }
 654
 655   while (caps1) {
 656     GstCaps *othercaps = caps2;
 657
 658     while (othercaps) {
 659       GstCaps *intersection = gst_caps_intersect_func (caps1, othercaps);
 660
 661       if (intersection) {
 662         if (!result) {
 663           walk = result = intersection;
 664         }
 665         else {
 666           walk = walk->next = intersection;
 667         }
 668       }
 669       othercaps = othercaps->next;
 670     }
 671     caps1 =  caps1->next;
 672   }
 673
 674   return result;
 675 }
 676
 677 GstCaps*
 678 gst_caps_normalize (GstCaps *caps)
 679 {
 680   GstCaps *result = NULL, *walk = caps;
 681
 682   if (caps == NULL)
 683     return caps;
 684
 685   while (caps) {
 686     GList *proplist;
 687
 688     proplist = gst_props_normalize (caps->properties);
 689     if (proplist && g_list_next (proplist) == NULL) {
 690       if (result == NULL)
 691         walk = result = caps;
 692       else {
 693         walk = walk->next = caps;
 694       }
 695       goto next;
 696     }
 697
 698     while (proplist) {
 699       GstProps *props = (GstProps *) proplist->data;
 700       GstCaps *newcaps = gst_caps_new_id (caps->name, caps->id, props);
 701
 702       if (result == NULL)
 703         walk = result = newcaps;
 704       else {
 705         walk = walk->next = newcaps;
 706       }
 707       proplist = g_list_next (proplist);
 708     }
 709 next:
 710     caps = caps->next;
 711   }
 712   return result;
 713 }
 714
 715 #ifndef GST_DISABLE_LOADSAVE_REGISTRY
 716 /**
 717  * gst_caps_save_thyself:
 718  * @caps: a capabilty to save
 719  * @parent: the parent XML node pointer
 720  *
 721  * Save the capability into an XML representation.
 722  *
 723  * Returns: a new XML node pointer
 724  */
 725 xmlNodePtr
 726 gst_caps_save_thyself (GstCaps *caps, xmlNodePtr parent)
 727 {
 728   xmlNodePtr subtree;
 729   xmlNodePtr subsubtree;
 730
 731   while (caps) {
 732     subtree = xmlNewChild (parent, NULL, "capscomp", NULL);
 733
 734     xmlNewChild (subtree, NULL, "name", caps->name);
 735     xmlNewChild (subtree, NULL, "type", gst_type_find_by_id (caps->id)->mime);
 736     if (caps->properties) {
 737       subsubtree = xmlNewChild (subtree, NULL, "properties", NULL);
 738
 739       gst_props_save_thyself (caps->properties, subsubtree);
 740     }
 741
 742     caps = caps->next;
 743   }
 744
 745   return parent;
 746 }
 747
 748 /**
 749  * gst_caps_load_thyself:
 750  * @parent: the parent XML node pointer
 751  *
 752  * Load a new caps from the XML representation.
 753  *
 754  * Returns: a new capability
 755  */
 756 GstCaps*
 757 gst_caps_load_thyself (xmlNodePtr parent)
 758 {
 759   GstCaps *result = NULL;
 760   xmlNodePtr field = parent->xmlChildrenNode;
 761
 762   while (field) {
 763     if (!strcmp (field->name, "capscomp")) {
 764       xmlNodePtr subfield = field->xmlChildrenNode;
 765       GstCaps *caps;
 766       gchar *content;
 767
 768       g_mutex_lock (_gst_caps_chunk_lock);
 769       caps = g_mem_chunk_alloc0 (_gst_caps_chunk);
 770       g_mutex_unlock (_gst_caps_chunk_lock);
 771
 772       caps->refcount = 1;
 773       caps->lock = g_mutex_new ();
 774       caps->next = NULL;
 775       caps->fixed = TRUE;
 776
 777       while (subfield) {
 778         if (!strcmp (subfield->name, "name")) {
 779           caps->name = xmlNodeGetContent (subfield);
 780         }
 781         if (!strcmp (subfield->name, "type")) {
 782           content = xmlNodeGetContent (subfield);
 783           caps->id = get_type_for_mime (content);
 784           g_free (content);
 785         }
 786         else if (!strcmp (subfield->name, "properties")) {
 787           caps->properties = gst_props_load_thyself (subfield);
 788         }
 789
 790         subfield = subfield->next;
 791       }
 792       result = gst_caps_append (result, caps);
 793     }
 794     field = field->next;
 795   }
 796
 797   return result;
 798 }
 799
 800 #endif /* GST_DISABLE_LOADSAVE_REGISTRY */