Merge branch 'master' into 0.11
[platform/upstream/gstreamer.git] / ext / vorbis / gstvorbisdec.c
1 /* GStreamer
2  * Copyright (C) 2004 Benjamin Otte <in7y118@public.uni-hamburg.de>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19
20 /**
21  * SECTION:element-vorbisdec
22  * @see_also: vorbisenc, oggdemux
23  *
24  * This element decodes a Vorbis stream to raw float audio.
25  * <ulink url="http://www.vorbis.com/">Vorbis</ulink> is a royalty-free
26  * audio codec maintained by the <ulink url="http://www.xiph.org/">Xiph.org
27  * Foundation</ulink>.
28  *
29  * <refsect2>
30  * <title>Example pipelines</title>
31  * |[
32  * gst-launch -v filesrc location=sine.ogg ! oggdemux ! vorbisdec ! audioconvert ! alsasink
33  * ]| Decode an Ogg/Vorbis. To create an Ogg/Vorbis file refer to the documentation of vorbisenc.
34  * </refsect2>
35  *
36  * Last reviewed on 2006-03-01 (0.10.4)
37  */
38
39 #ifdef HAVE_CONFIG_H
40 #  include "config.h"
41 #endif
42
43 #include "gstvorbisdec.h"
44 #include <string.h>
45 #include <gst/audio/audio.h>
46 #include <gst/tag/tag.h>
47 #include <gst/audio/multichannel.h>
48
49 #include "gstvorbiscommon.h"
50
51 GST_DEBUG_CATEGORY_EXTERN (vorbisdec_debug);
52 #define GST_CAT_DEFAULT vorbisdec_debug
53
54 static GstStaticPadTemplate vorbis_dec_src_factory =
55 GST_STATIC_PAD_TEMPLATE ("src",
56     GST_PAD_SRC,
57     GST_PAD_ALWAYS,
58     GST_VORBIS_DEC_SRC_CAPS);
59
60 static GstStaticPadTemplate vorbis_dec_sink_factory =
61 GST_STATIC_PAD_TEMPLATE ("sink",
62     GST_PAD_SINK,
63     GST_PAD_ALWAYS,
64     GST_STATIC_CAPS ("audio/x-vorbis")
65     );
66
67 #define gst_vorbis_dec_parent_class parent_class
68 G_DEFINE_TYPE (GST_VORBIS_DEC_GLIB_TYPE_NAME, gst_vorbis_dec, GST_TYPE_ELEMENT);
69
70 static void vorbis_dec_finalize (GObject * object);
71 static gboolean vorbis_dec_sink_event (GstPad * pad, GstEvent * event);
72 static GstFlowReturn vorbis_dec_chain (GstPad * pad, GstBuffer * buffer);
73 static GstFlowReturn vorbis_dec_chain_forward (GstVorbisDec * vd,
74     gboolean discont, GstBuffer * buffer);
75 static GstFlowReturn vorbis_dec_chain_reverse (GstVorbisDec * vd,
76     gboolean discont, GstBuffer * buf);
77 static GstStateChangeReturn vorbis_dec_change_state (GstElement * element,
78     GstStateChange transition);
79
80 static gboolean vorbis_dec_src_event (GstPad * pad, GstEvent * event);
81 static gboolean vorbis_dec_src_query (GstPad * pad, GstQuery * query);
82 static gboolean vorbis_dec_convert (GstPad * pad,
83     GstFormat src_format, gint64 src_value,
84     GstFormat * dest_format, gint64 * dest_value);
85
86 static gboolean vorbis_dec_sink_query (GstPad * pad, GstQuery * query);
87
88 static void
89 gst_vorbis_dec_class_init (GstVorbisDecClass * klass)
90 {
91   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
92   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
93
94   gobject_class->finalize = vorbis_dec_finalize;
95
96   gst_element_class_add_pad_template (gstelement_class,
97       gst_static_pad_template_get (&vorbis_dec_src_factory));
98
99   gst_element_class_add_pad_template (gstelement_class,
100       gst_static_pad_template_get (&vorbis_dec_sink_factory));
101
102   gst_element_class_set_details_simple (gstelement_class,
103       "Vorbis audio decoder", "Codec/Decoder/Audio",
104       GST_VORBIS_DEC_DESCRIPTION,
105       "Benjamin Otte <otte@gnome.org>, Chris Lord <chris@openedhand.com>");
106
107   gstelement_class->change_state = GST_DEBUG_FUNCPTR (vorbis_dec_change_state);
108 }
109
110 static const GstQueryType *
111 vorbis_get_query_types (GstPad * pad)
112 {
113   static const GstQueryType vorbis_dec_src_query_types[] = {
114     GST_QUERY_POSITION,
115     GST_QUERY_DURATION,
116     GST_QUERY_CONVERT,
117     0
118   };
119
120   return vorbis_dec_src_query_types;
121 }
122
123 static void
124 gst_vorbis_dec_init (GstVorbisDec * dec)
125 {
126   dec->sinkpad = gst_pad_new_from_static_template (&vorbis_dec_sink_factory,
127       "sink");
128
129   gst_pad_set_event_function (dec->sinkpad,
130       GST_DEBUG_FUNCPTR (vorbis_dec_sink_event));
131   gst_pad_set_chain_function (dec->sinkpad,
132       GST_DEBUG_FUNCPTR (vorbis_dec_chain));
133   gst_pad_set_query_function (dec->sinkpad,
134       GST_DEBUG_FUNCPTR (vorbis_dec_sink_query));
135   gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad);
136
137   dec->srcpad = gst_pad_new_from_static_template (&vorbis_dec_src_factory,
138       "src");
139
140   gst_pad_set_event_function (dec->srcpad,
141       GST_DEBUG_FUNCPTR (vorbis_dec_src_event));
142   gst_pad_set_query_type_function (dec->srcpad,
143       GST_DEBUG_FUNCPTR (vorbis_get_query_types));
144   gst_pad_set_query_function (dec->srcpad,
145       GST_DEBUG_FUNCPTR (vorbis_dec_src_query));
146   gst_pad_use_fixed_caps (dec->srcpad);
147   gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad);
148
149   dec->queued = NULL;
150   dec->pendingevents = NULL;
151   dec->taglist = NULL;
152 }
153
154 static void
155 vorbis_dec_finalize (GObject * object)
156 {
157   /* Release any possibly allocated libvorbis data.
158    * _clear functions can safely be called multiple times
159    */
160   GstVorbisDec *vd = GST_VORBIS_DEC (object);
161
162 #ifndef USE_TREMOLO
163   vorbis_block_clear (&vd->vb);
164 #endif
165
166   vorbis_dsp_clear (&vd->vd);
167   vorbis_comment_clear (&vd->vc);
168   vorbis_info_clear (&vd->vi);
169
170   G_OBJECT_CLASS (parent_class)->finalize (object);
171 }
172
173 static void
174 gst_vorbis_dec_reset (GstVorbisDec * dec)
175 {
176   dec->last_timestamp = GST_CLOCK_TIME_NONE;
177   dec->discont = TRUE;
178   dec->seqnum = gst_util_seqnum_next ();
179   gst_segment_init (&dec->segment, GST_FORMAT_TIME);
180
181   g_list_foreach (dec->queued, (GFunc) gst_mini_object_unref, NULL);
182   g_list_free (dec->queued);
183   dec->queued = NULL;
184   g_list_foreach (dec->gather, (GFunc) gst_mini_object_unref, NULL);
185   g_list_free (dec->gather);
186   dec->gather = NULL;
187   g_list_foreach (dec->decode, (GFunc) gst_mini_object_unref, NULL);
188   g_list_free (dec->decode);
189   dec->decode = NULL;
190   g_list_foreach (dec->pendingevents, (GFunc) gst_mini_object_unref, NULL);
191   g_list_free (dec->pendingevents);
192   dec->pendingevents = NULL;
193
194   if (dec->taglist)
195     gst_tag_list_free (dec->taglist);
196   dec->taglist = NULL;
197 }
198
199
200 static gboolean
201 vorbis_dec_convert (GstPad * pad,
202     GstFormat src_format, gint64 src_value,
203     GstFormat * dest_format, gint64 * dest_value)
204 {
205   gboolean res = TRUE;
206   GstVorbisDec *dec;
207   guint64 scale = 1;
208
209   if (src_format == *dest_format) {
210     *dest_value = src_value;
211     return TRUE;
212   }
213
214   dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
215
216   if (!dec->initialized)
217     goto no_header;
218
219   if (dec->sinkpad == pad &&
220       (src_format == GST_FORMAT_BYTES || *dest_format == GST_FORMAT_BYTES))
221     goto no_format;
222
223   switch (src_format) {
224     case GST_FORMAT_TIME:
225       switch (*dest_format) {
226         case GST_FORMAT_BYTES:
227           scale = dec->width * dec->vi.channels;
228         case GST_FORMAT_DEFAULT:
229           *dest_value =
230               scale * gst_util_uint64_scale_int (src_value, dec->vi.rate,
231               GST_SECOND);
232           break;
233         default:
234           res = FALSE;
235       }
236       break;
237     case GST_FORMAT_DEFAULT:
238       switch (*dest_format) {
239         case GST_FORMAT_BYTES:
240           *dest_value = src_value * dec->width * dec->vi.channels;
241           break;
242         case GST_FORMAT_TIME:
243           *dest_value =
244               gst_util_uint64_scale_int (src_value, GST_SECOND, dec->vi.rate);
245           break;
246         default:
247           res = FALSE;
248       }
249       break;
250     case GST_FORMAT_BYTES:
251       switch (*dest_format) {
252         case GST_FORMAT_DEFAULT:
253           *dest_value = src_value / (dec->width * dec->vi.channels);
254           break;
255         case GST_FORMAT_TIME:
256           *dest_value = gst_util_uint64_scale_int (src_value, GST_SECOND,
257               dec->vi.rate * dec->width * dec->vi.channels);
258           break;
259         default:
260           res = FALSE;
261       }
262       break;
263     default:
264       res = FALSE;
265   }
266 done:
267   gst_object_unref (dec);
268
269   return res;
270
271   /* ERRORS */
272 no_header:
273   {
274     GST_DEBUG_OBJECT (dec, "no header packets received");
275     res = FALSE;
276     goto done;
277   }
278 no_format:
279   {
280     GST_DEBUG_OBJECT (dec, "formats unsupported");
281     res = FALSE;
282     goto done;
283   }
284 }
285
286 static gboolean
287 vorbis_dec_src_query (GstPad * pad, GstQuery * query)
288 {
289   GstVorbisDec *dec;
290   gboolean res = FALSE;
291
292   dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
293   if (G_UNLIKELY (dec == NULL))
294     return FALSE;
295
296   switch (GST_QUERY_TYPE (query)) {
297     case GST_QUERY_POSITION:
298     {
299       gint64 value;
300       GstFormat format;
301       gint64 time;
302
303       gst_query_parse_position (query, &format, NULL);
304
305       /* we start from the last seen time */
306       time = dec->last_timestamp;
307       /* correct for the segment values */
308       time = gst_segment_to_stream_time (&dec->segment, GST_FORMAT_TIME, time);
309
310       GST_LOG_OBJECT (dec,
311           "query %p: our time: %" GST_TIME_FORMAT, query, GST_TIME_ARGS (time));
312
313       /* and convert to the final format */
314       if (!(res =
315               vorbis_dec_convert (pad, GST_FORMAT_TIME, time, &format, &value)))
316         goto error;
317
318       gst_query_set_position (query, format, value);
319
320       GST_LOG_OBJECT (dec,
321           "query %p: we return %" G_GINT64_FORMAT " (format %u)", query, value,
322           format);
323
324       break;
325     }
326     case GST_QUERY_DURATION:
327     {
328       res = gst_pad_peer_query (dec->sinkpad, query);
329       if (!res)
330         goto error;
331
332       break;
333     }
334     case GST_QUERY_CONVERT:
335     {
336       GstFormat src_fmt, dest_fmt;
337       gint64 src_val, dest_val;
338
339       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
340       if (!(res =
341               vorbis_dec_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val)))
342         goto error;
343       gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
344       break;
345     }
346     default:
347       res = gst_pad_query_default (pad, query);
348       break;
349   }
350 done:
351   gst_object_unref (dec);
352
353   return res;
354
355   /* ERRORS */
356 error:
357   {
358     GST_WARNING_OBJECT (dec, "error handling query");
359     goto done;
360   }
361 }
362
363 static gboolean
364 vorbis_dec_sink_query (GstPad * pad, GstQuery * query)
365 {
366   GstVorbisDec *dec;
367   gboolean res;
368
369   dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
370
371   switch (GST_QUERY_TYPE (query)) {
372     case GST_QUERY_CONVERT:
373     {
374       GstFormat src_fmt, dest_fmt;
375       gint64 src_val, dest_val;
376
377       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
378       if (!(res =
379               vorbis_dec_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val)))
380         goto error;
381       gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
382       break;
383     }
384     default:
385       res = gst_pad_query_default (pad, query);
386       break;
387   }
388
389 done:
390   gst_object_unref (dec);
391
392   return res;
393
394   /* ERRORS */
395 error:
396   {
397     GST_DEBUG_OBJECT (dec, "error converting value");
398     goto done;
399   }
400 }
401
402 static gboolean
403 vorbis_dec_src_event (GstPad * pad, GstEvent * event)
404 {
405   gboolean res = TRUE;
406   GstVorbisDec *dec;
407
408   dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
409   if (G_UNLIKELY (dec == NULL)) {
410     gst_event_unref (event);
411     return FALSE;
412   }
413
414   switch (GST_EVENT_TYPE (event)) {
415     case GST_EVENT_SEEK:
416     {
417       GstFormat format, tformat;
418       gdouble rate;
419       GstEvent *real_seek;
420       GstSeekFlags flags;
421       GstSeekType cur_type, stop_type;
422       gint64 cur, stop;
423       gint64 tcur, tstop;
424       guint32 seqnum;
425
426       gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur,
427           &stop_type, &stop);
428       seqnum = gst_event_get_seqnum (event);
429       gst_event_unref (event);
430
431       /* First bring the requested format to time */
432       tformat = GST_FORMAT_TIME;
433       if (!(res = vorbis_dec_convert (pad, format, cur, &tformat, &tcur)))
434         goto convert_error;
435       if (!(res = vorbis_dec_convert (pad, format, stop, &tformat, &tstop)))
436         goto convert_error;
437
438       /* then seek with time on the peer */
439       real_seek = gst_event_new_seek (rate, GST_FORMAT_TIME,
440           flags, cur_type, tcur, stop_type, tstop);
441       gst_event_set_seqnum (real_seek, seqnum);
442
443       res = gst_pad_push_event (dec->sinkpad, real_seek);
444       break;
445     }
446     default:
447       res = gst_pad_push_event (dec->sinkpad, event);
448       break;
449   }
450 done:
451   gst_object_unref (dec);
452
453   return res;
454
455   /* ERRORS */
456 convert_error:
457   {
458     GST_DEBUG_OBJECT (dec, "cannot convert start/stop for seek");
459     goto done;
460   }
461 }
462
463 static gboolean
464 vorbis_dec_sink_event (GstPad * pad, GstEvent * event)
465 {
466   gboolean ret = FALSE;
467   GstVorbisDec *dec;
468
469   dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
470
471   GST_LOG_OBJECT (dec, "handling event");
472   switch (GST_EVENT_TYPE (event)) {
473     case GST_EVENT_EOS:
474       if (dec->segment.rate < 0.0)
475         vorbis_dec_chain_reverse (dec, TRUE, NULL);
476       ret = gst_pad_push_event (dec->srcpad, event);
477       break;
478     case GST_EVENT_FLUSH_START:
479       ret = gst_pad_push_event (dec->srcpad, event);
480       break;
481     case GST_EVENT_FLUSH_STOP:
482       /* here we must clean any state in the decoder */
483 #ifdef HAVE_VORBIS_SYNTHESIS_RESTART
484       vorbis_synthesis_restart (&dec->vd);
485 #endif
486       gst_vorbis_dec_reset (dec);
487       ret = gst_pad_push_event (dec->srcpad, event);
488       break;
489     case GST_EVENT_SEGMENT:
490     {
491       const GstSegment *segment;
492
493       gst_event_parse_segment (event, &segment);
494
495       /* we need time for now */
496       if (segment->format != GST_FORMAT_TIME)
497         goto newseg_wrong_format;
498
499       GST_DEBUG_OBJECT (dec, "segment: %" GST_SEGMENT_FORMAT, segment);
500
501       /* now configure the values */
502       gst_segment_copy_into (segment, &dec->segment);
503       dec->seqnum = gst_event_get_seqnum (event);
504
505       if (dec->initialized)
506         /* and forward */
507         ret = gst_pad_push_event (dec->srcpad, event);
508       else {
509         /* store it to send once we're initialized */
510         dec->pendingevents = g_list_append (dec->pendingevents, event);
511         ret = TRUE;
512       }
513       break;
514     }
515     case GST_EVENT_TAG:
516     {
517       if (dec->initialized)
518         /* and forward */
519         ret = gst_pad_push_event (dec->srcpad, event);
520       else {
521         /* store it to send once we're initialized */
522         dec->pendingevents = g_list_append (dec->pendingevents, event);
523         ret = TRUE;
524       }
525       break;
526     }
527     default:
528       ret = gst_pad_event_default (pad, event);
529       break;
530   }
531 done:
532   gst_object_unref (dec);
533
534   return ret;
535
536   /* ERRORS */
537 newseg_wrong_format:
538   {
539     GST_DEBUG_OBJECT (dec, "received non TIME newsegment");
540     goto done;
541   }
542 }
543
544 static GstFlowReturn
545 vorbis_handle_identification_packet (GstVorbisDec * vd)
546 {
547   GstCaps *caps;
548   const GstAudioChannelPosition *pos = NULL;
549   gint width = GST_VORBIS_DEC_DEFAULT_SAMPLE_WIDTH;
550
551   switch (vd->vi.channels) {
552     case 1:
553     case 2:
554       /* nothing */
555       break;
556     case 3:
557     case 4:
558     case 5:
559     case 6:
560     case 7:
561     case 8:
562       pos = gst_vorbis_channel_positions[vd->vi.channels - 1];
563       break;
564     default:{
565       gint i;
566       GstAudioChannelPosition *posn =
567           g_new (GstAudioChannelPosition, vd->vi.channels);
568
569       GST_ELEMENT_WARNING (GST_ELEMENT (vd), STREAM, DECODE,
570           (NULL), ("Using NONE channel layout for more than 8 channels"));
571
572       for (i = 0; i < vd->vi.channels; i++)
573         posn[i] = GST_AUDIO_CHANNEL_POSITION_NONE;
574
575       pos = posn;
576     }
577   }
578
579   /* negotiate width with downstream */
580   caps = gst_pad_get_allowed_caps (vd->srcpad);
581   if (caps) {
582     if (!gst_caps_is_empty (caps)) {
583       GstStructure *s;
584
585       s = gst_caps_get_structure (caps, 0);
586       /* template ensures 16 or 32 */
587       gst_structure_get_int (s, "width", &width);
588
589       GST_INFO_OBJECT (vd, "using %s with %d channels and %d bit audio depth",
590           gst_structure_get_name (s), vd->vi.channels, width);
591     }
592     gst_caps_unref (caps);
593   }
594   vd->width = width >> 3;
595
596   /* select a copy_samples function, this way we can have specialized versions
597    * for mono/stereo and avoid the depth switch in tremor case */
598   vd->copy_samples = get_copy_sample_func (vd->vi.channels, vd->width);
599
600   caps = gst_caps_make_writable (gst_pad_get_pad_template_caps (vd->srcpad));
601   gst_caps_set_simple (caps, "rate", G_TYPE_INT, vd->vi.rate,
602       "channels", G_TYPE_INT, vd->vi.channels,
603       "width", G_TYPE_INT, width, NULL);
604
605   if (pos) {
606     gst_audio_set_channel_positions (gst_caps_get_structure (caps, 0), pos);
607   }
608
609   if (vd->vi.channels > 8) {
610     g_free ((GstAudioChannelPosition *) pos);
611   }
612
613   gst_pad_set_caps (vd->srcpad, caps);
614   gst_caps_unref (caps);
615
616   return GST_FLOW_OK;
617 }
618
619 static GstFlowReturn
620 vorbis_handle_comment_packet (GstVorbisDec * vd, ogg_packet * packet)
621 {
622   guint bitrate = 0;
623   gchar *encoder = NULL;
624   GstTagList *list, *old_list;
625   guint8 *data;
626   gsize size;
627
628   GST_DEBUG_OBJECT (vd, "parsing comment packet");
629
630   data = gst_ogg_packet_data (packet);
631   size = gst_ogg_packet_size (packet);
632
633   list =
634       gst_tag_list_from_vorbiscomment (data, size, (guint8 *) "\003vorbis", 7,
635       &encoder);
636
637   old_list = vd->taglist;
638   vd->taglist = gst_tag_list_merge (vd->taglist, list, GST_TAG_MERGE_REPLACE);
639
640   if (old_list)
641     gst_tag_list_free (old_list);
642   gst_tag_list_free (list);
643
644   if (!vd->taglist) {
645     GST_ERROR_OBJECT (vd, "couldn't decode comments");
646     vd->taglist = gst_tag_list_new ();
647   }
648   if (encoder) {
649     if (encoder[0])
650       gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
651           GST_TAG_ENCODER, encoder, NULL);
652     g_free (encoder);
653   }
654   gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
655       GST_TAG_ENCODER_VERSION, vd->vi.version,
656       GST_TAG_AUDIO_CODEC, "Vorbis", NULL);
657   if (vd->vi.bitrate_nominal > 0 && vd->vi.bitrate_nominal <= 0x7FFFFFFF) {
658     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
659         GST_TAG_NOMINAL_BITRATE, (guint) vd->vi.bitrate_nominal, NULL);
660     bitrate = vd->vi.bitrate_nominal;
661   }
662   if (vd->vi.bitrate_upper > 0 && vd->vi.bitrate_upper <= 0x7FFFFFFF) {
663     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
664         GST_TAG_MAXIMUM_BITRATE, (guint) vd->vi.bitrate_upper, NULL);
665     if (!bitrate)
666       bitrate = vd->vi.bitrate_upper;
667   }
668   if (vd->vi.bitrate_lower > 0 && vd->vi.bitrate_lower <= 0x7FFFFFFF) {
669     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
670         GST_TAG_MINIMUM_BITRATE, (guint) vd->vi.bitrate_lower, NULL);
671     if (!bitrate)
672       bitrate = vd->vi.bitrate_lower;
673   }
674   if (bitrate) {
675     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
676         GST_TAG_BITRATE, (guint) bitrate, NULL);
677   }
678
679   if (vd->initialized) {
680     gst_element_found_tags_for_pad (GST_ELEMENT_CAST (vd), vd->srcpad,
681         vd->taglist);
682     vd->taglist = NULL;
683   } else {
684     /* Only post them as messages for the time being. *
685      * They will be pushed on the pad once the decoder is initialized */
686     gst_element_post_message (GST_ELEMENT_CAST (vd),
687         gst_message_new_tag (GST_OBJECT (vd), gst_tag_list_copy (vd->taglist)));
688   }
689
690   return GST_FLOW_OK;
691 }
692
693 static GstFlowReturn
694 vorbis_handle_type_packet (GstVorbisDec * vd)
695 {
696   GList *walk;
697   gint res;
698
699   g_assert (vd->initialized == FALSE);
700
701 #ifdef USE_TREMOLO
702   if (G_UNLIKELY ((res = vorbis_dsp_init (&vd->vd, &vd->vi))))
703     goto synthesis_init_error;
704 #else
705   if (G_UNLIKELY ((res = vorbis_synthesis_init (&vd->vd, &vd->vi))))
706     goto synthesis_init_error;
707
708   if (G_UNLIKELY ((res = vorbis_block_init (&vd->vd, &vd->vb))))
709     goto block_init_error;
710 #endif
711
712   vd->initialized = TRUE;
713
714   if (vd->pendingevents) {
715     for (walk = vd->pendingevents; walk; walk = g_list_next (walk))
716       gst_pad_push_event (vd->srcpad, GST_EVENT_CAST (walk->data));
717     g_list_free (vd->pendingevents);
718     vd->pendingevents = NULL;
719   }
720
721   if (vd->taglist) {
722     /* The tags have already been sent on the bus as messages. */
723     gst_pad_push_event (vd->srcpad, gst_event_new_tag (vd->taglist));
724     vd->taglist = NULL;
725   }
726   return GST_FLOW_OK;
727
728   /* ERRORS */
729 synthesis_init_error:
730   {
731     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
732         (NULL), ("couldn't initialize synthesis (%d)", res));
733     return GST_FLOW_ERROR;
734   }
735 block_init_error:
736   {
737     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
738         (NULL), ("couldn't initialize block (%d)", res));
739     return GST_FLOW_ERROR;
740   }
741 }
742
743 static GstFlowReturn
744 vorbis_handle_header_packet (GstVorbisDec * vd, ogg_packet * packet)
745 {
746   GstFlowReturn res;
747   gint ret;
748
749   GST_DEBUG_OBJECT (vd, "parsing header packet");
750
751   /* Packetno = 0 if the first byte is exactly 0x01 */
752   packet->b_o_s = ((gst_ogg_packet_data (packet))[0] == 0x1) ? 1 : 0;
753
754 #ifdef USE_TREMOLO
755   if ((ret = vorbis_dsp_headerin (&vd->vi, &vd->vc, packet)))
756 #else
757   if ((ret = vorbis_synthesis_headerin (&vd->vi, &vd->vc, packet)))
758 #endif
759     goto header_read_error;
760
761   switch ((gst_ogg_packet_data (packet))[0]) {
762     case 0x01:
763       res = vorbis_handle_identification_packet (vd);
764       break;
765     case 0x03:
766       res = vorbis_handle_comment_packet (vd, packet);
767       break;
768     case 0x05:
769       res = vorbis_handle_type_packet (vd);
770       break;
771     default:
772       /* ignore */
773       g_warning ("unknown vorbis header packet found");
774       res = GST_FLOW_OK;
775       break;
776   }
777   return res;
778
779   /* ERRORS */
780 header_read_error:
781   {
782     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
783         (NULL), ("couldn't read header packet (%d)", ret));
784     return GST_FLOW_ERROR;
785   }
786 }
787
788 static GstFlowReturn
789 vorbis_dec_push_forward (GstVorbisDec * dec, GstBuffer * buf)
790 {
791   GstFlowReturn result;
792
793   /* clip */
794   if (!(buf = gst_audio_buffer_clip (buf, &dec->segment, dec->vi.rate,
795               dec->vi.channels * dec->width))) {
796     GST_LOG_OBJECT (dec, "clipped buffer");
797     return GST_FLOW_OK;
798   }
799
800   if (dec->discont) {
801     GST_LOG_OBJECT (dec, "setting DISCONT");
802     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
803     dec->discont = FALSE;
804   }
805
806   GST_DEBUG_OBJECT (dec,
807       "pushing time %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT,
808       GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
809       GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
810
811   result = gst_pad_push (dec->srcpad, buf);
812
813   return result;
814 }
815
816 static GstFlowReturn
817 vorbis_dec_push_reverse (GstVorbisDec * dec, GstBuffer * buf)
818 {
819   GstFlowReturn result = GST_FLOW_OK;
820
821   dec->queued = g_list_prepend (dec->queued, buf);
822
823   return result;
824 }
825
826 static void
827 vorbis_do_timestamps (GstVorbisDec * vd, GstBuffer * buf, gboolean reverse,
828     GstClockTime timestamp, GstClockTime duration)
829 {
830   /* interpolate reverse */
831   if (vd->last_timestamp != -1 && duration != -1 && reverse)
832     vd->last_timestamp -= duration;
833
834   /* take buffer timestamp, use interpolated timestamp otherwise */
835   if (timestamp != -1)
836     vd->last_timestamp = timestamp;
837   else
838     timestamp = vd->last_timestamp;
839
840   /* interpolate forwards */
841   if (vd->last_timestamp != -1 && duration != -1 && !reverse)
842     vd->last_timestamp += duration;
843
844   GST_LOG_OBJECT (vd,
845       "keeping timestamp %" GST_TIME_FORMAT " ts %" GST_TIME_FORMAT " dur %"
846       GST_TIME_FORMAT, GST_TIME_ARGS (vd->last_timestamp),
847       GST_TIME_ARGS (timestamp), GST_TIME_ARGS (duration));
848
849   if (buf) {
850     GST_BUFFER_TIMESTAMP (buf) = timestamp;
851     GST_BUFFER_DURATION (buf) = duration;
852   }
853 }
854
855 static GstFlowReturn
856 vorbis_handle_data_packet (GstVorbisDec * vd, ogg_packet * packet,
857     GstClockTime timestamp, GstClockTime duration)
858 {
859 #ifdef USE_TREMOLO
860   vorbis_sample_t *pcm;
861 #else
862   vorbis_sample_t **pcm;
863 #endif
864   guint sample_count;
865   GstBuffer *out = NULL;
866   GstFlowReturn result;
867   guint8 *data;
868   gsize size;
869
870   if (G_UNLIKELY (!vd->initialized))
871     goto not_initialized;
872
873   /* normal data packet */
874   /* FIXME, we can skip decoding if the packet is outside of the
875    * segment, this is however not very trivial as we need a previous
876    * packet to decode the current one so we must be carefull not to
877    * throw away too much. For now we decode everything and clip right
878    * before pushing data. */
879
880 #ifdef USE_TREMOLO
881   if (G_UNLIKELY (vorbis_dsp_synthesis (&vd->vd, packet, 1)))
882     goto could_not_read;
883 #else
884   if (G_UNLIKELY (vorbis_synthesis (&vd->vb, packet)))
885     goto could_not_read;
886
887   if (G_UNLIKELY (vorbis_synthesis_blockin (&vd->vd, &vd->vb) < 0))
888     goto not_accepted;
889 #endif
890
891   /* assume all goes well here */
892   result = GST_FLOW_OK;
893
894   /* count samples ready for reading */
895 #ifdef USE_TREMOLO
896   if ((sample_count = vorbis_dsp_pcmout (&vd->vd, NULL, 0)) == 0)
897 #else
898   if ((sample_count = vorbis_synthesis_pcmout (&vd->vd, NULL)) == 0)
899 #endif
900     goto done;
901
902   size = sample_count * vd->vi.channels * vd->width;
903   GST_LOG_OBJECT (vd, "%d samples ready for reading, size %d", sample_count,
904       size);
905
906   /* alloc buffer for it */
907   out = gst_buffer_new_and_alloc (size);
908
909   /* get samples ready for reading now, should be sample_count */
910 #ifdef USE_TREMOLO
911   pcm = GST_BUFFER_DATA (out);
912   if (G_UNLIKELY ((vorbis_dsp_pcmout (&vd->vd, pcm,
913                   sample_count)) != sample_count))
914 #else
915   if (G_UNLIKELY ((vorbis_synthesis_pcmout (&vd->vd, &pcm)) != sample_count))
916 #endif
917     goto wrong_samples;
918
919 #ifndef USE_TREMOLO
920   /* copy samples in buffer */
921   data = gst_buffer_map (out, NULL, NULL, GST_MAP_WRITE);
922   vd->copy_samples ((vorbis_sample_t *) data, pcm,
923       sample_count, vd->vi.channels, vd->width);
924 #endif
925
926   GST_LOG_OBJECT (vd, "setting output size to %d", size);
927   gst_buffer_unmap (out, data, size);
928
929   /* this should not overflow */
930   if (duration == -1)
931     duration = sample_count * GST_SECOND / vd->vi.rate;
932
933   vorbis_do_timestamps (vd, out, FALSE, timestamp, duration);
934
935   if (vd->segment.rate >= 0.0)
936     result = vorbis_dec_push_forward (vd, out);
937   else
938     result = vorbis_dec_push_reverse (vd, out);
939
940 done:
941   if (out == NULL) {
942     /* no output, still keep track of timestamps */
943     vorbis_do_timestamps (vd, NULL, FALSE, timestamp, duration);
944   }
945 #ifdef USE_TREMOLO
946   vorbis_dsp_read (&vd->vd, sample_count);
947 #else
948   vorbis_synthesis_read (&vd->vd, sample_count);
949 #endif
950
951   return result;
952
953   /* ERRORS */
954 not_initialized:
955   {
956     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
957         (NULL), ("no header sent yet"));
958     return GST_FLOW_ERROR;
959   }
960 could_not_read:
961   {
962     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
963         (NULL), ("couldn't read data packet"));
964     return GST_FLOW_ERROR;
965   }
966 not_accepted:
967   {
968     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
969         (NULL), ("vorbis decoder did not accept data packet"));
970     return GST_FLOW_ERROR;
971   }
972 wrong_samples:
973   {
974     gst_buffer_unref (out);
975     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
976         (NULL), ("vorbis decoder reported wrong number of samples"));
977     return GST_FLOW_ERROR;
978   }
979 }
980
981 static GstFlowReturn
982 vorbis_dec_handle_header_buffer (GstVorbisDec * vd, GstBuffer * buffer)
983 {
984   ogg_packet *packet;
985   ogg_packet_wrapper packet_wrapper;
986   GstFlowReturn ret;
987
988   gst_ogg_packet_wrapper_map (&packet_wrapper, buffer);
989   packet = gst_ogg_packet_from_wrapper (&packet_wrapper);
990
991   ret = vorbis_handle_header_packet (vd, packet);
992
993   gst_ogg_packet_wrapper_unmap (&packet_wrapper, buffer);
994
995   return ret;
996 }
997
998
999 #define MIN_NUM_HEADERS 3
1000 static GstFlowReturn
1001 vorbis_dec_handle_header_caps (GstVorbisDec * vd, GstBuffer * buffer)
1002 {
1003   GstFlowReturn result = GST_FLOW_OK;
1004   GstCaps *caps;
1005   GstStructure *s;
1006   const GValue *array;
1007   const GValue *value = NULL;
1008   GstBuffer *buf = NULL;
1009
1010   if ((caps = gst_pad_get_current_caps (vd->sinkpad)) == NULL)
1011     goto no_caps;
1012
1013   if ((s = gst_caps_get_structure (caps, 0)) == NULL)
1014     goto no_caps;
1015
1016   array = gst_structure_get_value (s, "streamheader");
1017
1018   if (array == NULL || (gst_value_array_get_size (array) < MIN_NUM_HEADERS))
1019     goto array_error;
1020
1021   /* initial header */
1022   value = gst_value_array_get_value (array, 0);
1023   buf = gst_value_get_buffer (value);
1024   if (!buf)
1025     goto null_buffer;
1026   result = vorbis_dec_handle_header_buffer (vd, buf);
1027   if (result != GST_FLOW_OK)
1028     goto buffer_error;
1029
1030   /* comment header */
1031   value = gst_value_array_get_value (array, 1);
1032   buf = gst_value_get_buffer (value);
1033   if (!buf)
1034     goto null_buffer;
1035   result = vorbis_dec_handle_header_buffer (vd, buf);
1036   if (result != GST_FLOW_OK)
1037     goto buffer_error;
1038
1039   /* bitstream codebook header */
1040   value = gst_value_array_get_value (array, 2);
1041   buf = gst_value_get_buffer (value);
1042   if (!buf)
1043     goto null_buffer;
1044   result = vorbis_dec_handle_header_buffer (vd, buf);
1045   if (result != GST_FLOW_OK)
1046     goto buffer_error;
1047
1048   return result;
1049
1050 no_caps:
1051   {
1052     GST_WARNING_OBJECT (vd, "no caps negotiated");
1053     return GST_FLOW_NOT_NEGOTIATED;
1054   }
1055 array_error:
1056   {
1057     GST_WARNING_OBJECT (vd, "streamheader array not found");
1058     return GST_FLOW_NOT_NEGOTIATED;
1059   }
1060 null_buffer:
1061   {
1062     GST_WARNING_OBJECT (vd, "streamheader with null buffer received");
1063     return GST_FLOW_NOT_NEGOTIATED;
1064   }
1065 buffer_error:
1066   {
1067     GST_WARNING_OBJECT (vd, "error handling buffer");
1068     return GST_FLOW_NOT_NEGOTIATED;
1069   }
1070 }
1071
1072 static GstFlowReturn
1073 vorbis_dec_decode_buffer (GstVorbisDec * vd, GstBuffer * buffer)
1074 {
1075   ogg_packet *packet;
1076   ogg_packet_wrapper packet_wrapper;
1077   GstFlowReturn result = GST_FLOW_OK;
1078
1079   /* make ogg_packet out of the buffer */
1080   gst_ogg_packet_wrapper_map (&packet_wrapper, buffer);
1081   packet = gst_ogg_packet_from_wrapper (&packet_wrapper);
1082   /* set some more stuff */
1083   packet->granulepos = -1;
1084   packet->packetno = 0;         /* we don't care */
1085   /* EOS does not matter, it is used in vorbis to implement clipping the last
1086    * block of samples based on the granulepos. We clip based on segments. */
1087   packet->e_o_s = 0;
1088
1089   GST_LOG_OBJECT (vd, "decode buffer of size %ld", packet->bytes);
1090
1091   /* error out on empty header packets, but just skip empty data packets */
1092   if (G_UNLIKELY (packet->bytes == 0)) {
1093     if (vd->initialized)
1094       goto empty_buffer;
1095     else
1096       goto empty_header;
1097   }
1098
1099   /* switch depending on packet type */
1100   if ((gst_ogg_packet_data (packet))[0] & 1) {
1101     if (vd->initialized) {
1102       GST_WARNING_OBJECT (vd, "Already initialized, so ignoring header packet");
1103       goto done;
1104     }
1105     result = vorbis_handle_header_packet (vd, packet);
1106   } else {
1107     GstClockTime timestamp, duration;
1108
1109     /* try to find header in caps so we can initialize the decoder */
1110     if (!vd->initialized) {
1111       result = vorbis_dec_handle_header_caps (vd, buffer);
1112       if (result != GST_FLOW_OK)
1113         goto invalid_caps_header;
1114     }
1115
1116     timestamp = GST_BUFFER_TIMESTAMP (buffer);
1117     duration = GST_BUFFER_DURATION (buffer);
1118
1119     result = vorbis_handle_data_packet (vd, packet, timestamp, duration);
1120   }
1121
1122 done:
1123   gst_ogg_packet_wrapper_unmap (&packet_wrapper, buffer);
1124
1125   return result;
1126
1127 empty_buffer:
1128   {
1129     /* don't error out here, just ignore the buffer, it's invalid for vorbis
1130      * but not fatal. */
1131     GST_WARNING_OBJECT (vd, "empty buffer received, ignoring");
1132     result = GST_FLOW_OK;
1133     goto done;
1134   }
1135
1136 /* ERRORS */
1137 empty_header:
1138   {
1139     GST_ELEMENT_ERROR (vd, STREAM, DECODE, (NULL), ("empty header received"));
1140     result = GST_FLOW_ERROR;
1141     vd->discont = TRUE;
1142     goto done;
1143   }
1144
1145 invalid_caps_header:
1146   {
1147     GST_ELEMENT_ERROR (vd, STREAM, DECODE, (NULL),
1148         ("invalid streamheader in caps"));
1149     goto done;
1150   }
1151 }
1152
1153 /*
1154  * Input:
1155  *  Buffer decoding order:  7  8  9  4  5  6  3  1  2  EOS
1156  *  Discont flag:           D        D        D  D
1157  *
1158  * - Each Discont marks a discont in the decoding order.
1159  *
1160  * for vorbis, each buffer is a keyframe when we have the previous
1161  * buffer. This means that to decode buffer 7, we need buffer 6, which
1162  * arrives out of order.
1163  *
1164  * we first gather buffers in the gather queue until we get a DISCONT. We
1165  * prepend each incomming buffer so that they are in reversed order.
1166  *
1167  *    gather queue:    9  8  7
1168  *    decode queue:
1169  *    output queue:
1170  *
1171  * When a DISCONT is received (buffer 4), we move the gather queue to the
1172  * decode queue. This is simply done be taking the head of the gather queue
1173  * and prepending it to the decode queue. This yields:
1174  *
1175  *    gather queue:
1176  *    decode queue:    7  8  9
1177  *    output queue:
1178  *
1179  * Then we decode each buffer in the decode queue in order and put the output
1180  * buffer in the output queue. The first buffer (7) will not produce any output
1181  * because it needs the previous buffer (6) which did not arrive yet. This
1182  * yields:
1183  *
1184  *    gather queue:
1185  *    decode queue:    7  8  9
1186  *    output queue:    9  8
1187  *
1188  * Then we remove the consumed buffers from the decode queue. Buffer 7 is not
1189  * completely consumed, we need to keep it around for when we receive buffer
1190  * 6. This yields:
1191  *
1192  *    gather queue:
1193  *    decode queue:    7
1194  *    output queue:    9  8
1195  *
1196  * Then we accumulate more buffers:
1197  *
1198  *    gather queue:    6  5  4
1199  *    decode queue:    7
1200  *    output queue:
1201  *
1202  * prepending to the decode queue on DISCONT yields:
1203  *
1204  *    gather queue:
1205  *    decode queue:    4  5  6  7
1206  *    output queue:
1207  *
1208  * after decoding and keeping buffer 4:
1209  *
1210  *    gather queue:
1211  *    decode queue:    4
1212  *    output queue:    7  6  5
1213  *
1214  * Etc..
1215  */
1216 static GstFlowReturn
1217 vorbis_dec_flush_decode (GstVorbisDec * dec)
1218 {
1219   GstFlowReturn res = GST_FLOW_OK;
1220   GList *walk;
1221
1222   walk = dec->decode;
1223
1224   GST_DEBUG_OBJECT (dec, "flushing buffers to decoder");
1225
1226   while (walk) {
1227     GList *next;
1228     GstBuffer *buf = GST_BUFFER_CAST (walk->data);
1229
1230     GST_DEBUG_OBJECT (dec, "decoding buffer %p, ts %" GST_TIME_FORMAT,
1231         buf, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
1232
1233     next = g_list_next (walk);
1234
1235     /* decode buffer, prepend to output queue */
1236     res = vorbis_dec_decode_buffer (dec, buf);
1237
1238     /* if we generated output, we can discard the buffer, else we
1239      * keep it in the queue */
1240     if (dec->queued) {
1241       GST_DEBUG_OBJECT (dec, "decoded buffer to %p", dec->queued->data);
1242       dec->decode = g_list_delete_link (dec->decode, walk);
1243       gst_buffer_unref (buf);
1244     } else {
1245       GST_DEBUG_OBJECT (dec, "buffer did not decode, keeping");
1246     }
1247     walk = next;
1248   }
1249   while (dec->queued) {
1250     GstBuffer *buf = GST_BUFFER_CAST (dec->queued->data);
1251     GstClockTime timestamp, duration;
1252
1253     timestamp = GST_BUFFER_TIMESTAMP (buf);
1254     duration = GST_BUFFER_DURATION (buf);
1255
1256     vorbis_do_timestamps (dec, buf, TRUE, timestamp, duration);
1257     res = vorbis_dec_push_forward (dec, buf);
1258
1259     dec->queued = g_list_delete_link (dec->queued, dec->queued);
1260   }
1261   return res;
1262 }
1263
1264 static GstFlowReturn
1265 vorbis_dec_chain_reverse (GstVorbisDec * vd, gboolean discont, GstBuffer * buf)
1266 {
1267   GstFlowReturn result = GST_FLOW_OK;
1268
1269   /* if we have a discont, move buffers to the decode list */
1270   if (G_UNLIKELY (discont)) {
1271     GST_DEBUG_OBJECT (vd, "received discont");
1272     while (vd->gather) {
1273       GstBuffer *gbuf;
1274
1275       gbuf = GST_BUFFER_CAST (vd->gather->data);
1276       /* remove from the gather list */
1277       vd->gather = g_list_delete_link (vd->gather, vd->gather);
1278       /* copy to decode queue */
1279       vd->decode = g_list_prepend (vd->decode, gbuf);
1280     }
1281     /* flush and decode the decode queue */
1282     result = vorbis_dec_flush_decode (vd);
1283   }
1284
1285   if (G_LIKELY (buf)) {
1286     GST_DEBUG_OBJECT (vd,
1287         "gathering buffer %p of size %u, time %" GST_TIME_FORMAT
1288         ", dur %" GST_TIME_FORMAT, buf, gst_buffer_get_size (buf),
1289         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
1290         GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
1291
1292     /* add buffer to gather queue */
1293     vd->gather = g_list_prepend (vd->gather, buf);
1294   }
1295
1296   return result;
1297 }
1298
1299 static GstFlowReturn
1300 vorbis_dec_chain_forward (GstVorbisDec * vd, gboolean discont,
1301     GstBuffer * buffer)
1302 {
1303   GstFlowReturn result;
1304
1305   result = vorbis_dec_decode_buffer (vd, buffer);
1306
1307   gst_buffer_unref (buffer);
1308
1309   return result;
1310 }
1311
1312 static GstFlowReturn
1313 vorbis_dec_chain (GstPad * pad, GstBuffer * buffer)
1314 {
1315   GstVorbisDec *vd;
1316   GstFlowReturn result = GST_FLOW_OK;
1317   gboolean discont;
1318
1319   vd = GST_VORBIS_DEC (gst_pad_get_parent (pad));
1320
1321   discont = GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT);
1322
1323   /* resync on DISCONT */
1324   if (G_UNLIKELY (discont)) {
1325     GST_DEBUG_OBJECT (vd, "received DISCONT buffer");
1326     vd->last_timestamp = GST_CLOCK_TIME_NONE;
1327 #ifdef HAVE_VORBIS_SYNTHESIS_RESTART
1328     vorbis_synthesis_restart (&vd->vd);
1329 #endif
1330     vd->discont = TRUE;
1331   }
1332
1333   if (vd->segment.rate >= 0.0)
1334     result = vorbis_dec_chain_forward (vd, discont, buffer);
1335   else
1336     result = vorbis_dec_chain_reverse (vd, discont, buffer);
1337
1338   gst_object_unref (vd);
1339
1340   return result;
1341 }
1342
1343 static GstStateChangeReturn
1344 vorbis_dec_change_state (GstElement * element, GstStateChange transition)
1345 {
1346   GstVorbisDec *vd = GST_VORBIS_DEC (element);
1347   GstStateChangeReturn res;
1348
1349   switch (transition) {
1350     case GST_STATE_CHANGE_NULL_TO_READY:
1351       break;
1352     case GST_STATE_CHANGE_READY_TO_PAUSED:
1353       vorbis_info_init (&vd->vi);
1354       vorbis_comment_init (&vd->vc);
1355       vd->initialized = FALSE;
1356       gst_vorbis_dec_reset (vd);
1357       break;
1358     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1359       break;
1360     default:
1361       break;
1362   }
1363
1364   res = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1365
1366   switch (transition) {
1367     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1368       break;
1369     case GST_STATE_CHANGE_PAUSED_TO_READY:
1370       GST_DEBUG_OBJECT (vd, "PAUSED -> READY, clearing vorbis structures");
1371       vd->initialized = FALSE;
1372
1373 #ifndef USE_TREMOLO
1374       vorbis_block_clear (&vd->vb);
1375 #endif
1376
1377       vorbis_dsp_clear (&vd->vd);
1378       vorbis_comment_clear (&vd->vc);
1379       vorbis_info_clear (&vd->vi);
1380       gst_vorbis_dec_reset (vd);
1381       break;
1382     case GST_STATE_CHANGE_READY_TO_NULL:
1383       break;
1384     default:
1385       break;
1386   }
1387
1388   return res;
1389 }