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