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