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