gst-libs/gst/riff/riff-media.c

   1 /* GStreamer RIFF I/O
   2  * Copyright (C) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
   3  *
   4  * riff-media.h: RIFF-id to/from caps routines
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include "riff-ids.h"
  27 #include "riff-media.h"
  28
  29 #include <gst/audio/multichannel.h>
  30
  31 #include <string.h>
  32 #include <math.h>
  33
  34 GST_DEBUG_CATEGORY_EXTERN (riff_debug);
  35 #define GST_CAT_DEFAULT riff_debug
  36
  37 /**
  38  * gst_riff_create_video_caps:
  39  * @codec_fcc: fourCC codec for this codec.
  40  * @strh: pointer to the strh stream header structure.
  41  * @strf: pointer to the strf stream header structure, including any
  42  *        data that is within the range of strf.size, but excluding any
  43  *        additional data withint this chunk but outside strf.size.
  44  * @strf_data: a #GstBuffer containing the additional data in the strf
  45  *             chunk outside reach of strf.size. Ususally a palette.
  46  * @strd_data: a #GstBuffer containing the data in the strd stream header
  47  *             chunk. Usually codec initialization data.
  48  * @codec_name: if given, will be filled with a human-readable codec name.
  49  */
  50
  51 GstCaps *
  52 gst_riff_create_video_caps (guint32 codec_fcc,
  53     gst_riff_strh * strh, gst_riff_strf_vids * strf,
  54     GstBuffer * strf_data, GstBuffer * strd_data, char **codec_name)
  55 {
  56   GstCaps *caps = NULL;
  57   GstBuffer *palette = NULL;
  58
  59   GST_DEBUG ("video fourcc %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (codec_fcc));
  60
  61   switch (codec_fcc) {
  62     case GST_MAKE_FOURCC ('D', 'I', 'B', ' '): /* uncompressed RGB */
  63     //case GST_MAKE_FOURCC (0x00, 0x00, 0x00, 0x00):   /*Commented so that FOURCC 0000 doesn't get detected as RGB format. ALso no standard for FOURCC 0000 */
  64     case GST_MAKE_FOURCC ('R', 'G', 'B', ' '):
  65     case GST_MAKE_FOURCC ('R', 'A', 'W', ' '):
  66     {
  67       gint bpp = (strf && strf->bit_cnt != 0) ? strf->bit_cnt : 8;
  68
  69       if (strf) {
  70         if (bpp == 8) {
  71           caps = gst_caps_new_simple ("video/x-raw-rgb",
  72               "bpp", G_TYPE_INT, 8, "depth", G_TYPE_INT, 8,
  73               "endianness", G_TYPE_INT, G_BYTE_ORDER, NULL);
  74         } else if (bpp == 24) {
  75           caps = gst_caps_new_simple ("video/x-raw-rgb",
  76               "bpp", G_TYPE_INT, 24, "depth", G_TYPE_INT, 24,
  77               "endianness", G_TYPE_INT, G_BIG_ENDIAN,
  78               "red_mask", G_TYPE_INT, 0xff, "green_mask", G_TYPE_INT, 0xff00,
  79               "blue_mask", G_TYPE_INT, 0xff0000, NULL);
  80         } else if (bpp == 32) {
  81           caps = gst_caps_new_simple ("video/x-raw-rgb",
  82               "bpp", G_TYPE_INT, 32, "depth", G_TYPE_INT, 24,
  83               "endianness", G_TYPE_INT, G_BIG_ENDIAN,
  84               "red_mask", G_TYPE_INT, 0xff00, "green_mask", G_TYPE_INT,
  85               0xff0000, "blue_mask", G_TYPE_INT, 0xff000000, NULL);
  86         } else {
  87           GST_WARNING ("Unhandled DIB RGB depth: %d", bpp);
  88           return NULL;
  89         }
  90       } else {
  91         /* for template */
  92         caps =
  93             gst_caps_from_string ("video/x-raw-rgb, bpp = (int) { 8, 24, 32 }, "
  94             "depth = (int) { 8, 24}");
  95       }
  96
  97       palette = strf_data;
  98       strf_data = NULL;
  99       if (codec_name) {
 100         if (bpp == 8)
 101           *codec_name = g_strdup_printf ("Palettized %d-bit RGB", bpp);
 102         else
 103           *codec_name = g_strdup_printf ("%d-bit RGB", bpp);
 104       }
 105       break;
 106     }
 107     case GST_MAKE_FOURCC ('I', '4', '2', '0'):
 108       caps = gst_caps_new_simple ("video/x-raw-yuv",
 109           "format", GST_TYPE_FOURCC, codec_fcc, NULL);
 110       if (codec_name)
 111         *codec_name = g_strdup ("Uncompressed planar YUV 4:2:0");
 112       break;
 113
 114     case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
 115     case GST_MAKE_FOURCC ('Y', 'U', 'N', 'V'):
 116       caps = gst_caps_new_simple ("video/x-raw-yuv",
 117           "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'),
 118           NULL);
 119       if (codec_name)
 120         *codec_name = g_strdup ("Uncompressed packed YUV 4:2:2");
 121       break;
 122
 123     case GST_MAKE_FOURCC ('Y', 'V', 'U', '9'):
 124       caps = gst_caps_new_simple ("video/x-raw-yuv",
 125           "format", GST_TYPE_FOURCC, codec_fcc, NULL);
 126       if (codec_name)
 127         *codec_name = g_strdup ("Uncompressed packed YVU 4:1:0");
 128       break;
 129
 130     case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
 131     case GST_MAKE_FOURCC ('2', 'v', 'u', 'y'):
 132       caps = gst_caps_new_simple ("video/x-raw-yuv",
 133           "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'),
 134           NULL);
 135       if (codec_name)
 136         *codec_name = g_strdup ("Uncompressed packed YUV 4:2:2");
 137       break;
 138
 139     case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
 140       caps = gst_caps_new_simple ("video/x-raw-yuv",
 141           "format", GST_TYPE_FOURCC, codec_fcc, NULL);
 142       if (codec_name)
 143         *codec_name = g_strdup ("Uncompressed packed YVU 4:2:2");
 144       break;
 145
 146     case GST_MAKE_FOURCC ('M', 'J', 'P', 'G'): /* YUY2 MJPEG */
 147     case GST_MAKE_FOURCC ('A', 'V', 'R', 'n'):
 148     case GST_MAKE_FOURCC ('I', 'J', 'P', 'G'):
 149     case GST_MAKE_FOURCC ('i', 'j', 'p', 'g'):
 150     case GST_MAKE_FOURCC ('d', 'm', 'b', '1'):
 151     case GST_MAKE_FOURCC ('A', 'C', 'D', 'V'):
 152     case GST_MAKE_FOURCC ('Q', 'I', 'V', 'G'):
 153       caps = gst_caps_new_simple ("image/jpeg", NULL);
 154       if (codec_name)
 155         *codec_name = g_strdup ("Motion JPEG");
 156       break;
 157
 158     case GST_MAKE_FOURCC ('J', 'P', 'E', 'G'): /* generic (mostly RGB) MJPEG */
 159     case GST_MAKE_FOURCC ('j', 'p', 'e', 'g'): /* generic (mostly RGB) MJPEG */
 160       caps = gst_caps_new_simple ("image/jpeg", NULL);
 161       if (codec_name)
 162         *codec_name = g_strdup ("JPEG Still Image");
 163       break;
 164
 165     case GST_MAKE_FOURCC ('P', 'I', 'X', 'L'): /* Miro/Pinnacle fourccs */
 166     case GST_MAKE_FOURCC ('V', 'I', 'X', 'L'): /* Miro/Pinnacle fourccs */
 167       caps = gst_caps_new_simple ("image/jpeg", NULL);
 168       if (codec_name)
 169         *codec_name = g_strdup ("Miro/Pinnacle Motion JPEG");
 170       break;
 171
 172     case GST_MAKE_FOURCC ('C', 'J', 'P', 'G'):
 173       caps = gst_caps_new_simple ("image/jpeg", NULL);
 174       if (codec_name)
 175         *codec_name = g_strdup ("Creative Webcam JPEG");
 176       break;
 177
 178     case GST_MAKE_FOURCC ('S', 'L', 'M', 'J'):
 179       caps = gst_caps_new_simple ("image/jpeg", NULL);
 180       if (codec_name)
 181         *codec_name = g_strdup ("SL Motion JPEG");
 182       break;
 183
 184     case GST_MAKE_FOURCC ('J', 'P', 'G', 'L'):
 185       caps = gst_caps_new_simple ("image/jpeg", NULL);
 186       if (codec_name)
 187         *codec_name = g_strdup ("Pegasus Lossless JPEG");
 188       break;
 189
 190     case GST_MAKE_FOURCC ('L', 'O', 'C', 'O'):
 191       caps = gst_caps_new_simple ("video/x-loco", NULL);
 192       if (codec_name)
 193         *codec_name = g_strdup ("LOCO Lossless");
 194       break;
 195
 196     case GST_MAKE_FOURCC ('S', 'P', '5', '3'):
 197     case GST_MAKE_FOURCC ('S', 'P', '5', '4'):
 198     case GST_MAKE_FOURCC ('S', 'P', '5', '5'):
 199     case GST_MAKE_FOURCC ('S', 'P', '5', '6'):
 200     case GST_MAKE_FOURCC ('S', 'P', '5', '7'):
 201     case GST_MAKE_FOURCC ('S', 'P', '5', '8'):
 202       caps = gst_caps_new_simple ("video/sp5x", NULL);
 203       if (codec_name)
 204         *codec_name = g_strdup ("Sp5x-like JPEG");
 205       break;
 206
 207     case GST_MAKE_FOURCC ('Z', 'M', 'B', 'V'):
 208       caps = gst_caps_new_simple ("video/x-zmbv", NULL);
 209       if (codec_name)
 210         *codec_name = g_strdup ("Zip Motion Block video");
 211       break;
 212
 213     case GST_MAKE_FOURCC ('H', 'F', 'Y', 'U'):
 214       caps = gst_caps_new_simple ("video/x-huffyuv", NULL);
 215       if (strf) {
 216         gst_caps_set_simple (caps, "bpp",
 217             G_TYPE_INT, (int) strf->bit_cnt, NULL);
 218       }
 219       if (codec_name)
 220         *codec_name = g_strdup ("Huffman Lossless Codec");
 221       break;
 222
 223     case GST_MAKE_FOURCC ('M', 'P', 'E', 'G'):
 224     case GST_MAKE_FOURCC ('M', 'P', 'G', 'I'):
 225     case GST_MAKE_FOURCC ('m', 'p', 'g', '1'):
 226     case GST_MAKE_FOURCC ('M', 'P', 'G', '1'):
 227     case GST_MAKE_FOURCC ('P', 'I', 'M', '1'):
 228     case GST_MAKE_FOURCC (0x01, 0x00, 0x00, 0x10):
 229       caps = gst_caps_new_simple ("video/mpeg",
 230           "systemstream", G_TYPE_BOOLEAN, FALSE,
 231           "mpegversion", G_TYPE_INT, 1, NULL);
 232       if (codec_name)
 233         *codec_name = g_strdup ("MPEG-1 video");
 234       break;
 235
 236     case GST_MAKE_FOURCC ('M', 'P', 'G', '2'):
 237     case GST_MAKE_FOURCC ('m', 'p', 'g', '2'):
 238     case GST_MAKE_FOURCC ('P', 'I', 'M', '2'):
 239     case GST_MAKE_FOURCC ('D', 'V', 'R', ' '):
 240     case GST_MAKE_FOURCC (0x02, 0x00, 0x00, 0x10):
 241       caps = gst_caps_new_simple ("video/mpeg",
 242           "systemstream", G_TYPE_BOOLEAN, FALSE,
 243           "mpegversion", G_TYPE_INT, 2, NULL);
 244       if (codec_name)
 245         *codec_name = g_strdup ("MPEG-2 video");
 246       break;
 247
 248     case GST_MAKE_FOURCC ('L', 'M', 'P', '2'):
 249       caps = gst_caps_new_simple ("video/mpeg",
 250           "systemstream", G_TYPE_BOOLEAN, FALSE,
 251           "mpegversion", G_TYPE_INT, 2, NULL);
 252       if (codec_name)
 253         *codec_name = g_strdup ("Lead MPEG-2 video");
 254       break;
 255
 256     case GST_MAKE_FOURCC ('H', '2', '6', '3'):
 257     case GST_MAKE_FOURCC ('h', '2', '6', '3'):
 258     case GST_MAKE_FOURCC ('i', '2', '6', '3'):
 259     case GST_MAKE_FOURCC ('U', '2', '6', '3'):
 260     case GST_MAKE_FOURCC ('v', 'i', 'v', '1'):
 261     case GST_MAKE_FOURCC ('T', '2', '6', '3'):
 262       caps = gst_caps_new_simple ("video/x-h263",
 263           "variant", G_TYPE_STRING, "itu", NULL);
 264       if (codec_name)
 265         *codec_name = g_strdup ("ITU H.26n");
 266       break;
 267
 268     case GST_MAKE_FOURCC ('L', '2', '6', '3'):
 269       /* http://www.leadcodecs.com/Codecs/LEAD-H263.htm */
 270       caps = gst_caps_new_simple ("video/x-h263",
 271           "variant", G_TYPE_STRING, "lead", NULL);
 272       if (codec_name)
 273         *codec_name = g_strdup ("Lead H.263");
 274       break;
 275
 276     case GST_MAKE_FOURCC ('M', '2', '6', '3'):
 277     case GST_MAKE_FOURCC ('m', '2', '6', '3'):
 278       caps = gst_caps_new_simple ("video/x-h263",
 279           "variant", G_TYPE_STRING, "microsoft", NULL);
 280       if (codec_name)
 281         *codec_name = g_strdup ("Microsoft H.263");
 282       break;
 283
 284     case GST_MAKE_FOURCC ('V', 'D', 'O', 'W'):
 285       caps = gst_caps_new_simple ("video/x-h263",
 286           "variant", G_TYPE_STRING, "vdolive", NULL);
 287       if (codec_name)
 288         *codec_name = g_strdup ("VDOLive");
 289       break;
 290
 291     case GST_MAKE_FOURCC ('V', 'I', 'V', 'O'):
 292       caps = gst_caps_new_simple ("video/x-h263",
 293           "variant", G_TYPE_STRING, "vivo", NULL);
 294       if (codec_name)
 295         *codec_name = g_strdup ("Vivo H.263");
 296       break;
 297
 298     case GST_MAKE_FOURCC ('x', '2', '6', '3'):
 299       caps = gst_caps_new_simple ("video/x-h263",
 300           "variant", G_TYPE_STRING, "xirlink", NULL);
 301       if (codec_name)
 302         *codec_name = g_strdup ("Xirlink H.263");
 303       break;
 304
 305       /* apparently not standard H.263...? */
 306     case GST_MAKE_FOURCC ('I', '2', '6', '3'):
 307       caps = gst_caps_new_simple ("video/x-intel-h263",
 308           "variant", G_TYPE_STRING, "intel", NULL);
 309       if (codec_name)
 310         *codec_name = g_strdup ("Intel H.263");
 311       break;
 312
 313     case GST_MAKE_FOURCC ('V', 'X', '1', 'K'):
 314       caps = gst_caps_new_simple ("video/x-h263",
 315           "variant", G_TYPE_STRING, "lucent", NULL);
 316       if (codec_name)
 317         *codec_name = g_strdup ("Lucent VX1000S H.263");
 318       break;
 319
 320     case GST_MAKE_FOURCC ('X', '2', '6', '4'):
 321     case GST_MAKE_FOURCC ('x', '2', '6', '4'):
 322     case GST_MAKE_FOURCC ('H', '2', '6', '4'):
 323     case GST_MAKE_FOURCC ('h', '2', '6', '4'):
 324     case GST_MAKE_FOURCC ('a', 'v', 'c', '1'):
 325     case GST_MAKE_FOURCC ('A', 'V', 'C', '1'):
 326       caps = gst_caps_new_simple ("video/x-h264",
 327           "variant", G_TYPE_STRING, "itu", NULL);
 328       if (codec_name)
 329         *codec_name = g_strdup ("ITU H.264");
 330       break;
 331
 332     case GST_MAKE_FOURCC ('V', 'S', 'S', 'H'):
 333       caps = gst_caps_new_simple ("video/x-h264",
 334           "variant", G_TYPE_STRING, "videosoft", NULL);
 335       if (codec_name)
 336         *codec_name = g_strdup ("VideoSoft H.264");
 337       break;
 338
 339     case GST_MAKE_FOURCC ('L', '2', '6', '4'):
 340       /* http://www.leadcodecs.com/Codecs/LEAD-H264.htm */
 341       caps = gst_caps_new_simple ("video/x-h264",
 342           "variant", G_TYPE_STRING, "lead", NULL);
 343       if (codec_name)
 344         *codec_name = g_strdup ("Lead H.264");
 345       break;
 346
 347     case GST_MAKE_FOURCC ('S', 'E', 'D', 'G'):
 348       caps = gst_caps_new_simple ("video/mpeg",
 349           "mpegversion", G_TYPE_INT, 4, NULL);
 350       if (codec_name)
 351         *codec_name = g_strdup ("Samsung MPEG-4");
 352       break;
 353
 354     case GST_MAKE_FOURCC ('M', '4', 'C', 'C'):
 355       caps = gst_caps_new_simple ("video/mpeg",
 356           "mpegversion", G_TYPE_INT, 4, NULL);
 357       if (codec_name)
 358         *codec_name = g_strdup ("Divio MPEG-4");
 359       break;
 360
 361     case GST_MAKE_FOURCC ('D', 'I', 'V', '3'):
 362     case GST_MAKE_FOURCC ('d', 'i', 'v', '3'):
 363     case GST_MAKE_FOURCC ('D', 'V', 'X', '3'):
 364     case GST_MAKE_FOURCC ('d', 'v', 'x', '3'):
 365     case GST_MAKE_FOURCC ('D', 'I', 'V', '4'):
 366     case GST_MAKE_FOURCC ('d', 'i', 'v', '4'):
 367     case GST_MAKE_FOURCC ('D', 'I', 'V', '5'):
 368     case GST_MAKE_FOURCC ('d', 'i', 'v', '5'):
 369     case GST_MAKE_FOURCC ('D', 'I', 'V', '6'):
 370     case GST_MAKE_FOURCC ('d', 'i', 'v', '6'):
 371     case GST_MAKE_FOURCC ('M', 'P', 'G', '3'):
 372     case GST_MAKE_FOURCC ('m', 'p', 'g', '3'):
 373     case GST_MAKE_FOURCC ('c', 'o', 'l', '0'):
 374     case GST_MAKE_FOURCC ('C', 'O', 'L', '0'):
 375     case GST_MAKE_FOURCC ('c', 'o', 'l', '1'):
 376     case GST_MAKE_FOURCC ('C', 'O', 'L', '1'):
 377     case GST_MAKE_FOURCC ('A', 'P', '4', '1'):
 378       caps = gst_caps_new_simple ("video/x-divx",
 379           "divxversion", G_TYPE_INT, 3, NULL);
 380       if (codec_name)
 381         *codec_name = g_strdup ("DivX MS-MPEG-4 Version 3");
 382       break;
 383
 384     case GST_MAKE_FOURCC ('d', 'i', 'v', 'x'):
 385     case GST_MAKE_FOURCC ('D', 'I', 'V', 'X'):
 386       caps = gst_caps_new_simple ("video/x-divx",
 387           "divxversion", G_TYPE_INT, 4, NULL);
 388       if (codec_name)
 389         *codec_name = g_strdup ("DivX MPEG-4 Version 4");
 390       break;
 391
 392     case GST_MAKE_FOURCC ('B', 'L', 'Z', '0'):
 393       caps = gst_caps_new_simple ("video/x-divx",
 394           "divxversion", G_TYPE_INT, 4, NULL);
 395       if (codec_name)
 396         *codec_name = g_strdup ("Blizzard DivX");
 397       break;
 398
 399     case GST_MAKE_FOURCC ('D', 'X', '5', '0'):
 400       caps = gst_caps_new_simple ("video/x-divx",
 401           "divxversion", G_TYPE_INT, 5, NULL);
 402       if (codec_name)
 403         *codec_name = g_strdup ("DivX MPEG-4 Version 5");
 404       break;
 405
 406     case GST_MAKE_FOURCC ('X', 'V', 'I', 'D'):
 407     case GST_MAKE_FOURCC ('x', 'v', 'i', 'd'):
 408       caps = gst_caps_new_simple ("video/x-xvid", NULL);
 409       if (codec_name)
 410         *codec_name = g_strdup ("XVID MPEG-4");
 411       break;
 412
 413     case GST_MAKE_FOURCC ('R', 'M', 'P', '4'):
 414       caps = gst_caps_new_simple ("video/x-xvid", NULL);
 415       if (codec_name)
 416         *codec_name = g_strdup ("Sigma-Designs MPEG-4");
 417       break;
 418
 419     case GST_MAKE_FOURCC ('M', 'P', 'G', '4'):
 420     case GST_MAKE_FOURCC ('M', 'P', '4', '1'):
 421     case GST_MAKE_FOURCC ('m', 'p', '4', '1'):
 422       caps = gst_caps_new_simple ("video/x-msmpeg",
 423           "msmpegversion", G_TYPE_INT, 41, NULL);
 424       if (codec_name)
 425         *codec_name = g_strdup ("Microsoft MPEG-4 4.1");
 426       break;
 427
 428     case GST_MAKE_FOURCC ('m', 'p', '4', '2'):
 429     case GST_MAKE_FOURCC ('M', 'P', '4', '2'):
 430       caps = gst_caps_new_simple ("video/x-msmpeg",
 431           "msmpegversion", G_TYPE_INT, 42, NULL);
 432       if (codec_name)
 433         *codec_name = g_strdup ("Microsoft MPEG-4 4.2");
 434       break;
 435
 436     case GST_MAKE_FOURCC ('m', 'p', '4', '3'):
 437     case GST_MAKE_FOURCC ('M', 'P', '4', '3'):
 438       caps = gst_caps_new_simple ("video/x-msmpeg",
 439           "msmpegversion", G_TYPE_INT, 43, NULL);
 440       if (codec_name)
 441         *codec_name = g_strdup ("Microsoft MPEG-4 4.3");
 442       break;
 443
 444     case GST_MAKE_FOURCC ('M', 'P', '4', 'S'):
 445     case GST_MAKE_FOURCC ('M', '4', 'S', '2'):
 446       caps = gst_caps_new_simple ("video/mpeg",
 447           "mpegversion", G_TYPE_INT, 4, NULL);
 448       if (codec_name)
 449         *codec_name = g_strdup ("Microsoft ISO MPEG-4 1.1");
 450       break;
 451
 452     case GST_MAKE_FOURCC ('F', 'M', 'P', '4'):
 453     case GST_MAKE_FOURCC ('U', 'M', 'P', '4'):
 454     case GST_MAKE_FOURCC ('F', 'F', 'D', 'S'):
 455       caps = gst_caps_new_simple ("video/mpeg",
 456           "mpegversion", G_TYPE_INT, 4, NULL);
 457       if (codec_name)
 458         *codec_name = g_strdup ("FFmpeg MPEG-4");
 459       break;
 460
 461     case GST_MAKE_FOURCC ('E', 'M', '4', 'A'):
 462     case GST_MAKE_FOURCC ('E', 'P', 'V', 'H'):
 463     case GST_MAKE_FOURCC ('F', 'V', 'F', 'W'):
 464     case GST_MAKE_FOURCC ('I', 'N', 'M', 'C'):
 465     case GST_MAKE_FOURCC ('D', 'I', 'G', 'I'):
 466     case GST_MAKE_FOURCC ('D', 'M', '2', 'K'):
 467     case GST_MAKE_FOURCC ('D', 'C', 'O', 'D'):
 468     case GST_MAKE_FOURCC ('M', 'V', 'X', 'M'):
 469     case GST_MAKE_FOURCC ('P', 'M', '4', 'V'):
 470     case GST_MAKE_FOURCC ('S', 'M', 'P', '4'):
 471     case GST_MAKE_FOURCC ('D', 'X', 'G', 'M'):
 472     case GST_MAKE_FOURCC ('V', 'I', 'D', 'M'):
 473     case GST_MAKE_FOURCC ('M', '4', 'T', '3'):
 474     case GST_MAKE_FOURCC ('G', 'E', 'O', 'X'):
 475     case GST_MAKE_FOURCC ('M', 'P', '4', 'V'):
 476     case GST_MAKE_FOURCC ('m', 'p', '4', 'v'):
 477       caps = gst_caps_new_simple ("video/mpeg",
 478           "mpegversion", G_TYPE_INT, 4, NULL);
 479       if (codec_name)
 480         *codec_name = g_strdup ("MPEG-4");
 481       break;
 482
 483     case GST_MAKE_FOURCC ('3', 'i', 'v', 'd'):
 484     case GST_MAKE_FOURCC ('3', 'I', 'V', 'D'):
 485       caps = gst_caps_new_simple ("video/x-msmpeg",
 486           "msmpegversion", G_TYPE_INT, 43, NULL);
 487       if (codec_name)
 488         *codec_name = g_strdup ("Microsoft MPEG-4 4.3");        /* FIXME? */
 489       break;
 490
 491     case GST_MAKE_FOURCC ('3', 'I', 'V', '1'):
 492     case GST_MAKE_FOURCC ('3', 'I', 'V', '2'):
 493       caps = gst_caps_new_simple ("video/x-3ivx", NULL);
 494       if (codec_name)
 495         *codec_name = g_strdup ("3ivx");
 496       break;
 497
 498     case GST_MAKE_FOURCC ('D', 'V', 'S', 'D'):
 499     case GST_MAKE_FOURCC ('d', 'v', 's', 'd'):
 500     case GST_MAKE_FOURCC ('d', 'v', 'c', ' '):
 501     case GST_MAKE_FOURCC ('d', 'v', '2', '5'):
 502       caps = gst_caps_new_simple ("video/x-dv",
 503           "systemstream", G_TYPE_BOOLEAN, FALSE,
 504           "dvversion", G_TYPE_INT, 25, NULL);
 505       if (codec_name)
 506         *codec_name = g_strdup ("Generic DV");
 507       break;
 508
 509     case GST_MAKE_FOURCC ('C', 'D', 'V', 'C'):
 510     case GST_MAKE_FOURCC ('c', 'd', 'v', 'c'):
 511       caps = gst_caps_new_simple ("video/x-dv",
 512           "systemstream", G_TYPE_BOOLEAN, FALSE,
 513           "dvversion", G_TYPE_INT, 25, NULL);
 514       if (codec_name)
 515         *codec_name = g_strdup ("Canopus DV");
 516       break;
 517
 518     case GST_MAKE_FOURCC ('D', 'V', '5', '0'):
 519     case GST_MAKE_FOURCC ('d', 'v', '5', '0'):
 520       caps = gst_caps_new_simple ("video/x-dv",
 521           "systemstream", G_TYPE_BOOLEAN, FALSE,
 522           "dvversion", G_TYPE_INT, 50, NULL);
 523       if (codec_name)
 524         *codec_name = g_strdup ("DVCPro50 Video");
 525       break;
 526
 527     case GST_MAKE_FOURCC ('W', 'M', 'V', '1'):
 528       caps = gst_caps_new_simple ("video/x-wmv",
 529           "wmvversion", G_TYPE_INT, 1, NULL);
 530       if (codec_name)
 531         *codec_name = g_strdup ("Microsoft Windows Media 7");
 532       break;
 533
 534     case GST_MAKE_FOURCC ('W', 'M', 'V', '2'):
 535       caps = gst_caps_new_simple ("video/x-wmv",
 536           "wmvversion", G_TYPE_INT, 2, NULL);
 537       if (codec_name)
 538         *codec_name = g_strdup ("Microsoft Windows Media 8");
 539       break;
 540
 541     case GST_MAKE_FOURCC ('W', 'M', 'V', '3'):
 542       caps = gst_caps_new_simple ("video/x-wmv",
 543           "wmvversion", G_TYPE_INT, 3, NULL);
 544       if (codec_name)
 545         *codec_name = g_strdup ("Microsoft Windows Media 9");
 546       break;
 547
 548     case GST_MAKE_FOURCC ('W', 'M', 'V', 'A'):
 549       caps = gst_caps_new_simple ("video/x-wmv",
 550           "wmvversion", G_TYPE_INT, 3, "format", GST_TYPE_FOURCC,
 551           codec_fcc, NULL);
 552       if (codec_name)
 553         *codec_name = g_strdup ("Microsoft Windows Media Advanced Profile");
 554       break;
 555
 556     case GST_MAKE_FOURCC ('W', 'V', 'C', '1'):
 557       caps = gst_caps_new_simple ("video/x-wmv",
 558           "wmvversion", G_TYPE_INT, 3, "format", GST_TYPE_FOURCC,
 559           codec_fcc, NULL);
 560       if (codec_name)
 561         *codec_name = g_strdup ("Microsoft Windows Media VC-1");
 562       break;
 563
 564     case GST_MAKE_FOURCC ('c', 'v', 'i', 'd'):
 565       caps = gst_caps_new_simple ("video/x-cinepak", NULL);
 566       if (codec_name)
 567         *codec_name = g_strdup ("Cinepak video");
 568       break;
 569
 570     case GST_MAKE_FOURCC ('M', 'S', 'V', 'C'):
 571     case GST_MAKE_FOURCC ('m', 's', 'v', 'c'):
 572     case GST_MAKE_FOURCC ('C', 'R', 'A', 'M'):
 573     case GST_MAKE_FOURCC ('c', 'r', 'a', 'm'):
 574     case GST_MAKE_FOURCC ('W', 'H', 'A', 'M'):
 575     case GST_MAKE_FOURCC ('w', 'h', 'a', 'm'):
 576       caps = gst_caps_new_simple ("video/x-msvideocodec",
 577           "msvideoversion", G_TYPE_INT, 1, NULL);
 578       if (codec_name)
 579         *codec_name = g_strdup ("MS video v1");
 580       palette = strf_data;
 581       strf_data = NULL;
 582       break;
 583
 584     case GST_MAKE_FOURCC ('R', 'L', 'E', ' '):
 585     case GST_MAKE_FOURCC ('m', 'r', 'l', 'e'):
 586     case GST_MAKE_FOURCC (0x1, 0x0, 0x0, 0x0): /* why, why, why? */
 587     case GST_MAKE_FOURCC (0x2, 0x0, 0x0, 0x0): /* why, why, why? */
 588       caps = gst_caps_new_simple ("video/x-rle",
 589           "layout", G_TYPE_STRING, "microsoft", NULL);
 590       palette = strf_data;
 591       strf_data = NULL;
 592       if (strf) {
 593         gst_caps_set_simple (caps,
 594             "depth", G_TYPE_INT, (gint) strf->bit_cnt, NULL);
 595       } else {
 596         gst_caps_set_simple (caps, "depth", GST_TYPE_INT_RANGE, 1, 64, NULL);
 597       }
 598       if (codec_name)
 599         *codec_name = g_strdup ("Microsoft RLE");
 600       break;
 601
 602     case GST_MAKE_FOURCC ('A', 'A', 'S', 'C'):
 603       caps = gst_caps_new_simple ("video/x-aasc", NULL);
 604       if (codec_name)
 605         *codec_name = g_strdup ("Autodesk Animator");
 606       break;
 607
 608     case GST_MAKE_FOURCC ('X', 'x', 'a', 'n'):
 609       caps = gst_caps_new_simple ("video/x-xan",
 610           "wcversion", G_TYPE_INT, 4, NULL);
 611       if (codec_name)
 612         *codec_name = g_strdup ("Xan Wing Commander 4");
 613       break;
 614
 615     case GST_MAKE_FOURCC ('R', 'T', '2', '1'):
 616       caps = gst_caps_new_simple ("video/x-indeo",
 617           "indeoversion", G_TYPE_INT, 2, NULL);
 618       if (codec_name)
 619         *codec_name = g_strdup ("Intel Video 2");
 620       break;
 621
 622     case GST_MAKE_FOURCC ('I', 'V', '3', '1'):
 623     case GST_MAKE_FOURCC ('I', 'V', '3', '2'):
 624     case GST_MAKE_FOURCC ('i', 'v', '3', '1'):
 625     case GST_MAKE_FOURCC ('i', 'v', '3', '2'):
 626       caps = gst_caps_new_simple ("video/x-indeo",
 627           "indeoversion", G_TYPE_INT, 3, NULL);
 628       if (codec_name)
 629         *codec_name = g_strdup ("Intel Video 3");
 630       break;
 631
 632     case GST_MAKE_FOURCC ('I', 'V', '4', '1'):
 633     case GST_MAKE_FOURCC ('i', 'v', '4', '1'):
 634       caps = gst_caps_new_simple ("video/x-indeo",
 635           "indeoversion", G_TYPE_INT, 4, NULL);
 636       if (codec_name)
 637         *codec_name = g_strdup ("Intel Video 4");
 638       break;
 639
 640     case GST_MAKE_FOURCC ('I', 'V', '5', '0'):
 641       caps = gst_caps_new_simple ("video/x-indeo",
 642           "indeoversion", G_TYPE_INT, 5, NULL);
 643       if (codec_name)
 644         *codec_name = g_strdup ("Intel Video 5");
 645       break;
 646
 647     case GST_MAKE_FOURCC ('M', 'S', 'Z', 'H'):
 648       caps = gst_caps_new_simple ("video/x-mszh", NULL);
 649       if (codec_name)
 650         *codec_name = g_strdup ("Lossless MSZH Video");
 651       break;
 652
 653     case GST_MAKE_FOURCC ('Z', 'L', 'I', 'B'):
 654       caps = gst_caps_new_simple ("video/x-zlib", NULL);
 655       if (codec_name)
 656         *codec_name = g_strdup ("Lossless zlib video");
 657       break;
 658
 659     case GST_MAKE_FOURCC ('C', 'L', 'J', 'R'):
 660     case GST_MAKE_FOURCC ('c', 'l', 'j', 'r'):
 661       caps = gst_caps_new_simple ("video/x-cirrus-logic-accupak", NULL);
 662       if (codec_name)
 663         *codec_name = g_strdup ("Cirrus Logipak AccuPak");
 664       break;
 665
 666     case GST_MAKE_FOURCC ('C', 'Y', 'U', 'V'):
 667     case GST_MAKE_FOURCC ('c', 'y', 'u', 'v'):
 668       caps = gst_caps_new_simple ("video/x-compressed-yuv", NULL);
 669       if (codec_name)
 670         *codec_name = g_strdup ("CYUV Lossless");
 671       break;
 672
 673     case GST_MAKE_FOURCC ('D', 'U', 'C', 'K'):
 674     case GST_MAKE_FOURCC ('P', 'V', 'E', 'Z'):
 675       caps = gst_caps_new_simple ("video/x-truemotion",
 676           "trueversion", G_TYPE_INT, 1, NULL);
 677       if (codec_name)
 678         *codec_name = g_strdup ("Duck Truemotion1");
 679       break;
 680
 681     case GST_MAKE_FOURCC ('T', 'M', '2', '0'):
 682       caps = gst_caps_new_simple ("video/x-truemotion",
 683           "trueversion", G_TYPE_INT, 2, NULL);
 684       if (codec_name)
 685         *codec_name = g_strdup ("TrueMotion 2.0");
 686       break;
 687
 688     case GST_MAKE_FOURCC ('V', 'P', '3', '0'):
 689     case GST_MAKE_FOURCC ('v', 'p', '3', '0'):
 690     case GST_MAKE_FOURCC ('V', 'P', '3', '1'):
 691     case GST_MAKE_FOURCC ('v', 'p', '3', '1'):
 692     case GST_MAKE_FOURCC ('V', 'P', '3', ' '):
 693       caps = gst_caps_new_simple ("video/x-vp3", NULL);
 694       if (codec_name)
 695         *codec_name = g_strdup ("VP3");
 696       break;
 697
 698     case GST_MAKE_FOURCC ('U', 'L', 'T', 'I'):
 699       caps = gst_caps_new_simple ("video/x-ultimotion", NULL);
 700       if (codec_name)
 701         *codec_name = g_strdup ("IBM UltiMotion");
 702       break;
 703
 704     case GST_MAKE_FOURCC ('T', 'S', 'C', 'C'):
 705     case GST_MAKE_FOURCC ('t', 's', 'c', 'c'):{
 706       if (strf) {
 707         gint depth = (strf->bit_cnt != 0) ? (gint) strf->bit_cnt : 24;
 708
 709         caps = gst_caps_new_simple ("video/x-camtasia", "depth", G_TYPE_INT,
 710             depth, NULL);
 711       } else {
 712         /* template caps */
 713         caps = gst_caps_new_simple ("video/x-camtasia", NULL);
 714       }
 715       if (codec_name)
 716         *codec_name = g_strdup ("TechSmith Camtasia");
 717       break;
 718     }
 719
 720     case GST_MAKE_FOURCC ('C', 'S', 'C', 'D'):
 721     {
 722       if (strf) {
 723         gint depth = (strf->bit_cnt != 0) ? (gint) strf->bit_cnt : 24;
 724
 725         caps = gst_caps_new_simple ("video/x-camstudio", "depth", G_TYPE_INT,
 726             depth, NULL);
 727       } else {
 728         /* template caps */
 729         caps = gst_caps_new_simple ("video/x-camstudio", NULL);
 730       }
 731       if (codec_name)
 732         *codec_name = g_strdup ("Camstudio");
 733       break;
 734     }
 735
 736     case GST_MAKE_FOURCC ('V', 'C', 'R', '1'):
 737       caps = gst_caps_new_simple ("video/x-ati-vcr",
 738           "vcrversion", G_TYPE_INT, 1, NULL);
 739       if (codec_name)
 740         *codec_name = g_strdup ("ATI VCR 1");
 741       break;
 742
 743     case GST_MAKE_FOURCC ('V', 'C', 'R', '2'):
 744       caps = gst_caps_new_simple ("video/x-ati-vcr",
 745           "vcrversion", G_TYPE_INT, 2, NULL);
 746       if (codec_name)
 747         *codec_name = g_strdup ("ATI VCR 2");
 748       break;
 749
 750     case GST_MAKE_FOURCC ('A', 'S', 'V', '1'):
 751       caps = gst_caps_new_simple ("video/x-asus",
 752           "asusversion", G_TYPE_INT, 1, NULL);
 753       if (codec_name)
 754         *codec_name = g_strdup ("Asus Video 1");
 755       break;
 756
 757     case GST_MAKE_FOURCC ('A', 'S', 'V', '2'):
 758       caps = gst_caps_new_simple ("video/x-asus",
 759           "asusversion", G_TYPE_INT, 2, NULL);
 760       if (codec_name)
 761         *codec_name = g_strdup ("Asus Video 2");
 762       break;
 763
 764     case GST_MAKE_FOURCC ('M', 'P', 'N', 'G'):
 765     case GST_MAKE_FOURCC ('m', 'p', 'n', 'g'):
 766     case GST_MAKE_FOURCC ('P', 'N', 'G', ' '):
 767       caps = gst_caps_new_simple ("image/png", NULL);
 768       if (codec_name)
 769         *codec_name = g_strdup ("PNG image");
 770       break;
 771
 772     case GST_MAKE_FOURCC ('F', 'L', 'V', '1'):
 773       caps = gst_caps_new_simple ("video/x-flash-video",
 774           "flvversion", G_TYPE_INT, 1, NULL);
 775       if (codec_name)
 776         *codec_name = g_strdup ("Flash Video 1");
 777       break;
 778
 779     case GST_MAKE_FOURCC ('V', 'M', 'n', 'c'):
 780       caps = gst_caps_new_simple ("video/x-vmnc",
 781           "version", G_TYPE_INT, 1, NULL);
 782       if (codec_name)
 783         *codec_name = g_strdup ("VMWare NC Video");
 784       break;
 785
 786     case GST_MAKE_FOURCC ('d', 'r', 'a', 'c'):
 787       caps = gst_caps_new_simple ("video/x-dirac", NULL);
 788       if (codec_name)
 789         *codec_name = g_strdup ("Dirac");
 790       break;
 791
 792     case GST_RIFF_rpza:
 793     case GST_RIFF_azpr:
 794     case GST_MAKE_FOURCC ('R', 'P', 'Z', 'A'):
 795       caps = gst_caps_new_simple ("video/x-apple-video", NULL);
 796       if (codec_name)
 797         *codec_name = g_strdup ("Apple Video (RPZA)");
 798       break;
 799
 800
 801     case GST_MAKE_FOURCC ('F', 'F', 'V', '1'):
 802       caps = gst_caps_new_simple ("video/x-ffv",
 803           "ffvversion", G_TYPE_INT, 1, NULL);
 804       if (codec_name)
 805         *codec_name = g_strdup ("FFmpeg lossless video codec");
 806       break;
 807
 808     case GST_MAKE_FOURCC ('K', 'M', 'V', 'C'):
 809       caps = gst_caps_new_simple ("video/x-kmvc", NULL);
 810       if (codec_name)
 811         *codec_name = g_strdup ("Karl Morton's video codec");
 812       break;
 813
 814     case GST_MAKE_FOURCC ('v', 'p', '5', '0'):
 815     case GST_MAKE_FOURCC ('V', 'P', '5', '0'):
 816       caps = gst_caps_new_simple ("video/x-vp5", NULL);
 817       if (codec_name)
 818         *codec_name = g_strdup ("On2 VP5");
 819       break;
 820
 821     case GST_MAKE_FOURCC ('v', 'p', '6', '0'):
 822     case GST_MAKE_FOURCC ('V', 'P', '6', '0'):
 823     case GST_MAKE_FOURCC ('v', 'p', '6', '1'):
 824     case GST_MAKE_FOURCC ('V', 'P', '6', '1'):
 825     case GST_MAKE_FOURCC ('V', 'p', '6', '2'):
 826     case GST_MAKE_FOURCC ('V', 'P', '6', '2'):
 827       caps = gst_caps_new_simple ("video/x-vp6", NULL);
 828       if (codec_name)
 829         *codec_name = g_strdup ("On2 VP6");
 830       break;
 831
 832     case GST_MAKE_FOURCC ('V', 'P', '6', 'F'):
 833     case GST_MAKE_FOURCC ('v', 'p', '6', 'f'):
 834     case GST_MAKE_FOURCC ('F', 'L', 'V', '4'):
 835       caps = gst_caps_new_simple ("video/x-vp6-flash", NULL);
 836       if (codec_name)
 837         *codec_name = g_strdup ("On2 VP6");
 838       break;
 839
 840     case GST_MAKE_FOURCC ('v', 'p', '7', '0'):
 841     case GST_MAKE_FOURCC ('V', 'P', '7', '0'):
 842       caps = gst_caps_new_simple ("video/x-vp7", NULL);
 843       if (codec_name)
 844         *codec_name = g_strdup ("On2 VP7");
 845       break;
 846
 847     case GST_MAKE_FOURCC ('V', 'P', '8', '0'):
 848       caps = gst_caps_new_simple ("video/x-vp8", NULL);
 849       if (codec_name)
 850         *codec_name = g_strdup ("On2 VP8");
 851       break;
 852
 853     case GST_MAKE_FOURCC ('L', 'M', '2', '0'):
 854       caps = gst_caps_new_simple ("video/x-mimic", NULL);
 855       if (codec_name)
 856         *codec_name = g_strdup ("Mimic webcam");
 857       break;
 858
 859     case GST_MAKE_FOURCC ('T', 'H', 'E', 'O'):
 860     case GST_MAKE_FOURCC ('t', 'h', 'e', 'o'):
 861       caps = gst_caps_new_simple ("video/x-theora", NULL);
 862       if (codec_name)
 863         *codec_name = g_strdup ("Theora video codec");
 864
 865       break;
 866
 867     case GST_MAKE_FOURCC ('F', 'P', 'S', '1'):
 868       caps = gst_caps_new_simple ("video/x-fraps", NULL);
 869       if (codec_name)
 870         *codec_name = g_strdup ("Fraps video");
 871
 872       break;
 873
 874     default:
 875       GST_WARNING ("Unknown video fourcc %" GST_FOURCC_FORMAT,
 876           GST_FOURCC_ARGS (codec_fcc));
 877       return NULL;
 878   }
 879
 880   if (strh != NULL) {
 881     gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION,
 882         strh->rate, strh->scale, NULL);
 883   } else {
 884     gst_caps_set_simple (caps,
 885         "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
 886   }
 887
 888   if (strf != NULL) {
 889     gst_caps_set_simple (caps,
 890         "width", G_TYPE_INT, strf->width,
 891         "height", G_TYPE_INT, strf->height, NULL);
 892   } else {
 893     gst_caps_set_simple (caps,
 894         "width", GST_TYPE_INT_RANGE, 1, G_MAXINT,
 895         "height", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL);
 896   }
 897
 898   /* extradata */
 899   if (strf_data || strd_data) {
 900     GstBuffer *codec_data;
 901
 902     codec_data = strf_data ? strf_data : strd_data;
 903
 904     gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, codec_data, NULL);
 905   }
 906
 907   /* palette */
 908   if (palette) {
 909     GstBuffer *copy;
 910     guint num_colors;
 911
 912     if (strf != NULL)
 913       num_colors = strf->num_colors;
 914     else
 915       num_colors = 256;
 916
 917     if (GST_BUFFER_SIZE (palette) >= (num_colors * 4)) {
 918       /* palette is always at least 256*4 bytes */
 919       copy =
 920           gst_buffer_new_and_alloc (MAX (GST_BUFFER_SIZE (palette), 256 * 4));
 921       memcpy (GST_BUFFER_DATA (copy), GST_BUFFER_DATA (palette),
 922           GST_BUFFER_SIZE (palette));
 923
 924 #if (G_BYTE_ORDER == G_BIG_ENDIAN)
 925       {
 926         guint8 *data = GST_BUFFER_DATA (copy);
 927         gint n;
 928
 929         /* own endianness */
 930         for (n = 0; n < num_colors; n++) {
 931           GST_WRITE_UINT32_BE (data, GST_READ_UINT32_LE (data));
 932           data += sizeof (guint32);
 933         }
 934       }
 935 #endif
 936       gst_caps_set_simple (caps, "palette_data", GST_TYPE_BUFFER, copy, NULL);
 937       gst_buffer_unref (copy);
 938     } else {
 939       GST_WARNING ("Palette smaller than expected: broken file");
 940     }
 941   }
 942
 943   return caps;
 944 }
 945
 946 static const struct
 947 {
 948   const guint32 ms_mask;
 949   const GstAudioChannelPosition gst_pos;
 950 } layout_mapping[] = {
 951   {
 952   0x00001, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
 953   0x00002, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
 954   0x00004, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
 955   0x00008, GST_AUDIO_CHANNEL_POSITION_LFE}, {
 956   0x00010, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT}, {
 957   0x00020, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
 958   0x00040, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER}, {
 959   0x00080, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER}, {
 960   0x00100, GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
 961   0x00200, GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT}, {
 962   0x00400, GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}, {
 963   0x00800, GST_AUDIO_CHANNEL_POSITION_INVALID}, /* TOP_CENTER       */
 964   {
 965   0x01000, GST_AUDIO_CHANNEL_POSITION_INVALID}, /* TOP_FRONT_LEFT   */
 966   {
 967   0x02000, GST_AUDIO_CHANNEL_POSITION_INVALID}, /* TOP_FRONT_CENTER */
 968   {
 969   0x04000, GST_AUDIO_CHANNEL_POSITION_INVALID}, /* TOP_FRONT_RIGHT  */
 970   {
 971   0x08000, GST_AUDIO_CHANNEL_POSITION_INVALID}, /* TOP_BACK_LEFT    */
 972   {
 973   0x10000, GST_AUDIO_CHANNEL_POSITION_INVALID}, /* TOP_BACK_CENTER  */
 974   {
 975   0x20000, GST_AUDIO_CHANNEL_POSITION_INVALID}  /* TOP_BACK_RIGHT   */
 976 };
 977
 978 #define MAX_CHANNEL_POSITIONS G_N_ELEMENTS (layout_mapping)
 979
 980 static gboolean
 981 gst_riff_wavext_add_channel_layout (GstCaps * caps, guint32 layout)
 982 {
 983   GstAudioChannelPosition pos[MAX_CHANNEL_POSITIONS];
 984   GstStructure *s;
 985   gint num_channels, i, p;
 986
 987   s = gst_caps_get_structure (caps, 0);
 988   if (!gst_structure_get_int (s, "channels", &num_channels))
 989     g_return_val_if_reached (FALSE);
 990
 991   /* In theory this should be done for 1 and 2 channels too but
 992    * apparently breaks too many things currently.
 993    */
 994   if (num_channels <= 2 || num_channels > MAX_CHANNEL_POSITIONS) {
 995     GST_DEBUG ("invalid number of channels: %d", num_channels);
 996     return FALSE;
 997   }
 998
 999   p = 0;
1000   for (i = 0; i < MAX_CHANNEL_POSITIONS; ++i) {
1001     if ((layout & layout_mapping[i].ms_mask) != 0) {
1002       if (p >= num_channels) {
1003         GST_WARNING ("More bits set in the channel layout map than there "
1004             "are channels! Broken file");
1005         return FALSE;
1006       }
1007       if (layout_mapping[i].gst_pos == GST_AUDIO_CHANNEL_POSITION_INVALID) {
1008         GST_WARNING ("Unsupported channel position (mask 0x%08x) in channel "
1009             "layout map - ignoring those channels", layout_mapping[i].ms_mask);
1010         /* what to do? just ignore it and let downstream deal with a channel
1011          * layout that has INVALID positions in it for now ... */
1012       }
1013       pos[p] = layout_mapping[i].gst_pos;
1014       ++p;
1015     }
1016   }
1017
1018   if (p != num_channels) {
1019     GST_WARNING ("Only %d bits set in the channel layout map, but there are "
1020         "supposed to be %d channels! Broken file", p, num_channels);
1021     return FALSE;
1022   }
1023
1024   gst_audio_set_channel_positions (s, pos);
1025   return TRUE;
1026 }
1027
1028 static gboolean
1029 gst_riff_wave_add_default_channel_layout (GstCaps * caps)
1030 {
1031   GstAudioChannelPosition pos[8] = { GST_AUDIO_CHANNEL_POSITION_NONE, };
1032   GstStructure *s;
1033   gint nchannels;
1034
1035   s = gst_caps_get_structure (caps, 0);
1036
1037   if (!gst_structure_get_int (s, "channels", &nchannels))
1038     g_return_val_if_reached (FALSE);
1039
1040   if (nchannels > 8) {
1041     GST_DEBUG ("invalid number of channels: %d", nchannels);
1042     return FALSE;
1043   }
1044
1045   /* This uses the default channel mapping from ALSA which
1046    * is used in quite a few surround test files and seems to be
1047    * the defacto standard. The channel mapping from
1048    * WAVE_FORMAT_EXTENSIBLE doesn't seem to be used in normal
1049    * wav files like chan-id.wav.
1050    * http://bugzilla.gnome.org/show_bug.cgi?id=489010
1051    */
1052   switch (nchannels) {
1053     case 1:
1054       pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_MONO;
1055       break;
1056     case 8:
1057       pos[7] = GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT;
1058       pos[6] = GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT;
1059       /* fall through */
1060     case 6:
1061       pos[5] = GST_AUDIO_CHANNEL_POSITION_LFE;
1062       /* fall through */
1063     case 5:
1064       pos[4] = GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER;
1065       /* fall through */
1066     case 4:
1067       pos[3] = GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT;
1068       pos[2] = GST_AUDIO_CHANNEL_POSITION_REAR_LEFT;
1069       /* fall through */
1070     case 2:
1071       pos[1] = GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT;
1072       pos[0] = GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT;
1073       break;
1074     default:
1075       return FALSE;
1076   }
1077
1078   gst_audio_set_channel_positions (s, pos);
1079   return TRUE;
1080 }
1081
1082 static guint32
1083 gst_riff_wavext_get_default_channel_mask (guint nchannels)
1084 {
1085   guint32 channel_mask = 0;
1086
1087   /* Set the default channel mask for the given number of channels.
1088    * http://www.microsoft.com/whdc/device/audio/multichaud.mspx
1089    */
1090   switch (nchannels) {
1091     case 11:
1092       channel_mask |= 0x00400;
1093       channel_mask |= 0x00200;
1094     case 9:
1095       channel_mask |= 0x00100;
1096     case 8:
1097       channel_mask |= 0x00080;
1098       channel_mask |= 0x00040;
1099     case 6:
1100       channel_mask |= 0x00020;
1101       channel_mask |= 0x00010;
1102     case 4:
1103       channel_mask |= 0x00008;
1104     case 3:
1105       channel_mask |= 0x00004;
1106     case 2:
1107       channel_mask |= 0x00002;
1108       channel_mask |= 0x00001;
1109       break;
1110   }
1111
1112   return channel_mask;
1113 }
1114
1115 GstCaps *
1116 gst_riff_create_audio_caps (guint16 codec_id,
1117     gst_riff_strh * strh, gst_riff_strf_auds * strf,
1118     GstBuffer * strf_data, GstBuffer * strd_data, char **codec_name)
1119 {
1120   gboolean block_align = FALSE, rate_chan = TRUE;
1121   GstCaps *caps = NULL;
1122   gint rate_min = 1000, rate_max = 96000;
1123   gint channels_max = 2;
1124
1125   switch (codec_id) {
1126     case GST_RIFF_WAVE_FORMAT_PCM:     /* PCM */
1127       rate_max = 192000;
1128       channels_max = 8;
1129
1130       if (strf != NULL) {
1131         gint ba = strf->blockalign;
1132         gint ch = strf->channels;
1133         gint wd, ws;
1134
1135         /* If we have an empty blockalign, we take the width contained in
1136          * strf->size */
1137         if (ba != 0)
1138           wd = ba * 8 / ch;
1139         else
1140           wd = strf->size;
1141
1142         if (strf->size > 32) {
1143           GST_WARNING ("invalid depth (%d) of pcm audio, overwriting.",
1144               strf->size);
1145           strf->size = 8 * ((wd + 7) / 8);
1146         }
1147
1148         /* in riff, the depth is stored in the size field but it just means that
1149          * the _least_ significant bits are cleared. We can therefore just play
1150          * the sample as if it had a depth == width */
1151         /* For reference, the actual depth is in strf->size */
1152         ws = wd;
1153
1154         caps = gst_caps_new_simple ("audio/x-raw-int",
1155             "endianness", G_TYPE_INT, G_LITTLE_ENDIAN,
1156             "channels", G_TYPE_INT, ch,
1157             "width", G_TYPE_INT, wd,
1158             "depth", G_TYPE_INT, ws, "signed", G_TYPE_BOOLEAN, wd != 8, NULL);
1159
1160         /* Add default channel layout. In theory this should be done
1161          * for 1 and 2 channels too but apparently breaks too many
1162          * things currently. Also we know no default layout for more than
1163          * 8 channels. */
1164         if (ch > 2) {
1165           if (ch > 8)
1166             GST_WARNING ("don't know default layout for %d channels", ch);
1167           else if (gst_riff_wave_add_default_channel_layout (caps))
1168             GST_DEBUG ("using default channel layout for %d channels", ch);
1169           else
1170             GST_WARNING ("failed to add channel layout");
1171         }
1172       } else {
1173         /* FIXME: this is pretty useless - we need fixed caps */
1174         caps = gst_caps_from_string ("audio/x-raw-int, "
1175             "endianness = (int) LITTLE_ENDIAN, "
1176             "signed = (boolean) { true, false }, "
1177             "width = (int) { 8, 16, 24, 32 }, " "depth = (int) [ 1, 32 ]");
1178       }
1179       if (codec_name && strf)
1180         *codec_name = g_strdup_printf ("Uncompressed %d-bit PCM audio",
1181             strf->size);
1182       break;
1183
1184     case GST_RIFF_WAVE_FORMAT_ADPCM:
1185       caps = gst_caps_new_simple ("audio/x-adpcm",
1186           "layout", G_TYPE_STRING, "microsoft", NULL);
1187       if (codec_name)
1188         *codec_name = g_strdup ("ADPCM audio");
1189       block_align = TRUE;
1190       break;
1191
1192     case GST_RIFF_WAVE_FORMAT_IEEE_FLOAT:
1193       rate_max = 192000;
1194       channels_max = 8;
1195
1196       if (strf != NULL) {
1197         gint ba = strf->blockalign;
1198         gint ch = strf->channels;
1199         gint wd = ba * 8 / ch;
1200
1201         caps = gst_caps_new_simple ("audio/x-raw-float",
1202             "endianness", G_TYPE_INT, G_LITTLE_ENDIAN,
1203             "channels", G_TYPE_INT, ch, "width", G_TYPE_INT, wd, NULL);
1204
1205         /* Add default channel layout. In theory this should be done
1206          * for 1 and 2 channels too but apparently breaks too many
1207          * things currently. Also we know no default layout for more than
1208          * 8 channels. */
1209         if (ch > 2) {
1210           if (ch > 8)
1211             GST_WARNING ("don't know default layout for %d channels", ch);
1212           else if (gst_riff_wave_add_default_channel_layout (caps))
1213             GST_DEBUG ("using default channel layout for %d channels", ch);
1214           else
1215             GST_WARNING ("failed to add channel layout");
1216         }
1217       } else {
1218         /* FIXME: this is pretty useless - we need fixed caps */
1219         caps = gst_caps_from_string ("audio/x-raw-float, "
1220             "endianness = (int) LITTLE_ENDIAN, " "width = (int) { 32, 64 }");
1221       }
1222       if (codec_name && strf)
1223         *codec_name = g_strdup_printf ("Uncompressed %d-bit IEEE float audio",
1224             strf->size);
1225       break;
1226
1227     case GST_RIFF_WAVE_FORMAT_IBM_CVSD:
1228       goto unknown;
1229
1230     case GST_RIFF_WAVE_FORMAT_ALAW:
1231       if (strf != NULL) {
1232         if (strf->size != 8) {
1233           GST_WARNING ("invalid depth (%d) of alaw audio, overwriting.",
1234               strf->size);
1235           strf->size = 8;
1236           strf->blockalign = (strf->size * strf->channels) / 8;
1237           strf->av_bps = strf->blockalign * strf->rate;
1238         }
1239         if (strf->av_bps == 0 || strf->blockalign == 0) {
1240           GST_WARNING ("fixing av_bps (%d) and blockalign (%d) of alaw audio",
1241               strf->av_bps, strf->blockalign);
1242           strf->blockalign = (strf->size * strf->channels) / 8;
1243           strf->av_bps = strf->blockalign * strf->rate;
1244         }
1245       }
1246       rate_max = 48000;
1247       caps = gst_caps_new_simple ("audio/x-alaw", NULL);
1248       if (codec_name)
1249         *codec_name = g_strdup ("A-law audio");
1250       break;
1251
1252     case GST_RIFF_WAVE_FORMAT_WMS:
1253       caps = gst_caps_new_simple ("audio/x-wms", NULL);
1254       if (strf != NULL) {
1255         gst_caps_set_simple (caps,
1256             "bitrate", G_TYPE_INT, strf->av_bps * 8,
1257             "width", G_TYPE_INT, strf->size,
1258             "depth", G_TYPE_INT, strf->size, NULL);
1259       } else {
1260         gst_caps_set_simple (caps,
1261             "bitrate", GST_TYPE_INT_RANGE, 0, G_MAXINT, NULL);
1262       }
1263       if (codec_name)
1264         *codec_name = g_strdup ("Windows Media Audio Speech");
1265       block_align = TRUE;
1266       break;
1267
1268     case GST_RIFF_WAVE_FORMAT_MULAW:
1269       if (strf != NULL) {
1270         if (strf->size != 8) {
1271           GST_WARNING ("invalid depth (%d) of mulaw audio, overwriting.",
1272               strf->size);
1273           strf->size = 8;
1274           strf->blockalign = (strf->size * strf->channels) / 8;
1275           strf->av_bps = strf->blockalign * strf->rate;
1276         }
1277         if (strf->av_bps == 0 || strf->blockalign == 0) {
1278           GST_WARNING ("fixing av_bps (%d) and blockalign (%d) of mulaw audio",
1279               strf->av_bps, strf->blockalign);
1280           strf->blockalign = (strf->size * strf->channels) / 8;
1281           strf->av_bps = strf->blockalign * strf->rate;
1282         }
1283       }
1284       rate_max = 48000;
1285       caps = gst_caps_new_simple ("audio/x-mulaw", NULL);
1286       if (codec_name)
1287         *codec_name = g_strdup ("Mu-law audio");
1288       break;
1289
1290     case GST_RIFF_WAVE_FORMAT_OKI_ADPCM:
1291       goto unknown;
1292
1293     case GST_RIFF_WAVE_FORMAT_DVI_ADPCM:
1294       rate_max = 48000;
1295       caps = gst_caps_new_simple ("audio/x-adpcm",
1296           "layout", G_TYPE_STRING, "dvi", NULL);
1297       if (codec_name)
1298         *codec_name = g_strdup ("DVI ADPCM audio");
1299       block_align = TRUE;
1300       break;
1301
1302     case GST_RIFF_WAVE_FORMAT_DSP_TRUESPEECH:
1303       rate_min = 8000;
1304       rate_max = 8000;
1305       caps = gst_caps_new_simple ("audio/x-truespeech", NULL);
1306       if (codec_name)
1307         *codec_name = g_strdup ("DSP Group TrueSpeech");
1308       break;
1309
1310     case GST_RIFF_WAVE_FORMAT_GSM610:
1311     case GST_RIFF_WAVE_FORMAT_MSN:
1312       rate_min = 1;
1313       caps = gst_caps_new_simple ("audio/ms-gsm", NULL);
1314       if (codec_name)
1315         *codec_name = g_strdup ("MS GSM audio");
1316       break;
1317
1318     case GST_RIFF_WAVE_FORMAT_MPEGL12: /* mp1 or mp2 */
1319       rate_min = 16000;
1320       rate_max = 48000;
1321       caps = gst_caps_new_simple ("audio/mpeg",
1322           "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 2, NULL);
1323       if (codec_name)
1324         *codec_name = g_strdup ("MPEG-1 layer 2");
1325       break;
1326
1327     case GST_RIFF_WAVE_FORMAT_MPEGL3:  /* mp3 */
1328       rate_min = 8000;
1329       rate_max = 48000;
1330       caps = gst_caps_new_simple ("audio/mpeg",
1331           "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 3, NULL);
1332       if (codec_name)
1333         *codec_name = g_strdup ("MPEG-1 layer 3");
1334       break;
1335
1336     case GST_RIFF_WAVE_FORMAT_AMR_NB:  /* amr-nb */
1337       rate_min = 8000;
1338       rate_max = 8000;
1339       channels_max = 1;
1340       caps = gst_caps_new_simple ("audio/AMR", NULL);
1341       if (codec_name)
1342         *codec_name = g_strdup ("AMR Narrow Band (NB)");
1343       break;
1344
1345     case GST_RIFF_WAVE_FORMAT_AMR_WB:  /* amr-wb */
1346       rate_min = 16000;
1347       rate_max = 16000;
1348       channels_max = 1;
1349       caps = gst_caps_new_simple ("audio/AMR-WB", NULL);
1350       if (codec_name)
1351         *codec_name = g_strdup ("AMR Wide Band (WB)");
1352       break;
1353
1354     case GST_RIFF_WAVE_FORMAT_VORBIS1: /* ogg/vorbis mode 1 */
1355     case GST_RIFF_WAVE_FORMAT_VORBIS2: /* ogg/vorbis mode 2 */
1356     case GST_RIFF_WAVE_FORMAT_VORBIS3: /* ogg/vorbis mode 3 */
1357     case GST_RIFF_WAVE_FORMAT_VORBIS1PLUS:     /* ogg/vorbis mode 1+ */
1358     case GST_RIFF_WAVE_FORMAT_VORBIS2PLUS:     /* ogg/vorbis mode 2+ */
1359     case GST_RIFF_WAVE_FORMAT_VORBIS3PLUS:     /* ogg/vorbis mode 3+ */
1360       rate_max = 192000;
1361       caps = gst_caps_new_simple ("audio/x-vorbis", NULL);
1362       if (codec_name)
1363         *codec_name = g_strdup ("Vorbis");
1364       break;
1365
1366     case GST_RIFF_WAVE_FORMAT_A52:
1367       channels_max = 6;
1368       caps = gst_caps_new_simple ("audio/x-ac3", NULL);
1369       if (codec_name)
1370         *codec_name = g_strdup ("AC-3 audio");
1371       break;
1372     case GST_RIFF_WAVE_FORMAT_DTS:
1373       channels_max = 6;
1374       caps = gst_caps_new_simple ("audio/x-dts", NULL);
1375       if (codec_name)
1376         *codec_name = g_strdup ("DTS audio");
1377       /* wavparse is not always able to specify rate/channels for DTS-in-wav */
1378       rate_chan = FALSE;
1379       break;
1380     case GST_RIFF_WAVE_FORMAT_AAC:
1381     case GST_RIFF_WAVE_FORMAT_AAC_AC:
1382     case GST_RIFF_WAVE_FORMAT_AAC_pm:
1383     case GST_RIFF_WAVE_FORMAT_AAC_PR:
1384     {
1385       channels_max = 8;
1386       caps = gst_caps_new_simple ("audio/mpeg",
1387           "mpegversion", G_TYPE_INT, 4, NULL);
1388       if (codec_name)
1389         *codec_name = g_strdup ("MPEG-4 AAC audio");
1390       break;
1391     }
1392     case GST_RIFF_WAVE_FORMAT_WMAV1:
1393     case GST_RIFF_WAVE_FORMAT_WMAV2:
1394     case GST_RIFF_WAVE_FORMAT_WMAV3:
1395     case GST_RIFF_WAVE_FORMAT_WMAV3_L:
1396     {
1397       gint version = (codec_id - GST_RIFF_WAVE_FORMAT_WMAV1) + 1;
1398
1399       /*Since gstreamer already knows GST_RIFF_WAVE_FORMAT_WMAV3_L (WMA lossless media) as version 3.*/
1400       if(codec_id == GST_RIFF_WAVE_FORMAT_WMAV3_L)
1401         version = (codec_id - GST_RIFF_WAVE_FORMAT_WMAV1);
1402
1403       /* WMA Pro supports upto 8 channels */
1404       channels_max = 8;
1405       block_align = TRUE;
1406
1407       caps = gst_caps_new_simple ("audio/x-wma",
1408           "wmaversion", G_TYPE_INT, version, NULL);
1409
1410       if (codec_name) {
1411         if (codec_id == GST_RIFF_WAVE_FORMAT_WMAV3_L)
1412           *codec_name = g_strdup ("WMA Lossless");
1413         else
1414           *codec_name = g_strdup_printf ("WMA Version %d", version + 6);
1415       }
1416
1417       if (strf != NULL) {
1418         gst_caps_set_simple (caps,
1419             "bitrate", G_TYPE_INT, strf->av_bps * 8,
1420             "depth", G_TYPE_INT, strf->size, NULL);
1421       } else {
1422         gst_caps_set_simple (caps,
1423             "bitrate", GST_TYPE_INT_RANGE, 0, G_MAXINT, NULL);
1424       }
1425       break;
1426     }
1427     case GST_RIFF_WAVE_FORMAT_SONY_ATRAC3:
1428       caps = gst_caps_new_simple ("audio/x-vnd.sony.atrac3", NULL);
1429       if (codec_name)
1430         *codec_name = g_strdup ("Sony ATRAC3");
1431       break;
1432
1433     case GST_RIFF_WAVE_FORMAT_SIREN:
1434       caps = gst_caps_new_simple ("audio/x-siren", NULL);
1435       if (codec_name)
1436         *codec_name = g_strdup ("Siren7");
1437       rate_chan = FALSE;
1438       break;
1439
1440     case GST_RIFF_WAVE_FORMAT_ADPCM_IMA_DK4:
1441       rate_min = 8000;
1442       rate_max = 96000;
1443       channels_max = 2;
1444       caps =
1445           gst_caps_new_simple ("audio/x-adpcm", "layout", G_TYPE_STRING, "dk4",
1446           NULL);
1447       if (codec_name)
1448         *codec_name = g_strdup ("IMA/DK4 ADPCM");
1449       break;
1450     case GST_RIFF_WAVE_FORMAT_ADPCM_IMA_DK3:
1451       rate_min = 8000;
1452       rate_max = 96000;
1453       channels_max = 2;
1454       caps =
1455           gst_caps_new_simple ("audio/x-adpcm", "layout", G_TYPE_STRING, "dk3",
1456           NULL);
1457       if (codec_name)
1458         *codec_name = g_strdup ("IMA/DK3 ADPCM");
1459       break;
1460
1461     case GST_RIFF_WAVE_FORMAT_ADPCM_IMA_WAV:
1462       rate_min = 8000;
1463       rate_max = 96000;
1464       channels_max = 2;
1465       caps =
1466           gst_caps_new_simple ("audio/x-adpcm", "layout", G_TYPE_STRING, "dvi",
1467           NULL);
1468       if (codec_name)
1469         *codec_name = g_strdup ("IMA/WAV ADPCM");
1470       break;
1471     case GST_RIFF_WAVE_FORMAT_EXTENSIBLE:{
1472       guint16 valid_bits_per_sample;
1473       guint32 channel_mask;
1474       guint32 subformat_guid[4];
1475       const guint8 *data;
1476
1477       channels_max = 8;
1478
1479       /* should be at least 22 bytes */
1480       if (strf_data == NULL || GST_BUFFER_SIZE (strf_data) < 22) {
1481         GST_WARNING ("WAVE_FORMAT_EXTENSIBLE data size is %d (expected: 22)",
1482             (strf_data) ? GST_BUFFER_SIZE (strf_data) : -1);
1483         return NULL;
1484       }
1485
1486       data = GST_BUFFER_DATA (strf_data);
1487
1488       valid_bits_per_sample = GST_READ_UINT16_LE (data);
1489       channel_mask = GST_READ_UINT32_LE (data + 2);
1490       subformat_guid[0] = GST_READ_UINT32_LE (data + 6);
1491       subformat_guid[1] = GST_READ_UINT32_LE (data + 10);
1492       subformat_guid[2] = GST_READ_UINT32_LE (data + 14);
1493       subformat_guid[3] = GST_READ_UINT32_LE (data + 18);
1494
1495       GST_DEBUG ("valid bps    = %u", valid_bits_per_sample);
1496       GST_DEBUG ("channel mask = 0x%08x", channel_mask);
1497       GST_DEBUG ("GUID         = %08x-%08x-%08x-%08x", subformat_guid[0],
1498           subformat_guid[1], subformat_guid[2], subformat_guid[3]);
1499
1500       if (subformat_guid[1] == 0x00100000 &&
1501           subformat_guid[2] == 0xaa000080 && subformat_guid[3] == 0x719b3800) {
1502         if (subformat_guid[0] == 0x00000001) {
1503           GST_DEBUG ("PCM");
1504           if (strf != NULL) {
1505             gint ba = strf->blockalign;
1506             gint wd = ba * 8 / strf->channels;
1507             gint ws;
1508
1509             /* in riff, the depth is stored in the size field but it just
1510              * means that the _least_ significant bits are cleared. We can
1511              * therefore just play the sample as if it had a depth == width */
1512             ws = wd;
1513
1514             /* For reference, use this to get the actual depth:
1515              * ws = strf->size;
1516              * if (valid_bits_per_sample != 0)
1517              *   ws = valid_bits_per_sample; */
1518
1519             caps = gst_caps_new_simple ("audio/x-raw-int",
1520                 "endianness", G_TYPE_INT, G_LITTLE_ENDIAN,
1521                 "channels", G_TYPE_INT, strf->channels,
1522                 "width", G_TYPE_INT, wd,
1523                 "depth", G_TYPE_INT, ws,
1524                 "rate", G_TYPE_INT, strf->rate,
1525                 "signed", G_TYPE_BOOLEAN, wd != 8, NULL);
1526
1527             /* If channel_mask == 0 and channels > 2 let's
1528              * assume default layout as some wav files don't have the
1529              * channel mask set. Don't set the layout for 1 or 2
1530              * channels as it apparently breaks too many things currently. */
1531             if (channel_mask == 0 && strf->channels > 2)
1532               channel_mask =
1533                   gst_riff_wavext_get_default_channel_mask (strf->channels);
1534
1535             if ((channel_mask != 0 || strf->channels > 2) &&
1536                 !gst_riff_wavext_add_channel_layout (caps, channel_mask)) {
1537               GST_WARNING ("failed to add channel layout");
1538               gst_caps_unref (caps);
1539               caps = NULL;
1540             }
1541             rate_chan = FALSE;
1542
1543             if (codec_name) {
1544               *codec_name = g_strdup_printf ("Uncompressed %d-bit PCM audio",
1545                   strf->size);
1546             }
1547           }
1548         } else if (subformat_guid[0] == 0x00000003) {
1549           GST_DEBUG ("FLOAT");
1550           if (strf != NULL) {
1551             gint ba = strf->blockalign;
1552             gint wd = ba * 8 / strf->channels;
1553
1554             caps = gst_caps_new_simple ("audio/x-raw-float",
1555                 "endianness", G_TYPE_INT, G_LITTLE_ENDIAN,
1556                 "channels", G_TYPE_INT, strf->channels,
1557                 "width", G_TYPE_INT, wd, "rate", G_TYPE_INT, strf->rate, NULL);
1558
1559             /* If channel_mask == 0 and channels > 2 let's
1560              * assume default layout as some wav files don't have the
1561              * channel mask set. Don't set the layout for 1 or 2
1562              * channels as it apparently breaks too many things currently. */
1563             if (channel_mask == 0 && strf->channels > 2)
1564               channel_mask =
1565                   gst_riff_wavext_get_default_channel_mask (strf->channels);
1566
1567             if ((channel_mask != 0 || strf->channels > 2) &&
1568                 !gst_riff_wavext_add_channel_layout (caps, channel_mask)) {
1569               GST_WARNING ("failed to add channel layout");
1570               gst_caps_unref (caps);
1571               caps = NULL;
1572             }
1573             rate_chan = FALSE;
1574
1575             if (codec_name) {
1576               *codec_name =
1577                   g_strdup_printf ("Uncompressed %d-bit IEEE float audio",
1578                   strf->size);
1579             }
1580           }
1581         } else if (subformat_guid[0] == 00000006) {
1582           GST_DEBUG ("ALAW");
1583           if (strf != NULL) {
1584             if (strf->size != 8) {
1585               GST_WARNING ("invalid depth (%d) of alaw audio, overwriting.",
1586                   strf->size);
1587               strf->size = 8;
1588               strf->av_bps = 8;
1589               strf->blockalign = strf->av_bps * strf->channels;
1590             }
1591             if (strf->av_bps == 0 || strf->blockalign == 0) {
1592               GST_WARNING
1593                   ("fixing av_bps (%d) and blockalign (%d) of alaw audio",
1594                   strf->av_bps, strf->blockalign);
1595               strf->av_bps = strf->size;
1596               strf->blockalign = strf->av_bps * strf->channels;
1597             }
1598           }
1599           rate_max = 48000;
1600           caps = gst_caps_new_simple ("audio/x-alaw", NULL);
1601
1602           if (codec_name)
1603             *codec_name = g_strdup ("A-law audio");
1604         } else if (subformat_guid[0] == 0x00000007) {
1605           GST_DEBUG ("MULAW");
1606           if (strf != NULL) {
1607             if (strf->size != 8) {
1608               GST_WARNING ("invalid depth (%d) of mulaw audio, overwriting.",
1609                   strf->size);
1610               strf->size = 8;
1611               strf->av_bps = 8;
1612               strf->blockalign = strf->av_bps * strf->channels;
1613             }
1614             if (strf->av_bps == 0 || strf->blockalign == 0) {
1615               GST_WARNING
1616                   ("fixing av_bps (%d) and blockalign (%d) of mulaw audio",
1617                   strf->av_bps, strf->blockalign);
1618               strf->av_bps = strf->size;
1619               strf->blockalign = strf->av_bps * strf->channels;
1620             }
1621           }
1622           rate_max = 48000;
1623           caps = gst_caps_new_simple ("audio/x-mulaw", NULL);
1624           if (codec_name)
1625             *codec_name = g_strdup ("Mu-law audio");
1626         } else if (subformat_guid[0] == 0x00000092) {
1627           GST_DEBUG ("FIXME: handle DOLBY AC3 SPDIF format");
1628         }
1629       } else if (subformat_guid[0] == 0x6ba47966 &&
1630           subformat_guid[1] == 0x41783f83 &&
1631           subformat_guid[2] == 0xf0006596 && subformat_guid[3] == 0xe59262bf) {
1632         caps = gst_caps_new_simple ("application/x-ogg-avi", NULL);
1633         if (codec_name)
1634           *codec_name = g_strdup ("Ogg-AVI");
1635       }
1636
1637       if (caps == NULL) {
1638         GST_WARNING ("Unknown WAVE_FORMAT_EXTENSIBLE audio format");
1639         return NULL;
1640       }
1641       break;
1642     }
1643       /* can anything decode these? pitfdll? */
1644     case GST_RIFF_WAVE_FORMAT_VOXWARE_AC8:
1645     case GST_RIFF_WAVE_FORMAT_VOXWARE_AC10:
1646     case GST_RIFF_WAVE_FORMAT_VOXWARE_AC16:
1647     case GST_RIFF_WAVE_FORMAT_VOXWARE_AC20:
1648     case GST_RIFF_WAVE_FORMAT_VOXWARE_METAVOICE:
1649     case GST_RIFF_WAVE_FORMAT_VOXWARE_METASOUND:
1650     case GST_RIFF_WAVE_FORMAT_VOXWARE_RT29HW:
1651     case GST_RIFF_WAVE_FORMAT_VOXWARE_VR12:
1652     case GST_RIFF_WAVE_FORMAT_VOXWARE_VR18:
1653     case GST_RIFF_WAVE_FORMAT_VOXWARE_TQ40:
1654     case GST_RIFF_WAVE_FORMAT_VOXWARE_TQ60:{
1655       caps = gst_caps_new_simple ("audio/x-voxware",
1656           "voxwaretype", G_TYPE_INT, (gint) codec_id, NULL);
1657       if (codec_name)
1658         *codec_name = g_strdup ("Voxware");
1659       break;
1660     }
1661     default:
1662     unknown:
1663       GST_WARNING ("Unknown audio tag 0x%04x", codec_id);
1664       return NULL;
1665   }
1666
1667   if (strf != NULL) {
1668     if (rate_chan) {
1669       if (strf->channels > channels_max)
1670         goto too_many_channels;
1671       if (strf->rate < rate_min || strf->rate > rate_max)
1672         goto invalid_rate;
1673
1674       gst_caps_set_simple (caps,
1675           "rate", G_TYPE_INT, strf->rate,
1676           "channels", G_TYPE_INT, strf->channels, NULL);
1677     }
1678     if (block_align) {
1679       gst_caps_set_simple (caps,
1680           "block_align", G_TYPE_INT, strf->blockalign, NULL);
1681     }
1682   } else {
1683     if (rate_chan) {
1684       if (rate_min == rate_max)
1685         gst_caps_set_simple (caps, "rate", G_TYPE_INT, rate_min, NULL);
1686       else
1687         gst_caps_set_simple (caps,
1688             "rate", GST_TYPE_INT_RANGE, rate_min, rate_max, NULL);
1689       if (channels_max == 1)
1690         gst_caps_set_simple (caps, "channels", G_TYPE_INT, 1, NULL);
1691       else
1692         gst_caps_set_simple (caps,
1693             "channels", GST_TYPE_INT_RANGE, 1, channels_max, NULL);
1694     }
1695     if (block_align) {
1696       gst_caps_set_simple (caps,
1697           "block_align", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL);
1698     }
1699   }
1700
1701   /* extradata */
1702   if (strf_data || strd_data) {
1703     gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER,
1704         strf_data ? strf_data : strd_data, NULL);
1705   }
1706
1707   return caps;
1708
1709   /* ERROR */
1710 too_many_channels:
1711   GST_WARNING
1712       ("Stream claims to contain %u channels, but format only supports %d",
1713       strf->channels, channels_max);
1714   gst_caps_unref (caps);
1715   return NULL;
1716 invalid_rate:
1717   GST_WARNING
1718       ("Stream with sample_rate %u, but format only supports %d .. %d",
1719       strf->rate, rate_min, rate_max);
1720   gst_caps_unref (caps);
1721   return NULL;
1722 }
1723
1724 GstCaps *
1725 gst_riff_create_iavs_caps (guint32 codec_fcc,
1726     gst_riff_strh * strh, gst_riff_strf_iavs * strf,
1727     GstBuffer * init_data, GstBuffer * extra_data, char **codec_name)
1728 {
1729   GstCaps *caps = NULL;
1730
1731   switch (codec_fcc) {
1732       /* is this correct? */
1733     case GST_MAKE_FOURCC ('D', 'V', 'S', 'D'):
1734     case GST_MAKE_FOURCC ('d', 'v', 's', 'd'):
1735       caps = gst_caps_new_simple ("video/x-dv",
1736           "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
1737       if (codec_name)
1738         *codec_name = g_strdup ("Generic DV");
1739       break;
1740
1741     default:
1742       GST_WARNING ("Unknown IAVS fourcc %" GST_FOURCC_FORMAT,
1743           GST_FOURCC_ARGS (codec_fcc));
1744       return NULL;
1745   }
1746
1747   return caps;
1748 }
1749
1750 /*
1751  * Functions below are for template caps. All is variable.
1752  */
1753
1754 GstCaps *
1755 gst_riff_create_video_template_caps (void)
1756 {
1757   static const guint32 tags[] = {
1758     GST_MAKE_FOURCC ('3', 'I', 'V', '1'),
1759     GST_MAKE_FOURCC ('A', 'S', 'V', '1'),
1760     GST_MAKE_FOURCC ('A', 'S', 'V', '2'),
1761     GST_MAKE_FOURCC ('C', 'L', 'J', 'R'),
1762     GST_MAKE_FOURCC ('C', 'S', 'C', 'D'),
1763     GST_MAKE_FOURCC ('C', 'Y', 'U', 'V'),
1764     GST_MAKE_FOURCC ('D', 'I', 'B', ' '),
1765     GST_MAKE_FOURCC ('D', 'I', 'V', '3'),
1766     GST_MAKE_FOURCC ('D', 'I', 'V', 'X'),
1767     GST_MAKE_FOURCC ('D', 'U', 'C', 'K'),
1768     GST_MAKE_FOURCC ('D', 'V', 'S', 'D'),
1769     GST_MAKE_FOURCC ('D', 'V', '5', '0'),
1770     GST_MAKE_FOURCC ('D', 'X', '5', '0'),
1771     GST_MAKE_FOURCC ('M', '4', 'C', 'C'),
1772     GST_MAKE_FOURCC ('F', 'L', 'V', '1'),
1773     GST_MAKE_FOURCC ('F', 'L', 'V', '4'),
1774     GST_MAKE_FOURCC ('H', '2', '6', '3'),
1775     GST_MAKE_FOURCC ('V', 'X', '1', 'K'),
1776     GST_MAKE_FOURCC ('H', '2', '6', '4'),
1777     GST_MAKE_FOURCC ('H', 'F', 'Y', 'U'),
1778     GST_MAKE_FOURCC ('I', '2', '6', '3'),
1779     GST_MAKE_FOURCC ('I', '4', '2', '0'),
1780     GST_MAKE_FOURCC ('I', 'V', '3', '2'),
1781     GST_MAKE_FOURCC ('I', 'V', '4', '1'),
1782     GST_MAKE_FOURCC ('I', 'V', '5', '0'),
1783     GST_MAKE_FOURCC ('L', '2', '6', '3'),
1784     GST_MAKE_FOURCC ('L', '2', '6', '4'),
1785     GST_MAKE_FOURCC ('M', '2', '6', '3'),
1786     GST_MAKE_FOURCC ('M', '4', 'S', '2'),
1787     GST_MAKE_FOURCC ('M', 'J', 'P', 'G'),
1788     GST_MAKE_FOURCC ('M', 'P', '4', '2'),
1789     GST_MAKE_FOURCC ('M', 'P', '4', '3'),
1790     GST_MAKE_FOURCC ('M', 'P', 'E', 'G'),
1791     GST_MAKE_FOURCC ('M', 'P', 'G', '2'),
1792     GST_MAKE_FOURCC ('M', 'P', 'G', '4'),
1793     GST_MAKE_FOURCC ('M', 'S', 'Z', 'H'),
1794     GST_MAKE_FOURCC ('P', 'N', 'G', ' '),
1795     GST_MAKE_FOURCC ('R', 'L', 'E', ' '),
1796     GST_MAKE_FOURCC ('R', 'T', '2', '1'),
1797     GST_MAKE_FOURCC ('S', 'P', '5', '3'),
1798     GST_MAKE_FOURCC ('T', 'M', '2', '0'),
1799     GST_MAKE_FOURCC ('T', 'S', 'C', 'C'),
1800     GST_MAKE_FOURCC ('U', 'L', 'T', 'I'),
1801     GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'),
1802     GST_MAKE_FOURCC ('V', 'C', 'R', '1'),
1803     GST_MAKE_FOURCC ('V', 'C', 'R', '2'),
1804     GST_MAKE_FOURCC ('V', 'D', 'O', 'W'),
1805     GST_MAKE_FOURCC ('V', 'I', 'V', 'O'),
1806     GST_MAKE_FOURCC ('V', 'M', 'n', 'c'),
1807     GST_MAKE_FOURCC ('V', 'P', '3', ' '),
1808     GST_MAKE_FOURCC ('V', 'S', 'S', 'H'),
1809     GST_MAKE_FOURCC ('W', 'M', 'V', '1'),
1810     GST_MAKE_FOURCC ('W', 'M', 'V', '2'),
1811     GST_MAKE_FOURCC ('W', 'M', 'V', '3'),
1812     GST_MAKE_FOURCC ('X', 'V', 'I', 'D'),
1813     GST_MAKE_FOURCC ('X', 'x', 'a', 'n'),
1814     GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'),
1815     GST_MAKE_FOURCC ('Y', 'V', 'U', '9'),
1816     GST_MAKE_FOURCC ('Z', 'L', 'I', 'B'),
1817     GST_MAKE_FOURCC ('c', 'v', 'i', 'd'),
1818     GST_MAKE_FOURCC ('h', '2', '6', '4'),
1819     GST_MAKE_FOURCC ('m', 's', 'v', 'c'),
1820     GST_MAKE_FOURCC ('x', '2', '6', '3'),
1821     GST_MAKE_FOURCC ('d', 'r', 'a', 'c'),
1822     GST_MAKE_FOURCC ('F', 'F', 'V', '1'),
1823     GST_MAKE_FOURCC ('K', 'M', 'V', 'C'),
1824     GST_MAKE_FOURCC ('V', 'P', '5', '0'),
1825     GST_MAKE_FOURCC ('V', 'P', '6', '0'),
1826     GST_MAKE_FOURCC ('V', 'P', '6', 'F'),
1827     GST_MAKE_FOURCC ('V', 'P', '7', '0'),
1828     GST_MAKE_FOURCC ('V', 'P', '8', '0'),
1829     GST_MAKE_FOURCC ('L', 'M', '2', '0'),
1830     GST_MAKE_FOURCC ('R', 'P', 'Z', 'A'),
1831     GST_MAKE_FOURCC ('T', 'H', 'E', 'O'),
1832     GST_MAKE_FOURCC ('F', 'P', 'S', '1'),
1833     GST_MAKE_FOURCC ('A', 'A', 'S', 'C'),
1834     GST_MAKE_FOURCC ('Y', 'V', '1', '2'),
1835     GST_MAKE_FOURCC ('L', 'O', 'C', 'O'),
1836     GST_MAKE_FOURCC ('Z', 'M', 'B', 'V'),
1837     /* FILL ME */
1838   };
1839   guint i;
1840   GstCaps *caps, *one;
1841
1842   caps = gst_caps_new_empty ();
1843   for (i = 0; i < G_N_ELEMENTS (tags); i++) {
1844     one = gst_riff_create_video_caps (tags[i], NULL, NULL, NULL, NULL, NULL);
1845     if (one)
1846       gst_caps_append (caps, one);
1847   }
1848
1849   return caps;
1850 }
1851
1852 GstCaps *
1853 gst_riff_create_audio_template_caps (void)
1854 {
1855   static const guint16 tags[] = {
1856     GST_RIFF_WAVE_FORMAT_GSM610,
1857     GST_RIFF_WAVE_FORMAT_MPEGL3,
1858     GST_RIFF_WAVE_FORMAT_MPEGL12,
1859     GST_RIFF_WAVE_FORMAT_PCM,
1860     GST_RIFF_WAVE_FORMAT_VORBIS1,
1861     GST_RIFF_WAVE_FORMAT_A52,
1862     GST_RIFF_WAVE_FORMAT_DTS,
1863     GST_RIFF_WAVE_FORMAT_AAC,
1864     GST_RIFF_WAVE_FORMAT_ALAW,
1865     GST_RIFF_WAVE_FORMAT_MULAW,
1866     GST_RIFF_WAVE_FORMAT_WMS,
1867     GST_RIFF_WAVE_FORMAT_ADPCM,
1868     GST_RIFF_WAVE_FORMAT_DVI_ADPCM,
1869     GST_RIFF_WAVE_FORMAT_DSP_TRUESPEECH,
1870     GST_RIFF_WAVE_FORMAT_WMAV1,
1871     GST_RIFF_WAVE_FORMAT_WMAV2,
1872     GST_RIFF_WAVE_FORMAT_WMAV3,
1873     GST_RIFF_WAVE_FORMAT_SONY_ATRAC3,
1874     GST_RIFF_WAVE_FORMAT_IEEE_FLOAT,
1875     GST_RIFF_WAVE_FORMAT_VOXWARE_METASOUND,
1876     GST_RIFF_WAVE_FORMAT_ADPCM_IMA_DK4,
1877     GST_RIFF_WAVE_FORMAT_ADPCM_IMA_DK3,
1878     GST_RIFF_WAVE_FORMAT_ADPCM_IMA_WAV,
1879     GST_RIFF_WAVE_FORMAT_AMR_NB,
1880     GST_RIFF_WAVE_FORMAT_AMR_WB,
1881     GST_RIFF_WAVE_FORMAT_SIREN,
1882     /* FILL ME */
1883   };
1884   guint i;
1885   GstCaps *caps, *one;
1886
1887   caps = gst_caps_new_empty ();
1888   for (i = 0; i < G_N_ELEMENTS (tags); i++) {
1889     one = gst_riff_create_audio_caps (tags[i], NULL, NULL, NULL, NULL, NULL);
1890     if (one)
1891       gst_caps_append (caps, one);
1892   }
1893   one = gst_caps_new_simple ("application/x-ogg-avi", NULL);
1894   gst_caps_append (caps, one);
1895
1896   return caps;
1897 }
1898
1899 GstCaps *
1900 gst_riff_create_iavs_template_caps (void)
1901 {
1902   static const guint32 tags[] = {
1903     GST_MAKE_FOURCC ('D', 'V', 'S', 'D')
1904         /* FILL ME */
1905   };
1906   guint i;
1907   GstCaps *caps, *one;
1908
1909   caps = gst_caps_new_empty ();
1910   for (i = 0; i < G_N_ELEMENTS (tags); i++) {
1911     one = gst_riff_create_iavs_caps (tags[i], NULL, NULL, NULL, NULL, NULL);
1912     if (one)
1913       gst_caps_append (caps, one);
1914   }
1915
1916   return caps;
1917 }