1 /* GStreamer Wavpack parser
2 * Copyright (C) 2012 Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
3 * Copyright (C) 2012 Nokia Corporation. All rights reserved.
4 * Contact: Stefan Kost <stefan.kost@nokia.com>
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 * SECTION:element-wavpackparse
23 * @title: wavpackparse
24 * @short_description: Wavpack parser
25 * @see_also: #GstAmrParse, #GstAACParse
26 *
27 * This is an Wavpack parser.
28 *
29 * ## Example launch line
30 * |[
31 * gst-launch-1.0 filesrc location=abc.wavpack ! wavpackparse ! wavpackdec ! audioresample ! audioconvert ! autoaudiosink
32 * ]|
33 *
34 */
35
36 #ifdef HAVE_CONFIG_H
37 #include "config.h"
38 #endif
39
40 #include <string.h>
41
42 #include "gstaudioparserselements.h"
43 #include "gstwavpackparse.h"
44
45 #include <gst/base/base.h>
46 #include <gst/pbutils/pbutils.h>
47 #include <gst/audio/audio.h>
48
49 GST_DEBUG_CATEGORY_STATIC (wavpack_parse_debug);
50 #define GST_CAT_DEFAULT wavpack_parse_debug
51
52 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
53 GST_PAD_SRC,
54 GST_PAD_ALWAYS,
55 GST_STATIC_CAPS ("audio/x-wavpack, "
56 "depth = (int) [ 1, 32 ], "
57 "channels = (int) [ 1, 8 ], "
58 "rate = (int) [ 6000, 192000 ], " "framed = (boolean) TRUE; "
59 "audio/x-wavpack-correction, " "framed = (boolean) TRUE")
60 );
61
62 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
63 GST_PAD_SINK,
64 GST_PAD_ALWAYS,
65 GST_STATIC_CAPS ("audio/x-wavpack; audio/x-wavpack-correction"));
66
67 static void gst_wavpack_parse_finalize (GObject * object);
68
69 static gboolean gst_wavpack_parse_start (GstBaseParse * parse);
70 static gboolean gst_wavpack_parse_stop (GstBaseParse * parse);
71 static GstFlowReturn gst_wavpack_parse_handle_frame (GstBaseParse * parse,
72 GstBaseParseFrame * frame, gint * skipsize);
73 static GstCaps *gst_wavpack_parse_get_sink_caps (GstBaseParse * parse,
74 GstCaps * filter);
75 static GstFlowReturn gst_wavpack_parse_pre_push_frame (GstBaseParse * parse,
76 GstBaseParseFrame * frame);
77
78 #define gst_wavpack_parse_parent_class parent_class
79 G_DEFINE_TYPE (GstWavpackParse, gst_wavpack_parse, GST_TYPE_BASE_PARSE);
80 GST_ELEMENT_REGISTER_DEFINE (wavpackparse, "wavpackparse",
81 GST_RANK_PRIMARY + 1, GST_TYPE_WAVPACK_PARSE);
82
83 static void
gst_wavpack_parse_class_init(GstWavpackParseClass * klass)84 gst_wavpack_parse_class_init (GstWavpackParseClass * klass)
85 {
86 GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass);
87 GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
88 GObjectClass *object_class = G_OBJECT_CLASS (klass);
89
90 GST_DEBUG_CATEGORY_INIT (wavpack_parse_debug, "wavpackparse", 0,
91 "Wavpack audio stream parser");
92
93 object_class->finalize = gst_wavpack_parse_finalize;
94
95 parse_class->start = GST_DEBUG_FUNCPTR (gst_wavpack_parse_start);
96 parse_class->stop = GST_DEBUG_FUNCPTR (gst_wavpack_parse_stop);
97 parse_class->handle_frame =
98 GST_DEBUG_FUNCPTR (gst_wavpack_parse_handle_frame);
99 parse_class->get_sink_caps =
100 GST_DEBUG_FUNCPTR (gst_wavpack_parse_get_sink_caps);
101 parse_class->pre_push_frame =
102 GST_DEBUG_FUNCPTR (gst_wavpack_parse_pre_push_frame);
103
104 gst_element_class_add_static_pad_template (element_class, &sink_template);
105 gst_element_class_add_static_pad_template (element_class, &src_template);
106
107 gst_element_class_set_static_metadata (element_class,
108 "Wavpack audio stream parser", "Codec/Parser/Audio",
109 "Wavpack parser", "Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>");
110 }
111
112 static void
gst_wavpack_parse_reset(GstWavpackParse * wvparse)113 gst_wavpack_parse_reset (GstWavpackParse * wvparse)
114 {
115 wvparse->channels = -1;
116 wvparse->channel_mask = 0;
117 wvparse->sample_rate = -1;
118 wvparse->width = -1;
119 wvparse->total_samples = 0;
120 wvparse->sent_codec_tag = FALSE;
121 }
122
123 static void
gst_wavpack_parse_init(GstWavpackParse * wvparse)124 gst_wavpack_parse_init (GstWavpackParse * wvparse)
125 {
126 gst_wavpack_parse_reset (wvparse);
127 GST_PAD_SET_ACCEPT_INTERSECT (GST_BASE_PARSE_SINK_PAD (wvparse));
128 GST_PAD_SET_ACCEPT_TEMPLATE (GST_BASE_PARSE_SINK_PAD (wvparse));
129 }
130
131 static void
gst_wavpack_parse_finalize(GObject * object)132 gst_wavpack_parse_finalize (GObject * object)
133 {
134 G_OBJECT_CLASS (parent_class)->finalize (object);
135 }
136
137 static gboolean
gst_wavpack_parse_start(GstBaseParse * parse)138 gst_wavpack_parse_start (GstBaseParse * parse)
139 {
140 GstWavpackParse *wvparse = GST_WAVPACK_PARSE (parse);
141
142 GST_DEBUG_OBJECT (parse, "starting");
143
144 gst_wavpack_parse_reset (wvparse);
145
146 /* need header at least */
147 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (wvparse),
148 sizeof (WavpackHeader));
149
150 /* inform baseclass we can come up with ts, based on counters in packets */
151 gst_base_parse_set_has_timing_info (GST_BASE_PARSE_CAST (wvparse), TRUE);
152 gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (wvparse), TRUE);
153
154 return TRUE;
155 }
156
157 static gboolean
gst_wavpack_parse_stop(GstBaseParse * parse)158 gst_wavpack_parse_stop (GstBaseParse * parse)
159 {
160 GST_DEBUG_OBJECT (parse, "stopping");
161
162 return TRUE;
163 }
164
165 static gint
gst_wavpack_get_default_channel_mask(gint nchannels)166 gst_wavpack_get_default_channel_mask (gint nchannels)
167 {
168 gint channel_mask = 0;
169
170 /* Set the default channel mask for the given number of channels.
171 * It's the same as for WAVE_FORMAT_EXTENDED:
172 * http://www.microsoft.com/whdc/device/audio/multichaud.mspx
173 */
174 switch (nchannels) {
175 case 11:
176 channel_mask |= 0x00400;
177 channel_mask |= 0x00200;
178 case 9:
179 channel_mask |= 0x00100;
180 case 8:
181 channel_mask |= 0x00080;
182 channel_mask |= 0x00040;
183 case 6:
184 channel_mask |= 0x00020;
185 channel_mask |= 0x00010;
186 case 4:
187 channel_mask |= 0x00008;
188 case 3:
189 channel_mask |= 0x00004;
190 case 2:
191 channel_mask |= 0x00002;
192 channel_mask |= 0x00001;
193 break;
194 case 1:
195 /* For mono use front center */
196 channel_mask |= 0x00004;
197 break;
198 }
199
200 return channel_mask;
201 }
202
203 static const struct
204 {
205 const guint32 ms_mask;
206 const GstAudioChannelPosition gst_pos;
207 } layout_mapping[] = {
208 {
209 0x00001, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT}, {
210 0x00002, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}, {
211 0x00004, GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER}, {
212 0x00008, GST_AUDIO_CHANNEL_POSITION_LFE1}, {
213 0x00010, GST_AUDIO_CHANNEL_POSITION_REAR_LEFT}, {
214 0x00020, GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT}, {
215 0x00040, GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER}, {
216 0x00080, GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER}, {
217 0x00100, GST_AUDIO_CHANNEL_POSITION_REAR_CENTER}, {
218 0x00200, GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT}, {
219 0x00400, GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT}, {
220 0x00800, GST_AUDIO_CHANNEL_POSITION_TOP_CENTER}, {
221 0x01000, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT}, {
222 0x02000, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER}, {
223 0x04000, GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT}, {
224 0x08000, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT}, {
225 0x10000, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER}, {
226 0x20000, GST_AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT}
227 };
228
229 #define MAX_CHANNEL_POSITIONS G_N_ELEMENTS (layout_mapping)
230
231 static gboolean
gst_wavpack_get_channel_positions(gint num_channels,gint layout,GstAudioChannelPosition * pos)232 gst_wavpack_get_channel_positions (gint num_channels, gint layout,
233 GstAudioChannelPosition * pos)
234 {
235 gint i, p;
236
237 if (num_channels == 1 && layout == 0x00004) {
238 pos[0] = GST_AUDIO_CHANNEL_POSITION_MONO;
239 return TRUE;
240 }
241
242 p = 0;
243 for (i = 0; i < MAX_CHANNEL_POSITIONS; ++i) {
244 if ((layout & layout_mapping[i].ms_mask) != 0) {
245 if (p >= num_channels) {
246 GST_WARNING ("More bits set in the channel layout map than there "
247 "are channels! Broken file");
248 return FALSE;
249 }
250 if (layout_mapping[i].gst_pos == GST_AUDIO_CHANNEL_POSITION_INVALID) {
251 GST_WARNING ("Unsupported channel position (mask 0x%08x) in channel "
252 "layout map - ignoring those channels", layout_mapping[i].ms_mask);
253 /* what to do? just ignore it and let downstream deal with a channel
254 * layout that has INVALID positions in it for now ... */
255 }
256 pos[p] = layout_mapping[i].gst_pos;
257 ++p;
258 }
259 }
260
261 if (p != num_channels) {
262 GST_WARNING ("Only %d bits set in the channel layout map, but there are "
263 "supposed to be %d channels! Broken file", p, num_channels);
264 return FALSE;
265 }
266
267 return TRUE;
268 }
269
270 static const guint32 sample_rates[] = {
271 6000, 8000, 9600, 11025, 12000, 16000, 22050,
272 24000, 32000, 44100, 48000, 64000, 88200, 96000, 192000
273 };
274
275 #define CHECK(call) { \
276 if (!call) \
277 goto read_failed; \
278 }
279
280 /* caller ensures properly sync'ed with enough data */
281 static gboolean
gst_wavpack_parse_frame_metadata(GstWavpackParse * parse,GstBuffer * buf,gint skip,WavpackHeader * wph,WavpackInfo * wpi)282 gst_wavpack_parse_frame_metadata (GstWavpackParse * parse, GstBuffer * buf,
283 gint skip, WavpackHeader * wph, WavpackInfo * wpi)
284 {
285 GstByteReader br;
286 gint i;
287 GstMapInfo map;
288
289 g_return_val_if_fail (wph != NULL || wpi != NULL, FALSE);
290 g_return_val_if_fail (gst_buffer_get_size (buf) >=
291 skip + sizeof (WavpackHeader), FALSE);
292
293 gst_buffer_map (buf, &map, GST_MAP_READ);
294
295 gst_byte_reader_init (&br, map.data + skip, wph->ckSize + 8);
296 /* skip past header */
297 gst_byte_reader_skip_unchecked (&br, sizeof (WavpackHeader));
298
299 /* get some basics from header */
300 i = (wph->flags >> 23) & 0xF;
301 if (!wpi->rate)
302 wpi->rate = (i < G_N_ELEMENTS (sample_rates)) ? sample_rates[i] : 44100;
303 wpi->width = ((wph->flags & 0x3) + 1) * 8;
304 if (!wpi->channels)
305 wpi->channels = (wph->flags & 0x4) ? 1 : 2;
306 if (!wpi->channel_mask)
307 wpi->channel_mask = 5 - wpi->channels;
308
309 /* need to dig metadata blocks for some more */
310 while (gst_byte_reader_get_remaining (&br)) {
311 gint size = 0;
312 guint16 size2 = 0;
313 guint8 c, id;
314 const guint8 *data;
315 GstByteReader mbr;
316
317 CHECK (gst_byte_reader_get_uint8 (&br, &id));
318 CHECK (gst_byte_reader_get_uint8 (&br, &c));
319 if (id & ID_LARGE)
320 CHECK (gst_byte_reader_get_uint16_le (&br, &size2));
321 size = size2;
322 size <<= 8;
323 size += c;
324 size <<= 1;
325 if (id & ID_ODD_SIZE)
326 size--;
327
328 CHECK (gst_byte_reader_get_data (&br, size + (size & 1), &data));
329 gst_byte_reader_init (&mbr, data, size);
330
331 /* 0x1f is the metadata id mask and 0x20 flag is for later extensions
332 * that do not need to be handled by the decoder */
333 switch (id & 0x3f) {
334 case ID_WVC_BITSTREAM:
335 GST_LOG_OBJECT (parse, "correction bitstream");
336 wpi->correction = TRUE;
337 break;
338 case ID_WV_BITSTREAM:
339 case ID_WVX_BITSTREAM:
340 break;
341 case ID_SAMPLE_RATE:
342 if (size == 3) {
343 CHECK (gst_byte_reader_get_uint24_le (&mbr, &wpi->rate));
344 GST_LOG_OBJECT (parse, "updated with custom rate %d", wpi->rate);
345 } else {
346 GST_DEBUG_OBJECT (parse, "unexpected size for SAMPLE_RATE metadata");
347 }
348 break;
349 case ID_CHANNEL_INFO:
350 {
351 guint16 channels;
352 guint32 mask = 0;
353
354 if (size == 6) {
355 CHECK (gst_byte_reader_get_uint16_le (&mbr, &channels));
356 channels = channels & 0xFFF;
357 CHECK (gst_byte_reader_get_uint24_le (&mbr, &mask));
358 } else if (size) {
359 CHECK (gst_byte_reader_get_uint8 (&mbr, &c));
360 channels = c;
361 while (gst_byte_reader_get_uint8 (&mbr, &c))
362 mask |= (((guint32) c) << 8);
363 } else {
364 GST_DEBUG_OBJECT (parse, "unexpected size for CHANNEL_INFO metadata");
365 break;
366 }
367 wpi->channels = channels;
368 wpi->channel_mask = mask;
369 break;
370 }
371 default:
372 GST_LOG_OBJECT (parse, "unparsed ID 0x%x", id);
373 break;
374 }
375 }
376
377 gst_buffer_unmap (buf, &map);
378
379 return TRUE;
380
381 /* ERRORS */
382 read_failed:
383 {
384 gst_buffer_unmap (buf, &map);
385 GST_DEBUG_OBJECT (parse, "short read while parsing metadata");
386 /* let's look the other way anyway */
387 return TRUE;
388 }
389 }
390
391 /* caller ensures properly sync'ed with enough data */
392 static gboolean
gst_wavpack_parse_frame_header(GstWavpackParse * parse,GstBuffer * buf,gint skip,WavpackHeader * _wph)393 gst_wavpack_parse_frame_header (GstWavpackParse * parse, GstBuffer * buf,
394 gint skip, WavpackHeader * _wph)
395 {
396 GstByteReader br;
397 WavpackHeader wph = { {0,}, 0, };
398 GstMapInfo map;
399 gboolean hdl = TRUE;
400
401 g_return_val_if_fail (gst_buffer_get_size (buf) >=
402 skip + sizeof (WavpackHeader), FALSE);
403
404 gst_buffer_map (buf, &map, GST_MAP_READ);
405 gst_byte_reader_init (&br, map.data, map.size);
406
407 /* marker */
408 gst_byte_reader_skip_unchecked (&br, skip + 4);
409
410 /* read */
411 hdl &= gst_byte_reader_get_uint32_le (&br, &wph.ckSize);
412 hdl &= gst_byte_reader_get_uint16_le (&br, &wph.version);
413 hdl &= gst_byte_reader_get_uint8 (&br, &wph.track_no);
414 hdl &= gst_byte_reader_get_uint8 (&br, &wph.index_no);
415 hdl &= gst_byte_reader_get_uint32_le (&br, &wph.total_samples);
416 hdl &= gst_byte_reader_get_uint32_le (&br, &wph.block_index);
417 hdl &= gst_byte_reader_get_uint32_le (&br, &wph.block_samples);
418 hdl &= gst_byte_reader_get_uint32_le (&br, &wph.flags);
419 hdl &= gst_byte_reader_get_uint32_le (&br, &wph.crc);
420
421 if (!hdl)
422 GST_WARNING_OBJECT (parse, "Error reading header");
423
424 /* dump */
425 GST_LOG_OBJECT (parse, "size %d", wph.ckSize);
426 GST_LOG_OBJECT (parse, "version 0x%x", wph.version);
427 GST_LOG_OBJECT (parse, "total samples %d", wph.total_samples);
428 GST_LOG_OBJECT (parse, "block index %d", wph.block_index);
429 GST_LOG_OBJECT (parse, "block samples %d", wph.block_samples);
430 GST_LOG_OBJECT (parse, "flags 0x%x", wph.flags);
431 GST_LOG_OBJECT (parse, "crc 0x%x", wph.flags);
432
433 if (!parse->total_samples && wph.block_index == 0 && wph.total_samples != -1) {
434 GST_DEBUG_OBJECT (parse, "determined duration of %u samples",
435 wph.total_samples);
436 parse->total_samples = wph.total_samples;
437 }
438
439 if (_wph)
440 *_wph = wph;
441
442 gst_buffer_unmap (buf, &map);
443
444 return TRUE;
445 }
446
447 static GstFlowReturn
gst_wavpack_parse_handle_frame(GstBaseParse * parse,GstBaseParseFrame * frame,gint * skipsize)448 gst_wavpack_parse_handle_frame (GstBaseParse * parse,
449 GstBaseParseFrame * frame, gint * skipsize)
450 {
451 GstWavpackParse *wvparse = GST_WAVPACK_PARSE (parse);
452 GstBuffer *buf = frame->buffer;
453 GstByteReader reader;
454 gint off;
455 guint rate, chans, width, mask;
456 gboolean lost_sync, draining, final;
457 guint frmsize = 0;
458 WavpackHeader wph;
459 WavpackInfo wpi = { 0, };
460 GstMapInfo map;
461
462 if (G_UNLIKELY (gst_buffer_get_size (buf) < sizeof (WavpackHeader)))
463 return FALSE;
464
465 gst_buffer_map (buf, &map, GST_MAP_READ);
466 gst_byte_reader_init (&reader, map.data, map.size);
467
468 /* scan for 'wvpk' marker */
469 off = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff, 0x7776706b,
470 0, map.size);
471
472 GST_LOG_OBJECT (parse, "possible sync at buffer offset %d", off);
473
474 /* didn't find anything that looks like a sync word, skip */
475 if (off < 0) {
476 *skipsize = map.size - 3;
477 goto skip;
478 }
479
480 /* possible frame header, but not at offset 0? skip bytes before sync */
481 if (off > 0) {
482 *skipsize = off;
483 goto skip;
484 }
485
486 /* make sure the values in the frame header look sane */
487 gst_wavpack_parse_frame_header (wvparse, buf, 0, &wph);
488 frmsize = wph.ckSize + 8;
489
490 /* need the entire frame for parsing */
491 if (gst_byte_reader_get_remaining (&reader) < frmsize)
492 goto more;
493
494 /* got a frame, now we can dig for some more metadata */
495 GST_LOG_OBJECT (parse, "got frame");
496 gst_wavpack_parse_frame_metadata (wvparse, buf, 0, &wph, &wpi);
497
498 lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
499 draining = GST_BASE_PARSE_DRAINING (parse);
500
501 while (!(final = (wph.flags & FLAG_FINAL_BLOCK)) || (lost_sync && !draining)) {
502 guint32 word = 0;
503
504 GST_LOG_OBJECT (wvparse, "checking next frame syncword; "
505 "lost_sync: %d, draining: %d, final: %d", lost_sync, draining, final);
506
507 if (!gst_byte_reader_skip (&reader, wph.ckSize + 8) ||
508 !gst_byte_reader_peek_uint32_be (&reader, &word)) {
509 GST_DEBUG_OBJECT (wvparse, "... but not sufficient data");
510 frmsize += 4;
511 goto more;
512 } else {
513 if (word != 0x7776706b) {
514 GST_DEBUG_OBJECT (wvparse, "0x%x not OK", word);
515 *skipsize = off + 2;
516 goto skip;
517 }
518 /* need to parse each frame/block for metadata if several ones */
519 if (!final) {
520 gint av;
521
522 GST_LOG_OBJECT (wvparse, "checking frame at offset %d (0x%x)",
523 frmsize, frmsize);
524 av = gst_byte_reader_get_remaining (&reader);
525 if (av < sizeof (WavpackHeader)) {
526 frmsize += sizeof (WavpackHeader);
527 goto more;
528 }
529 gst_wavpack_parse_frame_header (wvparse, buf, frmsize, &wph);
530 off = frmsize;
531 frmsize += wph.ckSize + 8;
532 if (av < wph.ckSize + 8)
533 goto more;
534 gst_wavpack_parse_frame_metadata (wvparse, buf, off, &wph, &wpi);
535 /* could also check for matching block_index and block_samples ?? */
536 }
537 }
538
539 /* resynced if we make it here */
540 lost_sync = FALSE;
541 }
542
543 rate = wpi.rate;
544 width = wpi.width;
545 chans = wpi.channels;
546 mask = wpi.channel_mask;
547
548 GST_LOG_OBJECT (parse, "rate: %u, width: %u, chans: %u", rate, width, chans);
549
550 GST_BUFFER_PTS (buf) =
551 gst_util_uint64_scale_int (wph.block_index, GST_SECOND, rate);
552 GST_BUFFER_DTS (buf) = GST_BUFFER_PTS (buf);
553 GST_BUFFER_DURATION (buf) =
554 gst_util_uint64_scale_int (wph.block_index + wph.block_samples,
555 GST_SECOND, rate) - GST_BUFFER_PTS (buf);
556
557 if (G_UNLIKELY (wvparse->sample_rate != rate || wvparse->channels != chans
558 || wvparse->width != width || wvparse->channel_mask != mask)) {
559 GstCaps *caps;
560
561 if (wpi.correction) {
562 caps = gst_caps_new_simple ("audio/x-wavpack-correction",
563 "framed", G_TYPE_BOOLEAN, TRUE, NULL);
564 } else {
565 caps = gst_caps_new_simple ("audio/x-wavpack",
566 "channels", G_TYPE_INT, chans,
567 "rate", G_TYPE_INT, rate,
568 "depth", G_TYPE_INT, width, "framed", G_TYPE_BOOLEAN, TRUE, NULL);
569
570 if (!mask)
571 mask = gst_wavpack_get_default_channel_mask (wvparse->channels);
572 if (mask != 0) {
573 GstAudioChannelPosition pos[64] =
574 { GST_AUDIO_CHANNEL_POSITION_INVALID, };
575 guint64 gmask;
576
577 if (!gst_wavpack_get_channel_positions (chans, mask, pos)) {
578 GST_WARNING_OBJECT (wvparse, "Failed to determine channel layout");
579 } else {
580 gst_audio_channel_positions_to_mask (pos, chans, FALSE, &gmask);
581 if (gmask)
582 gst_caps_set_simple (caps,
583 "channel-mask", GST_TYPE_BITMASK, gmask, NULL);
584 }
585 }
586 }
587
588 gst_pad_set_caps (GST_BASE_PARSE_SRC_PAD (parse), caps);
589 gst_caps_unref (caps);
590
591 wvparse->sample_rate = rate;
592 wvparse->channels = chans;
593 wvparse->width = width;
594 wvparse->channel_mask = mask;
595
596 if (wvparse->total_samples) {
597 GST_DEBUG_OBJECT (wvparse, "setting duration");
598 gst_base_parse_set_duration (GST_BASE_PARSE (wvparse),
599 GST_FORMAT_TIME, gst_util_uint64_scale_int (wvparse->total_samples,
600 GST_SECOND, wvparse->sample_rate), 0);
601 }
602 }
603
604 /* return to normal size */
605 gst_base_parse_set_min_frame_size (parse, sizeof (WavpackHeader));
606 gst_buffer_unmap (buf, &map);
607
608 return gst_base_parse_finish_frame (parse, frame, frmsize);
609
610 skip:
611 gst_buffer_unmap (buf, &map);
612 GST_LOG_OBJECT (wvparse, "skipping %d", *skipsize);
613 return GST_FLOW_OK;
614
615 more:
616 gst_buffer_unmap (buf, &map);
617 GST_LOG_OBJECT (wvparse, "need at least %u", frmsize);
618 gst_base_parse_set_min_frame_size (parse, frmsize);
619 *skipsize = 0;
620 return GST_FLOW_OK;
621 }
622
623 static void
remove_fields(GstCaps * caps)624 remove_fields (GstCaps * caps)
625 {
626 guint i, n;
627
628 n = gst_caps_get_size (caps);
629 for (i = 0; i < n; i++) {
630 GstStructure *s = gst_caps_get_structure (caps, i);
631
632 gst_structure_remove_field (s, "framed");
633 }
634 }
635
636 static GstCaps *
gst_wavpack_parse_get_sink_caps(GstBaseParse * parse,GstCaps * filter)637 gst_wavpack_parse_get_sink_caps (GstBaseParse * parse, GstCaps * filter)
638 {
639 GstCaps *peercaps, *templ;
640 GstCaps *res;
641
642 templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
643 if (filter) {
644 GstCaps *fcopy = gst_caps_copy (filter);
645 /* Remove the fields we convert */
646 remove_fields (fcopy);
647 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), fcopy);
648 gst_caps_unref (fcopy);
649 } else
650 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), NULL);
651
652 if (peercaps) {
653 /* Remove the framed field */
654 peercaps = gst_caps_make_writable (peercaps);
655 remove_fields (peercaps);
656
657 res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
658 gst_caps_unref (peercaps);
659 gst_caps_unref (templ);
660 } else {
661 res = templ;
662 }
663
664 if (filter) {
665 GstCaps *intersection;
666
667 intersection =
668 gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
669 gst_caps_unref (res);
670 res = intersection;
671 }
672
673 return res;
674 }
675
676 static GstFlowReturn
gst_wavpack_parse_pre_push_frame(GstBaseParse * parse,GstBaseParseFrame * frame)677 gst_wavpack_parse_pre_push_frame (GstBaseParse * parse,
678 GstBaseParseFrame * frame)
679 {
680 GstWavpackParse *wavpackparse = GST_WAVPACK_PARSE (parse);
681
682 if (!wavpackparse->sent_codec_tag) {
683 GstTagList *taglist;
684 GstCaps *caps;
685
686 /* codec tag */
687 caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
688 if (G_UNLIKELY (caps == NULL)) {
689 if (GST_PAD_IS_FLUSHING (GST_BASE_PARSE_SRC_PAD (parse))) {
690 GST_INFO_OBJECT (parse, "Src pad is flushing");
691 return GST_FLOW_FLUSHING;
692 } else {
693 GST_INFO_OBJECT (parse, "Src pad is not negotiated!");
694 return GST_FLOW_NOT_NEGOTIATED;
695 }
696 }
697
698 taglist = gst_tag_list_new_empty ();
699 gst_pb_utils_add_codec_description_to_tag_list (taglist,
700 GST_TAG_AUDIO_CODEC, caps);
701 gst_caps_unref (caps);
702
703 gst_base_parse_merge_tags (parse, taglist, GST_TAG_MERGE_REPLACE);
704 gst_tag_list_unref (taglist);
705
706 /* also signals the end of first-frame processing */
707 wavpackparse->sent_codec_tag = TRUE;
708 }
709
710 frame->flags |= GST_BASE_PARSE_FRAME_FLAG_CLIP;
711
712 return GST_FLOW_OK;
713 }
714