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     /* raw rgb data is stored topdown, but instead of inverting the buffer, */
 896     /* some tools just negate the height field in the header (e.g. ffmpeg) */
 897     gst_caps_set_simple (caps,
 898         "width", G_TYPE_INT, strf->width,
 899         "height", G_TYPE_INT, ABS ((gint) strf->height), NULL);
 900   } else {
 901     gst_caps_set_simple (caps,
 902         "width", GST_TYPE_INT_RANGE, 1, G_MAXINT,
 903         "height", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL);
 904   }
 905
 906   /* extradata */
 907   if (strf_data || strd_data) {
 908     GstBuffer *codec_data;
 909
 910     codec_data = strf_data ? strf_data : strd_data;
 911
 912     gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, codec_data, NULL);
 913   }
 914
 915   /* palette */
 916   if (palette) {
 917     GstBuffer *copy;
 918     guint num_colors;
 919     gsize size;
 920
 921     if (strf != NULL)
 922       num_colors = strf->num_colors;
 923     else
 924       num_colors = 256;
 925
 926     size = gst_buffer_get_size (palette);
 927
 928     if (size >= (num_colors * 4)) {
 929       guint8 *pdata;
 930
 931       /* palette is always at least 256*4 bytes */
 932       pdata = g_malloc0 (MAX (size, 256 * 4));
 933       gst_buffer_extract (palette, 0, pdata, size);
 934
 935       if (G_BYTE_ORDER == G_BIG_ENDIAN) {
 936         guint8 *p = pdata;
 937         gint n;
 938
 939         /* own endianness */
 940         for (n = 0; n < num_colors; n++) {
 941           GST_WRITE_UINT32_BE (p, GST_READ_UINT32_LE (p));
 942           p += sizeof (guint32);
 943         }
 944       }
 945
 946       copy = gst_buffer_new_wrapped (pdata, size);
 947       gst_caps_set_simple (caps, "palette_data", GST_TYPE_BUFFER, copy, NULL);
 948       gst_buffer_unref (copy);
 949     } else {
 950       GST_WARNING ("Palette smaller than expected: broken file");
 951     }
 952   }
 953
 954   return caps;
 955 }
 956
 957 static const struct
 958 {
 959   const guint32 ms_mask;
 960   const GstAudioChannelPosition gst_pos;
 961 } layout_mapping[] = {
 962   {
 963   0x00001, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
 964   0x00002, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
 965   0x00004, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
 966   0x00008, GST_AUDIO_CHANNEL_POSITION_LFE1}, {
 967   0x00010, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT}, {
 968   0x00020, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
 969   0x00040, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER}, {
 970   0x00080, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER}, {
 971   0x00100, GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
 972   0x00200, GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT}, {
 973   0x00400, GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}, {
 974   0x00800, GST_AUDIO_CHANNEL_POSITION_TOP_CENTER}, {
 975   0x01000, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT}, {
 976   0x02000, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER}, {
 977   0x04000, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT}, {
 978   0x08000, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT}, {
 979   0x10000, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER}, {
 980   0x20000, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT}
 981 };
 982
 983 #define MAX_CHANNEL_POSITIONS G_N_ELEMENTS (layout_mapping)
 984
 985 static gboolean
 986 gst_riff_wavext_add_channel_mask (GstCaps * caps, gint num_channels,
 987     guint32 layout, gint channel_reorder_map[18])
 988 {
 989   gint i, p;
 990   guint64 channel_mask = 0;
 991   GstAudioChannelPosition from[18], to[18];
 992
 993   if (num_channels < 1 || num_channels > MAX_CHANNEL_POSITIONS) {
 994     GST_DEBUG ("invalid number of channels: %d", num_channels);
 995     return FALSE;
 996   }
 997
 998   p = 0;
 999   for (i = 0; i < MAX_CHANNEL_POSITIONS; ++i) {
1000     if ((layout & layout_mapping[i].ms_mask) != 0) {
1001       if (p >= num_channels) {
1002         GST_WARNING ("More bits set in the channel layout map than there "
1003             "are channels! Broken file");
1004         return FALSE;
1005       }
1006       if (layout_mapping[i].gst_pos == GST_AUDIO_CHANNEL_POSITION_INVALID) {
1007         GST_WARNING ("Unsupported channel position (mask 0x%08x) in channel "
1008             "layout map - ignoring those channels", layout_mapping[i].ms_mask);
1009         /* what to do? just ignore it and let downstream deal with a channel
1010          * layout that has INVALID positions in it for now ... */
1011       }
1012       channel_mask |= G_GUINT64_CONSTANT (1) << layout_mapping[i].gst_pos;
1013       from[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   if (channel_reorder_map) {
1025     memcpy (to, from, sizeof (from[0]) * num_channels);
1026     if (!gst_audio_channel_positions_to_valid_order (to, num_channels))
1027       return FALSE;
1028     if (!gst_audio_get_channel_reorder_map (num_channels, from, to,
1029             channel_reorder_map))
1030       return FALSE;
1031   }
1032
1033   gst_caps_set_simple (caps, "channel-mask", GST_TYPE_BITMASK, channel_mask,
1034       NULL);
1035
1036   return TRUE;
1037 }
1038
1039 static gboolean
1040 gst_riff_wave_add_default_channel_mask (GstCaps * caps,
1041     gint nchannels, gint channel_reorder_map[18])
1042 {
1043   guint64 channel_mask = 0;
1044   static const gint reorder_maps[8][11] = {
1045     {0,},
1046     {0, 1},
1047     {-1, -1, -1},
1048     {0, 1, 2, 3},
1049     {0, 1, 3, 4, 2},
1050     {0, 1, 4, 5, 2, 3},
1051     {-1, -1, -1, -1, -1, -1, -1},
1052     {0, 1, 4, 5, 2, 3, 6, 7}
1053   };
1054
1055   if (nchannels > 8) {
1056     GST_DEBUG ("invalid number of channels: %d", nchannels);
1057     return FALSE;
1058   }
1059
1060   /* This uses the default channel mapping from ALSA which
1061    * is used in quite a few surround test files and seems to be
1062    * the defacto standard. The channel mapping from
1063    * WAVE_FORMAT_EXTENSIBLE doesn't seem to be used in normal
1064    * wav files like chan-id.wav.
1065    * http://bugzilla.gnome.org/show_bug.cgi?id=489010
1066    */
1067   switch (nchannels) {
1068     case 1:
1069       /* Mono => nothing */
1070       if (channel_reorder_map)
1071         channel_reorder_map[0] = 0;
1072       return TRUE;
1073     case 8:
1074       channel_mask |=
1075           G_GUINT64_CONSTANT (1) << GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT;
1076       channel_mask |=
1077           G_GUINT64_CONSTANT (1) << GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT;
1078       /* fall through */
1079     case 6:
1080       channel_mask |= G_GUINT64_CONSTANT (1) << GST_AUDIO_CHANNEL_POSITION_LFE1;
1081       /* fall through */
1082     case 5:
1083       channel_mask |=
1084           G_GUINT64_CONSTANT (1) << GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER;
1085       /* fall through */
1086     case 4:
1087       channel_mask |=
1088           G_GUINT64_CONSTANT (1) << GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT;
1089       channel_mask |=
1090           G_GUINT64_CONSTANT (1) << GST_AUDIO_CHANNEL_POSITION_REAR_LEFT;
1091       /* fall through */
1092     case 2:
1093       channel_mask |=
1094           G_GUINT64_CONSTANT (1) << GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT;
1095       channel_mask |=
1096           G_GUINT64_CONSTANT (1) << GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT;
1097       break;
1098     default:
1099       return FALSE;
1100   }
1101
1102   if (channel_reorder_map)
1103     memcpy (channel_reorder_map, reorder_maps[nchannels],
1104         sizeof (gint) * nchannels);
1105
1106   gst_caps_set_simple (caps, "channel-mask", GST_TYPE_BITMASK, channel_mask,
1107       NULL);
1108
1109   return TRUE;
1110 }
1111
1112 static guint32
1113 gst_riff_wavext_get_default_channel_mask (guint nchannels)
1114 {
1115   guint32 channel_mask = 0;
1116
1117   /* Set the default channel mask for the given number of channels.
1118    * http://www.microsoft.com/whdc/device/audio/multichaud.mspx
1119    */
1120   switch (nchannels) {
1121     case 11:
1122       channel_mask |= 0x00400;
1123       channel_mask |= 0x00200;
1124     case 9:
1125       channel_mask |= 0x00100;
1126     case 8:
1127       channel_mask |= 0x00080;
1128       channel_mask |= 0x00040;
1129     case 6:
1130       channel_mask |= 0x00020;
1131       channel_mask |= 0x00010;
1132     case 4:
1133       channel_mask |= 0x00008;
1134     case 3:
1135       channel_mask |= 0x00004;
1136     case 2:
1137       channel_mask |= 0x00002;
1138       channel_mask |= 0x00001;
1139       break;
1140   }
1141
1142   return channel_mask;
1143 }
1144
1145 GstCaps *
1146 gst_riff_create_audio_caps (guint16 codec_id,
1147     gst_riff_strh * strh, gst_riff_strf_auds * strf,
1148     GstBuffer * strf_data, GstBuffer * strd_data, char **codec_name,
1149     gint channel_reorder_map[18])
1150 {
1151   gboolean block_align = FALSE, rate_chan = TRUE;
1152   GstCaps *caps = NULL;
1153   gint rate_min = 1000, rate_max = 96000;
1154   gint channels_max = 2;
1155   gint i;
1156
1157   if (channel_reorder_map)
1158     for (i = 0; i < 18; i++)
1159       channel_reorder_map[i] = -1;
1160
1161   switch (codec_id) {
1162     case GST_RIFF_WAVE_FORMAT_PCM:     /* PCM */
1163       rate_max = 192000;
1164       channels_max = 8;
1165
1166       if (strf != NULL) {
1167         gint ba = strf->blockalign;
1168         gint ch = strf->channels;
1169         gint wd, ws;
1170         GstAudioFormat format;
1171
1172         /* If we have an empty blockalign, we take the width contained in
1173          * strf->bits_per_sample */
1174         if (ba != 0)
1175           wd = ba * 8 / ch;
1176         else
1177           wd = strf->bits_per_sample;
1178
1179         if (strf->bits_per_sample > 32) {
1180           GST_WARNING ("invalid depth (%d) of pcm audio, overwriting.",
1181               strf->bits_per_sample);
1182           strf->bits_per_sample = 8 * ((wd + 7) / 8);
1183         }
1184
1185         /* in riff, the depth is stored in the size field but it just means that
1186          * the _least_ significant bits are cleared. We can therefore just play
1187          * the sample as if it had a depth == width */
1188         /* For reference, the actual depth is in strf->bits_per_sample */
1189         ws = wd;
1190
1191         format =
1192             gst_audio_format_build_integer (wd != 8, G_LITTLE_ENDIAN, wd, ws);
1193
1194         caps = gst_caps_new_simple ("audio/x-raw",
1195             "format", G_TYPE_STRING, gst_audio_format_to_string (format),
1196             "layout", G_TYPE_STRING, "interleaved",
1197             "channels", G_TYPE_INT, ch, NULL);
1198
1199         /* Add default channel layout. We know no default layout for more than
1200          * 8 channels. */
1201         if (ch > 8)
1202           GST_WARNING ("don't know default layout for %d channels", ch);
1203         else if (gst_riff_wave_add_default_channel_mask (caps, ch,
1204                 channel_reorder_map))
1205           GST_DEBUG ("using default channel layout for %d channels", ch);
1206         else
1207           GST_WARNING ("failed to add channel layout");
1208       } else {
1209         /* FIXME: this is pretty useless - we need fixed caps */
1210         caps = gst_caps_from_string ("audio/x-raw, "
1211             "format = (string) { S8, U8, S16LE, U16LE, S24LE, "
1212             "U24LE, S32LE, U32LE }, " "layout = (string) interleaved");
1213       }
1214       if (codec_name && strf)
1215         *codec_name = g_strdup_printf ("Uncompressed %d-bit PCM audio",
1216             strf->bits_per_sample);
1217       break;
1218
1219     case GST_RIFF_WAVE_FORMAT_ADPCM:
1220       caps = gst_caps_new_simple ("audio/x-adpcm",
1221           "layout", G_TYPE_STRING, "microsoft", NULL);
1222       if (codec_name)
1223         *codec_name = g_strdup ("ADPCM audio");
1224       block_align = TRUE;
1225       break;
1226
1227     case GST_RIFF_WAVE_FORMAT_IEEE_FLOAT:
1228       rate_max = 192000;
1229       channels_max = 8;
1230
1231       if (strf != NULL) {
1232         gint ba = strf->blockalign;
1233         gint ch = strf->channels;
1234         gint wd = ba * 8 / ch;
1235
1236         caps = gst_caps_new_simple ("audio/x-raw",
1237             "format", G_TYPE_STRING, wd == 64 ? "F64LE" : "F32LE",
1238             "layout", G_TYPE_STRING, "interleaved",
1239             "channels", G_TYPE_INT, ch, NULL);
1240
1241         /* Add default channel layout. We know no default layout for more than
1242          * 8 channels. */
1243         if (ch > 8)
1244           GST_WARNING ("don't know default layout for %d channels", ch);
1245         else if (gst_riff_wave_add_default_channel_mask (caps, ch,
1246                 channel_reorder_map))
1247           GST_DEBUG ("using default channel layout for %d channels", ch);
1248         else
1249           GST_WARNING ("failed to add channel layout");
1250       } else {
1251         /* FIXME: this is pretty useless - we need fixed caps */
1252         caps = gst_caps_from_string ("audio/x-raw, "
1253             "format = (string) { F32LE, F64LE }, "
1254             "layout = (string) interleaved");
1255       }
1256       if (codec_name && strf)
1257         *codec_name = g_strdup_printf ("Uncompressed %d-bit IEEE float audio",
1258             strf->bits_per_sample);
1259       break;
1260
1261     case GST_RIFF_WAVE_FORMAT_IBM_CVSD:
1262       goto unknown;
1263
1264     case GST_RIFF_WAVE_FORMAT_ALAW:
1265       if (strf != NULL) {
1266         if (strf->bits_per_sample != 8) {
1267           GST_WARNING ("invalid depth (%d) of alaw audio, overwriting.",
1268               strf->bits_per_sample);
1269           strf->bits_per_sample = 8;
1270           strf->blockalign = (strf->bits_per_sample * strf->channels) / 8;
1271           strf->av_bps = strf->blockalign * strf->rate;
1272         }
1273         if (strf->av_bps == 0 || strf->blockalign == 0) {
1274           GST_WARNING ("fixing av_bps (%d) and blockalign (%d) of alaw audio",
1275               strf->av_bps, strf->blockalign);
1276           strf->blockalign = (strf->bits_per_sample * strf->channels) / 8;
1277           strf->av_bps = strf->blockalign * strf->rate;
1278         }
1279       }
1280       rate_max = 48000;
1281       caps = gst_caps_new_empty_simple ("audio/x-alaw");
1282       if (codec_name)
1283         *codec_name = g_strdup ("A-law audio");
1284       break;
1285
1286     case GST_RIFF_WAVE_FORMAT_WMS:
1287       caps = gst_caps_new_empty_simple ("audio/x-wms");
1288       if (strf != NULL) {
1289         gst_caps_set_simple (caps,
1290             "bitrate", G_TYPE_INT, strf->av_bps * 8,
1291             "width", G_TYPE_INT, strf->bits_per_sample,
1292             "depth", G_TYPE_INT, strf->bits_per_sample, NULL);
1293       } else {
1294         gst_caps_set_simple (caps,
1295             "bitrate", GST_TYPE_INT_RANGE, 0, G_MAXINT, NULL);
1296       }
1297       if (codec_name)
1298         *codec_name = g_strdup ("Windows Media Audio Speech");
1299       block_align = TRUE;
1300       break;
1301
1302     case GST_RIFF_WAVE_FORMAT_MULAW:
1303       if (strf != NULL) {
1304         if (strf->bits_per_sample != 8) {
1305           GST_WARNING ("invalid depth (%d) of mulaw audio, overwriting.",
1306               strf->bits_per_sample);
1307           strf->bits_per_sample = 8;
1308           strf->blockalign = (strf->bits_per_sample * strf->channels) / 8;
1309           strf->av_bps = strf->blockalign * strf->rate;
1310         }
1311         if (strf->av_bps == 0 || strf->blockalign == 0) {
1312           GST_WARNING ("fixing av_bps (%d) and blockalign (%d) of mulaw audio",
1313               strf->av_bps, strf->blockalign);
1314           strf->blockalign = (strf->bits_per_sample * strf->channels) / 8;
1315           strf->av_bps = strf->blockalign * strf->rate;
1316         }
1317       }
1318       rate_max = 48000;
1319       caps = gst_caps_new_empty_simple ("audio/x-mulaw");
1320       if (codec_name)
1321         *codec_name = g_strdup ("Mu-law audio");
1322       break;
1323
1324     case GST_RIFF_WAVE_FORMAT_OKI_ADPCM:
1325       goto unknown;
1326
1327     case GST_RIFF_WAVE_FORMAT_DVI_ADPCM:
1328       rate_max = 48000;
1329       caps = gst_caps_new_simple ("audio/x-adpcm",
1330           "layout", G_TYPE_STRING, "dvi", NULL);
1331       if (codec_name)
1332         *codec_name = g_strdup ("DVI ADPCM audio");
1333       block_align = TRUE;
1334       break;
1335
1336     case GST_RIFF_WAVE_FORMAT_DSP_TRUESPEECH:
1337       rate_min = 8000;
1338       rate_max = 8000;
1339       caps = gst_caps_new_empty_simple ("audio/x-truespeech");
1340       if (codec_name)
1341         *codec_name = g_strdup ("DSP Group TrueSpeech");
1342       break;
1343
1344     case GST_RIFF_WAVE_FORMAT_GSM610:
1345     case GST_RIFF_WAVE_FORMAT_MSN:
1346       rate_min = 1;
1347       caps = gst_caps_new_empty_simple ("audio/ms-gsm");
1348       if (codec_name)
1349         *codec_name = g_strdup ("MS GSM audio");
1350       break;
1351
1352     case GST_RIFF_WAVE_FORMAT_MPEGL12: /* mp1 or mp2 */
1353       rate_min = 16000;
1354       rate_max = 48000;
1355       caps = gst_caps_new_simple ("audio/mpeg",
1356           "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 2, NULL);
1357       if (codec_name)
1358         *codec_name = g_strdup ("MPEG-1 layer 2");
1359       break;
1360
1361     case GST_RIFF_WAVE_FORMAT_MPEGL3:  /* mp3 */
1362       rate_min = 8000;
1363       rate_max = 48000;
1364       caps = gst_caps_new_simple ("audio/mpeg",
1365           "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 3, NULL);
1366       if (codec_name)
1367         *codec_name = g_strdup ("MPEG-1 layer 3");
1368       break;
1369
1370     case GST_RIFF_WAVE_FORMAT_AMR_NB:  /* amr-nb */
1371       rate_min = 8000;
1372       rate_max = 8000;
1373       channels_max = 1;
1374       caps = gst_caps_new_empty_simple ("audio/AMR");
1375       if (codec_name)
1376         *codec_name = g_strdup ("AMR Narrow Band (NB)");
1377       break;
1378
1379     case GST_RIFF_WAVE_FORMAT_AMR_WB:  /* amr-wb */
1380       rate_min = 16000;
1381       rate_max = 16000;
1382       channels_max = 1;
1383       caps = gst_caps_new_empty_simple ("audio/AMR-WB");
1384       if (codec_name)
1385         *codec_name = g_strdup ("AMR Wide Band (WB)");
1386       break;
1387
1388     case GST_RIFF_WAVE_FORMAT_VORBIS1: /* ogg/vorbis mode 1 */
1389     case GST_RIFF_WAVE_FORMAT_VORBIS2: /* ogg/vorbis mode 2 */
1390     case GST_RIFF_WAVE_FORMAT_VORBIS3: /* ogg/vorbis mode 3 */
1391     case GST_RIFF_WAVE_FORMAT_VORBIS1PLUS:     /* ogg/vorbis mode 1+ */
1392     case GST_RIFF_WAVE_FORMAT_VORBIS2PLUS:     /* ogg/vorbis mode 2+ */
1393     case GST_RIFF_WAVE_FORMAT_VORBIS3PLUS:     /* ogg/vorbis mode 3+ */
1394       rate_max = 192000;
1395       caps = gst_caps_new_empty_simple ("audio/x-vorbis");
1396       if (codec_name)
1397         *codec_name = g_strdup ("Vorbis");
1398       break;
1399
1400     case GST_RIFF_WAVE_FORMAT_A52:
1401       channels_max = 6;
1402       caps = gst_caps_new_empty_simple ("audio/x-ac3");
1403       if (codec_name)
1404         *codec_name = g_strdup ("AC-3 audio");
1405       break;
1406     case GST_RIFF_WAVE_FORMAT_DTS:
1407       channels_max = 6;
1408       caps = gst_caps_new_empty_simple ("audio/x-dts");
1409       if (codec_name)
1410         *codec_name = g_strdup ("DTS audio");
1411       /* wavparse is not always able to specify rate/channels for DTS-in-wav */
1412       rate_chan = FALSE;
1413       break;
1414     case GST_RIFF_WAVE_FORMAT_AAC:
1415     case GST_RIFF_WAVE_FORMAT_AAC_AC:
1416     case GST_RIFF_WAVE_FORMAT_AAC_pm:
1417     {
1418       channels_max = 8;
1419       caps = gst_caps_new_simple ("audio/mpeg",
1420           "mpegversion", G_TYPE_INT, 4, NULL);
1421       if (codec_name)
1422         *codec_name = g_strdup ("MPEG-4 AAC audio");
1423       break;
1424     }
1425     case GST_RIFF_WAVE_FORMAT_WMAV1:
1426     case GST_RIFF_WAVE_FORMAT_WMAV2:
1427     case GST_RIFF_WAVE_FORMAT_WMAV3:
1428     case GST_RIFF_WAVE_FORMAT_WMAV3_L:
1429     {
1430       gint version = (codec_id - GST_RIFF_WAVE_FORMAT_WMAV1) + 1;
1431
1432       channels_max = 6;
1433       block_align = TRUE;
1434
1435       caps = gst_caps_new_simple ("audio/x-wma",
1436           "wmaversion", G_TYPE_INT, version, NULL);
1437
1438       if (codec_name) {
1439         if (codec_id == GST_RIFF_WAVE_FORMAT_WMAV3_L)
1440           *codec_name = g_strdup ("WMA Lossless");
1441         else
1442           *codec_name = g_strdup_printf ("WMA Version %d", version + 6);
1443       }
1444
1445       if (strf != NULL) {
1446         gst_caps_set_simple (caps,
1447             "bitrate", G_TYPE_INT, strf->av_bps * 8,
1448             "depth", G_TYPE_INT, strf->bits_per_sample, NULL);
1449       } else {
1450         gst_caps_set_simple (caps,
1451             "bitrate", GST_TYPE_INT_RANGE, 0, G_MAXINT, NULL);
1452       }
1453       break;
1454     }
1455     case GST_RIFF_WAVE_FORMAT_SONY_ATRAC3:
1456       caps = gst_caps_new_empty_simple ("audio/x-vnd.sony.atrac3");
1457       if (codec_name)
1458         *codec_name = g_strdup ("Sony ATRAC3");
1459       break;
1460
1461     case GST_RIFF_WAVE_FORMAT_SIREN:
1462       caps = gst_caps_new_empty_simple ("audio/x-siren");
1463       if (codec_name)
1464         *codec_name = g_strdup ("Siren7");
1465       rate_chan = FALSE;
1466       break;
1467
1468     case GST_RIFF_WAVE_FORMAT_ADPCM_IMA_DK4:
1469       rate_min = 8000;
1470       rate_max = 96000;
1471       channels_max = 2;
1472       caps =
1473           gst_caps_new_simple ("audio/x-adpcm", "layout", G_TYPE_STRING, "dk4",
1474           NULL);
1475       if (codec_name)
1476         *codec_name = g_strdup ("IMA/DK4 ADPCM");
1477       break;
1478     case GST_RIFF_WAVE_FORMAT_ADPCM_IMA_DK3:
1479       rate_min = 8000;
1480       rate_max = 96000;
1481       channels_max = 2;
1482       caps =
1483           gst_caps_new_simple ("audio/x-adpcm", "layout", G_TYPE_STRING, "dk3",
1484           NULL);
1485       if (codec_name)
1486         *codec_name = g_strdup ("IMA/DK3 ADPCM");
1487       break;
1488
1489     case GST_RIFF_WAVE_FORMAT_ADPCM_IMA_WAV:
1490       rate_min = 8000;
1491       rate_max = 96000;
1492       channels_max = 2;
1493       caps =
1494           gst_caps_new_simple ("audio/x-adpcm", "layout", G_TYPE_STRING, "dvi",
1495           NULL);
1496       if (codec_name)
1497         *codec_name = g_strdup ("IMA/WAV ADPCM");
1498       break;
1499     case GST_RIFF_WAVE_FORMAT_EXTENSIBLE:{
1500       guint16 valid_bits_per_sample;
1501       guint32 channel_mask;
1502       guint32 subformat_guid[4];
1503       GstMapInfo info;
1504       gsize size;
1505
1506       channels_max = 8;
1507
1508       /* should be at least 22 bytes */
1509       size = gst_buffer_get_size (strf_data);
1510
1511       if (strf_data == NULL || size < 22) {
1512         GST_WARNING ("WAVE_FORMAT_EXTENSIBLE data size is %" G_GSIZE_FORMAT
1513             " (expected: 22)", (strf_data) ? size : -1);
1514         return NULL;
1515       }
1516
1517       gst_buffer_map (strf_data, &info, GST_MAP_READ);
1518       valid_bits_per_sample = GST_READ_UINT16_LE (info.data);
1519       channel_mask = GST_READ_UINT32_LE (info.data + 2);
1520       subformat_guid[0] = GST_READ_UINT32_LE (info.data + 6);
1521       subformat_guid[1] = GST_READ_UINT32_LE (info.data + 10);
1522       subformat_guid[2] = GST_READ_UINT32_LE (info.data + 14);
1523       subformat_guid[3] = GST_READ_UINT32_LE (info.data + 18);
1524       gst_buffer_unmap (strf_data, &info);
1525
1526       GST_DEBUG ("valid bps    = %u", valid_bits_per_sample);
1527       GST_DEBUG ("channel mask = 0x%08x", channel_mask);
1528       GST_DEBUG ("GUID         = %08x-%08x-%08x-%08x", subformat_guid[0],
1529           subformat_guid[1], subformat_guid[2], subformat_guid[3]);
1530
1531       if (subformat_guid[1] == 0x00100000 &&
1532           subformat_guid[2] == 0xaa000080 && subformat_guid[3] == 0x719b3800) {
1533         if (subformat_guid[0] == 0x00000001) {
1534           GST_DEBUG ("PCM");
1535           if (strf != NULL) {
1536             gint ba = strf->blockalign;
1537             gint wd = ba * 8 / strf->channels;
1538             gint ws;
1539             GstAudioFormat format;
1540
1541             /* in riff, the depth is stored in the size field but it just
1542              * means that the _least_ significant bits are cleared. We can
1543              * therefore just play the sample as if it had a depth == width */
1544             ws = wd;
1545
1546             /* For reference, use this to get the actual depth:
1547              * ws = strf->bits_per_sample;
1548              * if (valid_bits_per_sample != 0)
1549              *   ws = valid_bits_per_sample; */
1550
1551             format =
1552                 gst_audio_format_build_integer (wd != 8, G_LITTLE_ENDIAN, wd,
1553                 ws);
1554
1555             caps = gst_caps_new_simple ("audio/x-raw",
1556                 "format", G_TYPE_STRING, gst_audio_format_to_string (format),
1557                 "layout", G_TYPE_STRING, "interleaved",
1558                 "channels", G_TYPE_INT, strf->channels,
1559                 "rate", G_TYPE_INT, strf->rate, NULL);
1560
1561             if (codec_name) {
1562               *codec_name = g_strdup_printf ("Uncompressed %d-bit PCM audio",
1563                   strf->bits_per_sample);
1564             }
1565           }
1566         } else if (subformat_guid[0] == 0x00000003) {
1567           GST_DEBUG ("FLOAT");
1568           if (strf != NULL) {
1569             gint ba = strf->blockalign;
1570             gint wd = ba * 8 / strf->channels;
1571
1572             caps = gst_caps_new_simple ("audio/x-raw",
1573                 "format", G_TYPE_STRING, wd == 32 ? "F32LE" : "F64LE",
1574                 "layout", G_TYPE_STRING, "interleaved",
1575                 "channels", G_TYPE_INT, strf->channels,
1576                 "rate", G_TYPE_INT, strf->rate, NULL);
1577
1578             if (codec_name) {
1579               *codec_name =
1580                   g_strdup_printf ("Uncompressed %d-bit IEEE float audio",
1581                   strf->bits_per_sample);
1582             }
1583           }
1584         } else if (subformat_guid[0] == 0x0000006) {
1585           GST_DEBUG ("ALAW");
1586           if (strf != NULL) {
1587             if (strf->bits_per_sample != 8) {
1588               GST_WARNING ("invalid depth (%d) of alaw audio, overwriting.",
1589                   strf->bits_per_sample);
1590               strf->bits_per_sample = 8;
1591               strf->av_bps = 8;
1592               strf->blockalign = strf->av_bps * strf->channels;
1593             }
1594             if (strf->av_bps == 0 || strf->blockalign == 0) {
1595               GST_WARNING
1596                   ("fixing av_bps (%d) and blockalign (%d) of alaw audio",
1597                   strf->av_bps, strf->blockalign);
1598               strf->av_bps = strf->bits_per_sample;
1599               strf->blockalign = strf->av_bps * strf->channels;
1600             }
1601           }
1602           rate_max = 48000;
1603           caps = gst_caps_new_empty_simple ("audio/x-alaw");
1604
1605           if (codec_name)
1606             *codec_name = g_strdup ("A-law audio");
1607         } else if (subformat_guid[0] == 0x00000007) {
1608           GST_DEBUG ("MULAW");
1609           if (strf != NULL) {
1610             if (strf->bits_per_sample != 8) {
1611               GST_WARNING ("invalid depth (%d) of mulaw audio, overwriting.",
1612                   strf->bits_per_sample);
1613               strf->bits_per_sample = 8;
1614               strf->av_bps = 8;
1615               strf->blockalign = strf->av_bps * strf->channels;
1616             }
1617             if (strf->av_bps == 0 || strf->blockalign == 0) {
1618               GST_WARNING
1619                   ("fixing av_bps (%d) and blockalign (%d) of mulaw audio",
1620                   strf->av_bps, strf->blockalign);
1621               strf->av_bps = strf->bits_per_sample;
1622               strf->blockalign = strf->av_bps * strf->channels;
1623             }
1624           }
1625           rate_max = 48000;
1626           caps = gst_caps_new_empty_simple ("audio/x-mulaw");
1627           if (codec_name)
1628             *codec_name = g_strdup ("Mu-law audio");
1629         } else if (subformat_guid[0] == 0x00000092) {
1630           GST_DEBUG ("FIXME: handle DOLBY AC3 SPDIF format");
1631           GST_DEBUG ("WAVE_FORMAT_EXTENSIBLE AC-3 SPDIF audio");
1632           caps = gst_caps_new_empty_simple ("audio/x-ac3");
1633           if (codec_name)
1634             *codec_name = g_strdup ("wavext AC-3 SPDIF audio");
1635         } else if (subformat_guid[0] == GST_RIFF_WAVE_FORMAT_EXTENSIBLE) {
1636           GST_DEBUG ("WAVE_FORMAT_EXTENSIBLE nested");
1637         } else {
1638           /* recurse where no special consideration has yet to be identified
1639            * for the subformat guid */
1640           caps = gst_riff_create_audio_caps (subformat_guid[0], strh, strf,
1641               strf_data, strd_data, codec_name, channel_reorder_map);
1642           if (!codec_name)
1643             GST_DEBUG ("WAVE_FORMAT_EXTENSIBLE audio");
1644           if (caps) {
1645             if (codec_name) {
1646               GST_DEBUG ("WAVE_FORMAT_EXTENSIBLE %s", *codec_name);
1647               *codec_name = g_strjoin ("wavext ", *codec_name, NULL);
1648             }
1649             return caps;
1650           }
1651         }
1652       } else if (subformat_guid[0] == 0x6ba47966 &&
1653           subformat_guid[1] == 0x41783f83 &&
1654           subformat_guid[2] == 0xf0006596 && subformat_guid[3] == 0xe59262bf) {
1655         caps = gst_caps_new_empty_simple ("application/x-ogg-avi");
1656         if (codec_name)
1657           *codec_name = g_strdup ("Ogg-AVI");
1658       }
1659
1660       if (strf != NULL) {
1661         /* If channel_mask == 0 and channels > 1 let's
1662          * assume default layout as some wav files don't have the
1663          * channel mask set. Don't set the layout for 1 channel. */
1664         if (channel_mask == 0 && strf->channels > 1)
1665           channel_mask =
1666               gst_riff_wavext_get_default_channel_mask (strf->channels);
1667
1668         if ((channel_mask != 0 || strf->channels > 1) &&
1669             !gst_riff_wavext_add_channel_mask (caps, strf->channels,
1670                 channel_mask, channel_reorder_map)) {
1671           GST_WARNING ("failed to add channel layout");
1672           gst_caps_unref (caps);
1673           caps = NULL;
1674         }
1675         rate_chan = FALSE;
1676       }
1677
1678       if (caps == NULL) {
1679         GST_WARNING ("Unknown WAVE_FORMAT_EXTENSIBLE audio format");
1680         return NULL;
1681       }
1682       break;
1683     }
1684       /* can anything decode these? pitfdll? */
1685     case GST_RIFF_WAVE_FORMAT_VOXWARE_AC8:
1686     case GST_RIFF_WAVE_FORMAT_VOXWARE_AC10:
1687     case GST_RIFF_WAVE_FORMAT_VOXWARE_AC16:
1688     case GST_RIFF_WAVE_FORMAT_VOXWARE_AC20:
1689     case GST_RIFF_WAVE_FORMAT_VOXWARE_METAVOICE:
1690     case GST_RIFF_WAVE_FORMAT_VOXWARE_METASOUND:
1691     case GST_RIFF_WAVE_FORMAT_VOXWARE_RT29HW:
1692     case GST_RIFF_WAVE_FORMAT_VOXWARE_VR12:
1693     case GST_RIFF_WAVE_FORMAT_VOXWARE_VR18:
1694     case GST_RIFF_WAVE_FORMAT_VOXWARE_TQ40:
1695     case GST_RIFF_WAVE_FORMAT_VOXWARE_TQ60:{
1696       caps = gst_caps_new_simple ("audio/x-voxware",
1697           "voxwaretype", G_TYPE_INT, (gint) codec_id, NULL);
1698       if (codec_name)
1699         *codec_name = g_strdup ("Voxware");
1700       break;
1701     }
1702     default:
1703     unknown:
1704       GST_WARNING ("Unknown audio tag 0x%04x", codec_id);
1705       return NULL;
1706   }
1707
1708   if (strf != NULL) {
1709     if (rate_chan) {
1710       if (strf->channels > channels_max)
1711         goto too_many_channels;
1712       if (strf->rate < rate_min || strf->rate > rate_max)
1713         goto invalid_rate;
1714
1715       gst_caps_set_simple (caps,
1716           "rate", G_TYPE_INT, strf->rate,
1717           "channels", G_TYPE_INT, strf->channels, NULL);
1718     }
1719     if (block_align) {
1720       gst_caps_set_simple (caps,
1721           "block_align", G_TYPE_INT, strf->blockalign, NULL);
1722     }
1723   } else {
1724     if (rate_chan) {
1725       if (rate_min == rate_max)
1726         gst_caps_set_simple (caps, "rate", G_TYPE_INT, rate_min, NULL);
1727       else
1728         gst_caps_set_simple (caps,
1729             "rate", GST_TYPE_INT_RANGE, rate_min, rate_max, NULL);
1730       if (channels_max == 1)
1731         gst_caps_set_simple (caps, "channels", G_TYPE_INT, 1, NULL);
1732       else
1733         gst_caps_set_simple (caps,
1734             "channels", GST_TYPE_INT_RANGE, 1, channels_max, NULL);
1735     }
1736     if (block_align) {
1737       gst_caps_set_simple (caps,
1738           "block_align", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL);
1739     }
1740   }
1741
1742   /* extradata */
1743   if (strf_data || strd_data) {
1744     gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER,
1745         strf_data ? strf_data : strd_data, NULL);
1746   }
1747
1748   return caps;
1749
1750   /* ERROR */
1751 too_many_channels:
1752   GST_WARNING
1753       ("Stream claims to contain %u channels, but format only supports %d",
1754       strf->channels, channels_max);
1755   gst_caps_unref (caps);
1756   return NULL;
1757 invalid_rate:
1758   GST_WARNING
1759       ("Stream with sample_rate %u, but format only supports %d .. %d",
1760       strf->rate, rate_min, rate_max);
1761   gst_caps_unref (caps);
1762   return NULL;
1763 }
1764
1765 GstCaps *
1766 gst_riff_create_iavs_caps (guint32 codec_fcc,
1767     gst_riff_strh * strh, gst_riff_strf_iavs * strf,
1768     GstBuffer * init_data, GstBuffer * extra_data, char **codec_name)
1769 {
1770   GstCaps *caps = NULL;
1771
1772   switch (codec_fcc) {
1773       /* is this correct? */
1774     case GST_MAKE_FOURCC ('D', 'V', 'S', 'D'):
1775     case GST_MAKE_FOURCC ('d', 'v', 's', 'd'):
1776       caps = gst_caps_new_simple ("video/x-dv",
1777           "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
1778       if (codec_name)
1779         *codec_name = g_strdup ("Generic DV");
1780       break;
1781
1782     default:
1783       GST_WARNING ("Unknown IAVS fourcc %" GST_FOURCC_FORMAT,
1784           GST_FOURCC_ARGS (codec_fcc));
1785       return NULL;
1786   }
1787
1788   return caps;
1789 }
1790
1791 /*
1792  * Functions below are for template caps. All is variable.
1793  */
1794
1795 GstCaps *
1796 gst_riff_create_video_template_caps (void)
1797 {
1798   static const guint32 tags[] = {
1799     GST_MAKE_FOURCC ('3', 'I', 'V', '1'),
1800     GST_MAKE_FOURCC ('A', 'S', 'V', '1'),
1801     GST_MAKE_FOURCC ('A', 'S', 'V', '2'),
1802     GST_MAKE_FOURCC ('C', 'L', 'J', 'R'),
1803     GST_MAKE_FOURCC ('C', 'S', 'C', 'D'),
1804     GST_MAKE_FOURCC ('C', 'Y', 'U', 'V'),
1805     GST_MAKE_FOURCC ('D', 'I', 'B', ' '),
1806     GST_MAKE_FOURCC ('D', 'I', 'V', '3'),
1807     GST_MAKE_FOURCC ('D', 'I', 'V', 'X'),
1808     GST_MAKE_FOURCC ('D', 'U', 'C', 'K'),
1809     GST_MAKE_FOURCC ('D', 'V', 'S', 'D'),
1810     GST_MAKE_FOURCC ('D', 'V', '5', '0'),
1811     GST_MAKE_FOURCC ('D', 'X', '5', '0'),
1812     GST_MAKE_FOURCC ('M', '4', 'C', 'C'),
1813     GST_MAKE_FOURCC ('F', 'L', 'V', '1'),
1814     GST_MAKE_FOURCC ('F', 'L', 'V', '4'),
1815     GST_MAKE_FOURCC ('H', '2', '6', '3'),
1816     GST_MAKE_FOURCC ('V', 'X', '1', 'K'),
1817     GST_MAKE_FOURCC ('H', '2', '6', '4'),
1818     GST_MAKE_FOURCC ('H', 'F', 'Y', 'U'),
1819     GST_MAKE_FOURCC ('I', '2', '6', '3'),
1820     GST_MAKE_FOURCC ('I', '4', '2', '0'),
1821     GST_MAKE_FOURCC ('I', 'V', '3', '2'),
1822     GST_MAKE_FOURCC ('I', 'V', '4', '1'),
1823     GST_MAKE_FOURCC ('I', 'V', '5', '0'),
1824     GST_MAKE_FOURCC ('L', '2', '6', '3'),
1825     GST_MAKE_FOURCC ('L', '2', '6', '4'),
1826     GST_MAKE_FOURCC ('M', '2', '6', '3'),
1827     GST_MAKE_FOURCC ('M', '4', 'S', '2'),
1828     GST_MAKE_FOURCC ('M', 'J', 'P', 'G'),
1829     GST_MAKE_FOURCC ('M', 'P', '4', '2'),
1830     GST_MAKE_FOURCC ('M', 'P', '4', '3'),
1831     GST_MAKE_FOURCC ('M', 'P', 'E', 'G'),
1832     GST_MAKE_FOURCC ('M', 'P', 'G', '2'),
1833     GST_MAKE_FOURCC ('M', 'P', 'G', '4'),
1834     GST_MAKE_FOURCC ('M', 'S', 'Z', 'H'),
1835     GST_MAKE_FOURCC ('P', 'N', 'G', ' '),
1836     GST_MAKE_FOURCC ('R', 'L', 'E', ' '),
1837     GST_MAKE_FOURCC ('R', 'T', '2', '1'),
1838     GST_MAKE_FOURCC ('S', 'P', '5', '3'),
1839     GST_MAKE_FOURCC ('T', 'M', '2', '0'),
1840     GST_MAKE_FOURCC ('T', 'S', 'C', 'C'),
1841     GST_MAKE_FOURCC ('U', 'L', 'T', 'I'),
1842     GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'),
1843     GST_MAKE_FOURCC ('V', 'C', 'R', '1'),
1844     GST_MAKE_FOURCC ('V', 'C', 'R', '2'),
1845     GST_MAKE_FOURCC ('V', 'D', 'O', 'W'),
1846     GST_MAKE_FOURCC ('V', 'I', 'V', 'O'),
1847     GST_MAKE_FOURCC ('V', 'M', 'n', 'c'),
1848     GST_MAKE_FOURCC ('V', 'P', '3', ' '),
1849     GST_MAKE_FOURCC ('V', 'S', 'S', 'H'),
1850     GST_MAKE_FOURCC ('W', 'M', 'V', '1'),
1851     GST_MAKE_FOURCC ('W', 'M', 'V', '2'),
1852     GST_MAKE_FOURCC ('W', 'M', 'V', '3'),
1853     GST_MAKE_FOURCC ('X', 'V', 'I', 'D'),
1854     GST_MAKE_FOURCC ('X', 'x', 'a', 'n'),
1855     GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'),
1856     GST_MAKE_FOURCC ('Y', 'V', 'U', '9'),
1857     GST_MAKE_FOURCC ('Z', 'L', 'I', 'B'),
1858     GST_MAKE_FOURCC ('c', 'v', 'i', 'd'),
1859     GST_MAKE_FOURCC ('h', '2', '6', '4'),
1860     GST_MAKE_FOURCC ('m', 's', 'v', 'c'),
1861     GST_MAKE_FOURCC ('x', '2', '6', '3'),
1862     GST_MAKE_FOURCC ('d', 'r', 'a', 'c'),
1863     GST_MAKE_FOURCC ('F', 'F', 'V', '1'),
1864     GST_MAKE_FOURCC ('K', 'M', 'V', 'C'),
1865     GST_MAKE_FOURCC ('V', 'P', '5', '0'),
1866     GST_MAKE_FOURCC ('V', 'P', '6', '0'),
1867     GST_MAKE_FOURCC ('V', 'P', '6', 'F'),
1868     GST_MAKE_FOURCC ('V', 'P', '7', '0'),
1869     GST_MAKE_FOURCC ('V', 'P', '8', '0'),
1870     GST_MAKE_FOURCC ('L', 'M', '2', '0'),
1871     GST_MAKE_FOURCC ('R', 'P', 'Z', 'A'),
1872     GST_MAKE_FOURCC ('T', 'H', 'E', 'O'),
1873     GST_MAKE_FOURCC ('F', 'P', 'S', '1'),
1874     GST_MAKE_FOURCC ('A', 'A', 'S', 'C'),
1875     GST_MAKE_FOURCC ('Y', 'V', '1', '2'),
1876     GST_MAKE_FOURCC ('L', 'O', 'C', 'O'),
1877     GST_MAKE_FOURCC ('Z', 'M', 'B', 'V'),
1878     GST_MAKE_FOURCC ('v', '2', '1', '0'),
1879     GST_MAKE_FOURCC ('r', '2', '1', '0'),
1880     /* FILL ME */
1881   };
1882   guint i;
1883   GstCaps *caps, *one;
1884
1885   caps = gst_caps_new_empty ();
1886   for (i = 0; i < G_N_ELEMENTS (tags); i++) {
1887     one = gst_riff_create_video_caps (tags[i], NULL, NULL, NULL, NULL, NULL);
1888     if (one)
1889       gst_caps_append (caps, one);
1890   }
1891
1892   return caps;
1893 }
1894
1895 GstCaps *
1896 gst_riff_create_audio_template_caps (void)
1897 {
1898   static const guint16 tags[] = {
1899     GST_RIFF_WAVE_FORMAT_GSM610,
1900     GST_RIFF_WAVE_FORMAT_MPEGL3,
1901     GST_RIFF_WAVE_FORMAT_MPEGL12,
1902     GST_RIFF_WAVE_FORMAT_PCM,
1903     GST_RIFF_WAVE_FORMAT_VORBIS1,
1904     GST_RIFF_WAVE_FORMAT_A52,
1905     GST_RIFF_WAVE_FORMAT_DTS,
1906     GST_RIFF_WAVE_FORMAT_AAC,
1907     GST_RIFF_WAVE_FORMAT_ALAW,
1908     GST_RIFF_WAVE_FORMAT_MULAW,
1909     GST_RIFF_WAVE_FORMAT_WMS,
1910     GST_RIFF_WAVE_FORMAT_ADPCM,
1911     GST_RIFF_WAVE_FORMAT_DVI_ADPCM,
1912     GST_RIFF_WAVE_FORMAT_DSP_TRUESPEECH,
1913     GST_RIFF_WAVE_FORMAT_WMAV1,
1914     GST_RIFF_WAVE_FORMAT_WMAV2,
1915     GST_RIFF_WAVE_FORMAT_WMAV3,
1916     GST_RIFF_WAVE_FORMAT_SONY_ATRAC3,
1917     GST_RIFF_WAVE_FORMAT_IEEE_FLOAT,
1918     GST_RIFF_WAVE_FORMAT_VOXWARE_METASOUND,
1919     GST_RIFF_WAVE_FORMAT_ADPCM_IMA_DK4,
1920     GST_RIFF_WAVE_FORMAT_ADPCM_IMA_DK3,
1921     GST_RIFF_WAVE_FORMAT_ADPCM_IMA_WAV,
1922     GST_RIFF_WAVE_FORMAT_AMR_NB,
1923     GST_RIFF_WAVE_FORMAT_AMR_WB,
1924     GST_RIFF_WAVE_FORMAT_SIREN,
1925     /* FILL ME */
1926   };
1927   guint i;
1928   GstCaps *caps, *one;
1929
1930   caps = gst_caps_new_empty ();
1931   for (i = 0; i < G_N_ELEMENTS (tags); i++) {
1932     one =
1933         gst_riff_create_audio_caps (tags[i], NULL, NULL, NULL, NULL, NULL,
1934         NULL);
1935     if (one)
1936       gst_caps_append (caps, one);
1937   }
1938   one = gst_caps_new_empty_simple ("application/x-ogg-avi");
1939   gst_caps_append (caps, one);
1940
1941   return caps;
1942 }
1943
1944 GstCaps *
1945 gst_riff_create_iavs_template_caps (void)
1946 {
1947   static const guint32 tags[] = {
1948     GST_MAKE_FOURCC ('D', 'V', 'S', 'D')
1949         /* FILL ME */
1950   };
1951   guint i;
1952   GstCaps *caps, *one;
1953
1954   caps = gst_caps_new_empty ();
1955   for (i = 0; i < G_N_ELEMENTS (tags); i++) {
1956     one = gst_riff_create_iavs_caps (tags[i], NULL, NULL, NULL, NULL, NULL);
1957     if (one)
1958       gst_caps_append (caps, one);
1959   }
1960
1961   return caps;
1962 }