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