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