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_NEWSEGMENT:
 490     {
 491       GstFormat format;
 492       gdouble rate, arate;
 493       gint64 start, stop, time;
 494       gboolean update;
 495
 496       gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,
 497           &start, &stop, &time);
 498
 499       /* we need time for now */
 500       if (format != GST_FORMAT_TIME)
 501         goto newseg_wrong_format;
 502
 503       GST_DEBUG_OBJECT (dec,
 504           "newsegment: update %d, rate %g, arate %g, start %" GST_TIME_FORMAT
 505           ", stop %" GST_TIME_FORMAT ", time %" GST_TIME_FORMAT,
 506           update, rate, arate, GST_TIME_ARGS (start), GST_TIME_ARGS (stop),
 507           GST_TIME_ARGS (time));
 508
 509       /* now configure the values */
 510       gst_segment_set_newsegment_full (&dec->segment, update,
 511           rate, arate, format, start, stop, time);
 512       dec->seqnum = gst_event_get_seqnum (event);
 513
 514       if (dec->initialized)
 515         /* and forward */
 516         ret = gst_pad_push_event (dec->srcpad, event);
 517       else {
 518         /* store it to send once we're initialized */
 519         dec->pendingevents = g_list_append (dec->pendingevents, event);
 520         ret = TRUE;
 521       }
 522       break;
 523     }
 524     case GST_EVENT_TAG:
 525     {
 526       if (dec->initialized)
 527         /* and forward */
 528         ret = gst_pad_push_event (dec->srcpad, event);
 529       else {
 530         /* store it to send once we're initialized */
 531         dec->pendingevents = g_list_append (dec->pendingevents, event);
 532         ret = TRUE;
 533       }
 534       break;
 535     }
 536     default:
 537       ret = gst_pad_event_default (pad, event);
 538       break;
 539   }
 540 done:
 541   gst_object_unref (dec);
 542
 543   return ret;
 544
 545   /* ERRORS */
 546 newseg_wrong_format:
 547   {
 548     GST_DEBUG_OBJECT (dec, "received non TIME newsegment");
 549     goto done;
 550   }
 551 }
 552
 553 static GstFlowReturn
 554 vorbis_handle_identification_packet (GstVorbisDec * vd)
 555 {
 556   GstCaps *caps;
 557   const GstAudioChannelPosition *pos = NULL;
 558   gint width = GST_VORBIS_DEC_DEFAULT_SAMPLE_WIDTH;
 559
 560   switch (vd->vi.channels) {
 561     case 1:
 562     case 2:
 563       /* nothing */
 564       break;
 565     case 3:
 566     case 4:
 567     case 5:
 568     case 6:
 569     case 7:
 570     case 8:
 571       pos = gst_vorbis_channel_positions[vd->vi.channels - 1];
 572       break;
 573     default:{
 574       gint i;
 575       GstAudioChannelPosition *posn =
 576           g_new (GstAudioChannelPosition, vd->vi.channels);
 577
 578       GST_ELEMENT_WARNING (GST_ELEMENT (vd), STREAM, DECODE,
 579           (NULL), ("Using NONE channel layout for more than 8 channels"));
 580
 581       for (i = 0; i < vd->vi.channels; i++)
 582         posn[i] = GST_AUDIO_CHANNEL_POSITION_NONE;
 583
 584       pos = posn;
 585     }
 586   }
 587
 588   /* negotiate width with downstream */
 589   caps = gst_pad_get_allowed_caps (vd->srcpad);
 590   if (caps) {
 591     if (!gst_caps_is_empty (caps)) {
 592       GstStructure *s;
 593
 594       s = gst_caps_get_structure (caps, 0);
 595       /* template ensures 16 or 32 */
 596       gst_structure_get_int (s, "width", &width);
 597
 598       GST_INFO_OBJECT (vd, "using %s with %d channels and %d bit audio depth",
 599           gst_structure_get_name (s), vd->vi.channels, width);
 600     }
 601     gst_caps_unref (caps);
 602   }
 603   vd->width = width >> 3;
 604
 605   /* select a copy_samples function, this way we can have specialized versions
 606    * for mono/stereo and avoid the depth switch in tremor case */
 607   vd->copy_samples = get_copy_sample_func (vd->vi.channels, vd->width);
 608
 609   caps = gst_caps_copy (gst_pad_get_pad_template_caps (vd->srcpad));
 610   gst_caps_set_simple (caps, "rate", G_TYPE_INT, vd->vi.rate,
 611       "channels", G_TYPE_INT, vd->vi.channels,
 612       "width", G_TYPE_INT, width, NULL);
 613
 614   if (pos) {
 615     gst_audio_set_channel_positions (gst_caps_get_structure (caps, 0), pos);
 616   }
 617
 618   if (vd->vi.channels > 8) {
 619     g_free ((GstAudioChannelPosition *) pos);
 620   }
 621
 622   gst_pad_set_caps (vd->srcpad, caps);
 623   gst_caps_unref (caps);
 624
 625   return GST_FLOW_OK;
 626 }
 627
 628 static GstFlowReturn
 629 vorbis_handle_comment_packet (GstVorbisDec * vd, ogg_packet * packet)
 630 {
 631   guint bitrate = 0;
 632   gchar *encoder = NULL;
 633   GstTagList *list, *old_list;
 634   guint8 *data;
 635   gsize size;
 636
 637   GST_DEBUG_OBJECT (vd, "parsing comment packet");
 638
 639   data = gst_ogg_packet_data (packet);
 640   size = gst_ogg_packet_size (packet);
 641
 642   list =
 643       gst_tag_list_from_vorbiscomment (data, size, (guint8 *) "\003vorbis", 7,
 644       &encoder);
 645
 646   old_list = vd->taglist;
 647   vd->taglist = gst_tag_list_merge (vd->taglist, list, GST_TAG_MERGE_REPLACE);
 648
 649   if (old_list)
 650     gst_tag_list_free (old_list);
 651   gst_tag_list_free (list);
 652
 653   if (!vd->taglist) {
 654     GST_ERROR_OBJECT (vd, "couldn't decode comments");
 655     vd->taglist = gst_tag_list_new ();
 656   }
 657   if (encoder) {
 658     if (encoder[0])
 659       gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 660           GST_TAG_ENCODER, encoder, NULL);
 661     g_free (encoder);
 662   }
 663   gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 664       GST_TAG_ENCODER_VERSION, vd->vi.version,
 665       GST_TAG_AUDIO_CODEC, "Vorbis", NULL);
 666   if (vd->vi.bitrate_nominal > 0 && vd->vi.bitrate_nominal <= 0x7FFFFFFF) {
 667     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 668         GST_TAG_NOMINAL_BITRATE, (guint) vd->vi.bitrate_nominal, NULL);
 669     bitrate = vd->vi.bitrate_nominal;
 670   }
 671   if (vd->vi.bitrate_upper > 0 && vd->vi.bitrate_upper <= 0x7FFFFFFF) {
 672     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 673         GST_TAG_MAXIMUM_BITRATE, (guint) vd->vi.bitrate_upper, NULL);
 674     if (!bitrate)
 675       bitrate = vd->vi.bitrate_upper;
 676   }
 677   if (vd->vi.bitrate_lower > 0 && vd->vi.bitrate_lower <= 0x7FFFFFFF) {
 678     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 679         GST_TAG_MINIMUM_BITRATE, (guint) vd->vi.bitrate_lower, NULL);
 680     if (!bitrate)
 681       bitrate = vd->vi.bitrate_lower;
 682   }
 683   if (bitrate) {
 684     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 685         GST_TAG_BITRATE, (guint) bitrate, NULL);
 686   }
 687
 688   if (vd->initialized) {
 689     gst_element_found_tags_for_pad (GST_ELEMENT_CAST (vd), vd->srcpad,
 690         vd->taglist);
 691     vd->taglist = NULL;
 692   } else {
 693     /* Only post them as messages for the time being. *
 694      * They will be pushed on the pad once the decoder is initialized */
 695     gst_element_post_message (GST_ELEMENT_CAST (vd),
 696         gst_message_new_tag (GST_OBJECT (vd), gst_tag_list_copy (vd->taglist)));
 697   }
 698
 699   return GST_FLOW_OK;
 700 }
 701
 702 static GstFlowReturn
 703 vorbis_handle_type_packet (GstVorbisDec * vd)
 704 {
 705   GList *walk;
 706   gint res;
 707
 708   g_assert (vd->initialized == FALSE);
 709
 710 #ifdef USE_TREMOLO
 711   if (G_UNLIKELY ((res = vorbis_dsp_init (&vd->vd, &vd->vi))))
 712     goto synthesis_init_error;
 713 #else
 714   if (G_UNLIKELY ((res = vorbis_synthesis_init (&vd->vd, &vd->vi))))
 715     goto synthesis_init_error;
 716
 717   if (G_UNLIKELY ((res = vorbis_block_init (&vd->vd, &vd->vb))))
 718     goto block_init_error;
 719 #endif
 720
 721   vd->initialized = TRUE;
 722
 723   if (vd->pendingevents) {
 724     for (walk = vd->pendingevents; walk; walk = g_list_next (walk))
 725       gst_pad_push_event (vd->srcpad, GST_EVENT_CAST (walk->data));
 726     g_list_free (vd->pendingevents);
 727     vd->pendingevents = NULL;
 728   }
 729
 730   if (vd->taglist) {
 731     /* The tags have already been sent on the bus as messages. */
 732     gst_pad_push_event (vd->srcpad, gst_event_new_tag (vd->taglist));
 733     vd->taglist = NULL;
 734   }
 735   return GST_FLOW_OK;
 736
 737   /* ERRORS */
 738 synthesis_init_error:
 739   {
 740     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
 741         (NULL), ("couldn't initialize synthesis (%d)", res));
 742     return GST_FLOW_ERROR;
 743   }
 744 block_init_error:
 745   {
 746     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
 747         (NULL), ("couldn't initialize block (%d)", res));
 748     return GST_FLOW_ERROR;
 749   }
 750 }
 751
 752 static GstFlowReturn
 753 vorbis_handle_header_packet (GstVorbisDec * vd, ogg_packet * packet)
 754 {
 755   GstFlowReturn res;
 756   gint ret;
 757
 758   GST_DEBUG_OBJECT (vd, "parsing header packet");
 759
 760   /* Packetno = 0 if the first byte is exactly 0x01 */
 761   packet->b_o_s = ((gst_ogg_packet_data (packet))[0] == 0x1) ? 1 : 0;
 762
 763 #ifdef USE_TREMOLO
 764   if ((ret = vorbis_dsp_headerin (&vd->vi, &vd->vc, packet)))
 765 #else
 766   if ((ret = vorbis_synthesis_headerin (&vd->vi, &vd->vc, packet)))
 767 #endif
 768     goto header_read_error;
 769
 770   switch ((gst_ogg_packet_data (packet))[0]) {
 771     case 0x01:
 772       res = vorbis_handle_identification_packet (vd);
 773       break;
 774     case 0x03:
 775       res = vorbis_handle_comment_packet (vd, packet);
 776       break;
 777     case 0x05:
 778       res = vorbis_handle_type_packet (vd);
 779       break;
 780     default:
 781       /* ignore */
 782       g_warning ("unknown vorbis header packet found");
 783       res = GST_FLOW_OK;
 784       break;
 785   }
 786   return res;
 787
 788   /* ERRORS */
 789 header_read_error:
 790   {
 791     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
 792         (NULL), ("couldn't read header packet (%d)", ret));
 793     return GST_FLOW_ERROR;
 794   }
 795 }
 796
 797 static GstFlowReturn
 798 vorbis_dec_push_forward (GstVorbisDec * dec, GstBuffer * buf)
 799 {
 800   GstFlowReturn result;
 801
 802   /* clip */
 803   if (!(buf = gst_audio_buffer_clip (buf, &dec->segment, dec->vi.rate,
 804               dec->vi.channels * dec->width))) {
 805     GST_LOG_OBJECT (dec, "clipped buffer");
 806     return GST_FLOW_OK;
 807   }
 808
 809   if (dec->discont) {
 810     GST_LOG_OBJECT (dec, "setting DISCONT");
 811     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
 812     dec->discont = FALSE;
 813   }
 814
 815   GST_DEBUG_OBJECT (dec,
 816       "pushing time %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT,
 817       GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
 818       GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
 819
 820   result = gst_pad_push (dec->srcpad, buf);
 821
 822   return result;
 823 }
 824
 825 static GstFlowReturn
 826 vorbis_dec_push_reverse (GstVorbisDec * dec, GstBuffer * buf)
 827 {
 828   GstFlowReturn result = GST_FLOW_OK;
 829
 830   dec->queued = g_list_prepend (dec->queued, buf);
 831
 832   return result;
 833 }
 834
 835 static void
 836 vorbis_do_timestamps (GstVorbisDec * vd, GstBuffer * buf, gboolean reverse,
 837     GstClockTime timestamp, GstClockTime duration)
 838 {
 839   /* interpolate reverse */
 840   if (vd->last_timestamp != -1 && duration != -1 && reverse)
 841     vd->last_timestamp -= duration;
 842
 843   /* take buffer timestamp, use interpolated timestamp otherwise */
 844   if (timestamp != -1)
 845     vd->last_timestamp = timestamp;
 846   else
 847     timestamp = vd->last_timestamp;
 848
 849   /* interpolate forwards */
 850   if (vd->last_timestamp != -1 && duration != -1 && !reverse)
 851     vd->last_timestamp += duration;
 852
 853   GST_LOG_OBJECT (vd,
 854       "keeping timestamp %" GST_TIME_FORMAT " ts %" GST_TIME_FORMAT " dur %"
 855       GST_TIME_FORMAT, GST_TIME_ARGS (vd->last_timestamp),
 856       GST_TIME_ARGS (timestamp), GST_TIME_ARGS (duration));
 857
 858   if (buf) {
 859     GST_BUFFER_TIMESTAMP (buf) = timestamp;
 860     GST_BUFFER_DURATION (buf) = duration;
 861   }
 862 }
 863
 864 static GstFlowReturn
 865 vorbis_handle_data_packet (GstVorbisDec * vd, ogg_packet * packet,
 866     GstClockTime timestamp, GstClockTime duration)
 867 {
 868 #ifdef USE_TREMOLO
 869   vorbis_sample_t *pcm;
 870 #else
 871   vorbis_sample_t **pcm;
 872 #endif
 873   guint sample_count;
 874   GstBuffer *out = NULL;
 875   GstFlowReturn result;
 876   guint8 *data;
 877   gsize size;
 878
 879   if (G_UNLIKELY (!vd->initialized))
 880     goto not_initialized;
 881
 882   /* normal data packet */
 883   /* FIXME, we can skip decoding if the packet is outside of the
 884    * segment, this is however not very trivial as we need a previous
 885    * packet to decode the current one so we must be carefull not to
 886    * throw away too much. For now we decode everything and clip right
 887    * before pushing data. */
 888
 889 #ifdef USE_TREMOLO
 890   if (G_UNLIKELY (vorbis_dsp_synthesis (&vd->vd, packet, 1)))
 891     goto could_not_read;
 892 #else
 893   if (G_UNLIKELY (vorbis_synthesis (&vd->vb, packet)))
 894     goto could_not_read;
 895
 896   if (G_UNLIKELY (vorbis_synthesis_blockin (&vd->vd, &vd->vb) < 0))
 897     goto not_accepted;
 898 #endif
 899
 900   /* assume all goes well here */
 901   result = GST_FLOW_OK;
 902
 903   /* count samples ready for reading */
 904 #ifdef USE_TREMOLO
 905   if ((sample_count = vorbis_dsp_pcmout (&vd->vd, NULL, 0)) == 0)
 906 #else
 907   if ((sample_count = vorbis_synthesis_pcmout (&vd->vd, NULL)) == 0)
 908 #endif
 909     goto done;
 910
 911   size = sample_count * vd->vi.channels * vd->width;
 912   GST_LOG_OBJECT (vd, "%d samples ready for reading, size %d", sample_count,
 913       size);
 914
 915   /* alloc buffer for it */
 916   out = gst_buffer_new_and_alloc (size);
 917
 918   /* get samples ready for reading now, should be sample_count */
 919 #ifdef USE_TREMOLO
 920   pcm = GST_BUFFER_DATA (out);
 921   if (G_UNLIKELY ((vorbis_dsp_pcmout (&vd->vd, pcm,
 922                   sample_count)) != sample_count))
 923 #else
 924   if (G_UNLIKELY ((vorbis_synthesis_pcmout (&vd->vd, &pcm)) != sample_count))
 925 #endif
 926     goto wrong_samples;
 927
 928 #ifndef USE_TREMOLO
 929   /* copy samples in buffer */
 930   data = gst_buffer_map (out, NULL, NULL, GST_MAP_WRITE);
 931   vd->copy_samples ((vorbis_sample_t *) data, pcm,
 932       sample_count, vd->vi.channels, vd->width);
 933 #endif
 934
 935   GST_LOG_OBJECT (vd, "setting output size to %d", size);
 936   gst_buffer_unmap (out, data, size);
 937
 938   /* this should not overflow */
 939   if (duration == -1)
 940     duration = sample_count * GST_SECOND / vd->vi.rate;
 941
 942   vorbis_do_timestamps (vd, out, FALSE, timestamp, duration);
 943
 944   if (vd->segment.rate >= 0.0)
 945     result = vorbis_dec_push_forward (vd, out);
 946   else
 947     result = vorbis_dec_push_reverse (vd, out);
 948
 949 done:
 950   if (out == NULL) {
 951     /* no output, still keep track of timestamps */
 952     vorbis_do_timestamps (vd, NULL, FALSE, timestamp, duration);
 953   }
 954 #ifdef USE_TREMOLO
 955   vorbis_dsp_read (&vd->vd, sample_count);
 956 #else
 957   vorbis_synthesis_read (&vd->vd, sample_count);
 958 #endif
 959
 960   return result;
 961
 962   /* ERRORS */
 963 not_initialized:
 964   {
 965     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
 966         (NULL), ("no header sent yet"));
 967     return GST_FLOW_ERROR;
 968   }
 969 could_not_read:
 970   {
 971     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
 972         (NULL), ("couldn't read data packet"));
 973     return GST_FLOW_ERROR;
 974   }
 975 not_accepted:
 976   {
 977     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
 978         (NULL), ("vorbis decoder did not accept data packet"));
 979     return GST_FLOW_ERROR;
 980   }
 981 wrong_samples:
 982   {
 983     gst_buffer_unref (out);
 984     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
 985         (NULL), ("vorbis decoder reported wrong number of samples"));
 986     return GST_FLOW_ERROR;
 987   }
 988 }
 989
 990 static GstFlowReturn
 991 vorbis_dec_decode_buffer (GstVorbisDec * vd, GstBuffer * buffer)
 992 {
 993   ogg_packet *packet;
 994   ogg_packet_wrapper packet_wrapper;
 995   GstFlowReturn result = GST_FLOW_OK;
 996
 997   /* make ogg_packet out of the buffer */
 998   gst_ogg_packet_wrapper_map (&packet_wrapper, buffer);
 999   packet = gst_ogg_packet_from_wrapper (&packet_wrapper);
1000   /* set some more stuff */
1001   packet->granulepos = -1;
1002   packet->packetno = 0;         /* we don't care */
1003   /* EOS does not matter, it is used in vorbis to implement clipping the last
1004    * block of samples based on the granulepos. We clip based on segments. */
1005   packet->e_o_s = 0;
1006
1007   GST_LOG_OBJECT (vd, "decode buffer of size %ld", packet->bytes);
1008
1009   /* error out on empty header packets, but just skip empty data packets */
1010   if (G_UNLIKELY (packet->bytes == 0)) {
1011     if (vd->initialized)
1012       goto empty_buffer;
1013     else
1014       goto empty_header;
1015   }
1016
1017   /* switch depending on packet type */
1018   if ((gst_ogg_packet_data (packet))[0] & 1) {
1019     if (vd->initialized) {
1020       GST_WARNING_OBJECT (vd, "Already initialized, so ignoring header packet");
1021       goto done;
1022     }
1023     result = vorbis_handle_header_packet (vd, packet);
1024   } else {
1025     GstClockTime timestamp, duration;
1026
1027     timestamp = GST_BUFFER_TIMESTAMP (buffer);
1028     duration = GST_BUFFER_DURATION (buffer);
1029
1030     result = vorbis_handle_data_packet (vd, packet, timestamp, duration);
1031   }
1032
1033 done:
1034   gst_ogg_packet_wrapper_unmap (&packet_wrapper, buffer);
1035
1036   return result;
1037
1038 empty_buffer:
1039   {
1040     /* don't error out here, just ignore the buffer, it's invalid for vorbis
1041      * but not fatal. */
1042     GST_WARNING_OBJECT (vd, "empty buffer received, ignoring");
1043     result = GST_FLOW_OK;
1044     goto done;
1045   }
1046
1047 /* ERRORS */
1048 empty_header:
1049   {
1050     GST_ELEMENT_ERROR (vd, STREAM, DECODE, (NULL), ("empty header received"));
1051     result = GST_FLOW_ERROR;
1052     vd->discont = TRUE;
1053     goto done;
1054   }
1055 }
1056
1057 /*
1058  * Input:
1059  *  Buffer decoding order:  7  8  9  4  5  6  3  1  2  EOS
1060  *  Discont flag:           D        D        D  D
1061  *
1062  * - Each Discont marks a discont in the decoding order.
1063  *
1064  * for vorbis, each buffer is a keyframe when we have the previous
1065  * buffer. This means that to decode buffer 7, we need buffer 6, which
1066  * arrives out of order.
1067  *
1068  * we first gather buffers in the gather queue until we get a DISCONT. We
1069  * prepend each incomming buffer so that they are in reversed order.
1070  *
1071  *    gather queue:    9  8  7
1072  *    decode queue:
1073  *    output queue:
1074  *
1075  * When a DISCONT is received (buffer 4), we move the gather queue to the
1076  * decode queue. This is simply done be taking the head of the gather queue
1077  * and prepending it to the decode queue. This yields:
1078  *
1079  *    gather queue:
1080  *    decode queue:    7  8  9
1081  *    output queue:
1082  *
1083  * Then we decode each buffer in the decode queue in order and put the output
1084  * buffer in the output queue. The first buffer (7) will not produce any output
1085  * because it needs the previous buffer (6) which did not arrive yet. This
1086  * yields:
1087  *
1088  *    gather queue:
1089  *    decode queue:    7  8  9
1090  *    output queue:    9  8
1091  *
1092  * Then we remove the consumed buffers from the decode queue. Buffer 7 is not
1093  * completely consumed, we need to keep it around for when we receive buffer
1094  * 6. This yields:
1095  *
1096  *    gather queue:
1097  *    decode queue:    7
1098  *    output queue:    9  8
1099  *
1100  * Then we accumulate more buffers:
1101  *
1102  *    gather queue:    6  5  4
1103  *    decode queue:    7
1104  *    output queue:
1105  *
1106  * prepending to the decode queue on DISCONT yields:
1107  *
1108  *    gather queue:
1109  *    decode queue:    4  5  6  7
1110  *    output queue:
1111  *
1112  * after decoding and keeping buffer 4:
1113  *
1114  *    gather queue:
1115  *    decode queue:    4
1116  *    output queue:    7  6  5
1117  *
1118  * Etc..
1119  */
1120 static GstFlowReturn
1121 vorbis_dec_flush_decode (GstVorbisDec * dec)
1122 {
1123   GstFlowReturn res = GST_FLOW_OK;
1124   GList *walk;
1125
1126   walk = dec->decode;
1127
1128   GST_DEBUG_OBJECT (dec, "flushing buffers to decoder");
1129
1130   while (walk) {
1131     GList *next;
1132     GstBuffer *buf = GST_BUFFER_CAST (walk->data);
1133
1134     GST_DEBUG_OBJECT (dec, "decoding buffer %p, ts %" GST_TIME_FORMAT,
1135         buf, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
1136
1137     next = g_list_next (walk);
1138
1139     /* decode buffer, prepend to output queue */
1140     res = vorbis_dec_decode_buffer (dec, buf);
1141
1142     /* if we generated output, we can discard the buffer, else we
1143      * keep it in the queue */
1144     if (dec->queued) {
1145       GST_DEBUG_OBJECT (dec, "decoded buffer to %p", dec->queued->data);
1146       dec->decode = g_list_delete_link (dec->decode, walk);
1147       gst_buffer_unref (buf);
1148     } else {
1149       GST_DEBUG_OBJECT (dec, "buffer did not decode, keeping");
1150     }
1151     walk = next;
1152   }
1153   while (dec->queued) {
1154     GstBuffer *buf = GST_BUFFER_CAST (dec->queued->data);
1155     GstClockTime timestamp, duration;
1156
1157     timestamp = GST_BUFFER_TIMESTAMP (buf);
1158     duration = GST_BUFFER_DURATION (buf);
1159
1160     vorbis_do_timestamps (dec, buf, TRUE, timestamp, duration);
1161     res = vorbis_dec_push_forward (dec, buf);
1162
1163     dec->queued = g_list_delete_link (dec->queued, dec->queued);
1164   }
1165   return res;
1166 }
1167
1168 static GstFlowReturn
1169 vorbis_dec_chain_reverse (GstVorbisDec * vd, gboolean discont, GstBuffer * buf)
1170 {
1171   GstFlowReturn result = GST_FLOW_OK;
1172
1173   /* if we have a discont, move buffers to the decode list */
1174   if (G_UNLIKELY (discont)) {
1175     GST_DEBUG_OBJECT (vd, "received discont");
1176     while (vd->gather) {
1177       GstBuffer *gbuf;
1178
1179       gbuf = GST_BUFFER_CAST (vd->gather->data);
1180       /* remove from the gather list */
1181       vd->gather = g_list_delete_link (vd->gather, vd->gather);
1182       /* copy to decode queue */
1183       vd->decode = g_list_prepend (vd->decode, gbuf);
1184     }
1185     /* flush and decode the decode queue */
1186     result = vorbis_dec_flush_decode (vd);
1187   }
1188
1189   if (G_LIKELY (buf)) {
1190     GST_DEBUG_OBJECT (vd,
1191         "gathering buffer %p of size %u, time %" GST_TIME_FORMAT
1192         ", dur %" GST_TIME_FORMAT, buf, gst_buffer_get_size (buf),
1193         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
1194         GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
1195
1196     /* add buffer to gather queue */
1197     vd->gather = g_list_prepend (vd->gather, buf);
1198   }
1199
1200   return result;
1201 }
1202
1203 static GstFlowReturn
1204 vorbis_dec_chain_forward (GstVorbisDec * vd, gboolean discont,
1205     GstBuffer * buffer)
1206 {
1207   GstFlowReturn result;
1208
1209   result = vorbis_dec_decode_buffer (vd, buffer);
1210
1211   gst_buffer_unref (buffer);
1212
1213   return result;
1214 }
1215
1216 static GstFlowReturn
1217 vorbis_dec_chain (GstPad * pad, GstBuffer * buffer)
1218 {
1219   GstVorbisDec *vd;
1220   GstFlowReturn result = GST_FLOW_OK;
1221   gboolean discont;
1222
1223   vd = GST_VORBIS_DEC (gst_pad_get_parent (pad));
1224
1225   discont = GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT);
1226
1227   /* resync on DISCONT */
1228   if (G_UNLIKELY (discont)) {
1229     GST_DEBUG_OBJECT (vd, "received DISCONT buffer");
1230     vd->last_timestamp = GST_CLOCK_TIME_NONE;
1231 #ifdef HAVE_VORBIS_SYNTHESIS_RESTART
1232     vorbis_synthesis_restart (&vd->vd);
1233 #endif
1234     vd->discont = TRUE;
1235   }
1236
1237   if (vd->segment.rate >= 0.0)
1238     result = vorbis_dec_chain_forward (vd, discont, buffer);
1239   else
1240     result = vorbis_dec_chain_reverse (vd, discont, buffer);
1241
1242   gst_object_unref (vd);
1243
1244   return result;
1245 }
1246
1247 static GstStateChangeReturn
1248 vorbis_dec_change_state (GstElement * element, GstStateChange transition)
1249 {
1250   GstVorbisDec *vd = GST_VORBIS_DEC (element);
1251   GstStateChangeReturn res;
1252
1253   switch (transition) {
1254     case GST_STATE_CHANGE_NULL_TO_READY:
1255       break;
1256     case GST_STATE_CHANGE_READY_TO_PAUSED:
1257       vorbis_info_init (&vd->vi);
1258       vorbis_comment_init (&vd->vc);
1259       vd->initialized = FALSE;
1260       gst_vorbis_dec_reset (vd);
1261       break;
1262     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1263       break;
1264     default:
1265       break;
1266   }
1267
1268   res = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1269
1270   switch (transition) {
1271     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1272       break;
1273     case GST_STATE_CHANGE_PAUSED_TO_READY:
1274       GST_DEBUG_OBJECT (vd, "PAUSED -> READY, clearing vorbis structures");
1275       vd->initialized = FALSE;
1276
1277 #ifndef USE_TREMOLO
1278       vorbis_block_clear (&vd->vb);
1279 #endif
1280
1281       vorbis_dsp_clear (&vd->vd);
1282       vorbis_comment_clear (&vd->vc);
1283       vorbis_info_clear (&vd->vi);
1284       gst_vorbis_dec_reset (vd);
1285       break;
1286     case GST_STATE_CHANGE_READY_TO_NULL:
1287       break;
1288     default:
1289       break;
1290   }
1291
1292   return res;
1293 }