ext/vorbis/vorbisdec.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 GST_DEBUG_CATEGORY_EXTERN (vorbisdec_debug);
  50 #define GST_CAT_DEFAULT vorbisdec_debug
  51
  52 static const GstElementDetails vorbis_dec_details =
  53 GST_ELEMENT_DETAILS ("Vorbis audio decoder",
  54     "Codec/Decoder/Audio",
  55     "decode raw vorbis streams to float audio",
  56     "Benjamin Otte <in7y118@public.uni-hamburg.de>");
  57
  58 static GstStaticPadTemplate vorbis_dec_src_factory =
  59 GST_STATIC_PAD_TEMPLATE ("src",
  60     GST_PAD_SRC,
  61     GST_PAD_ALWAYS,
  62     GST_STATIC_CAPS ("audio/x-raw-float, "
  63         "rate = (int) [ 1, MAX ], "
  64         "channels = (int) [ 1, 256 ], " "endianness = (int) BYTE_ORDER, "
  65 /* no ifdef in macros, please
  66 #ifdef GST_VORBIS_DEC_SEQUENTIAL
  67       "layout = \"sequential\", "
  68 #endif
  69 */
  70         "width = (int) 32")
  71     );
  72
  73 static GstStaticPadTemplate vorbis_dec_sink_factory =
  74 GST_STATIC_PAD_TEMPLATE ("sink",
  75     GST_PAD_SINK,
  76     GST_PAD_ALWAYS,
  77     GST_STATIC_CAPS ("audio/x-vorbis")
  78     );
  79
  80 GST_BOILERPLATE (GstVorbisDec, gst_vorbis_dec, GstElement, GST_TYPE_ELEMENT);
  81
  82 static void vorbis_dec_finalize (GObject * object);
  83 static gboolean vorbis_dec_sink_event (GstPad * pad, GstEvent * event);
  84 static GstFlowReturn vorbis_dec_chain (GstPad * pad, GstBuffer * buffer);
  85 static GstFlowReturn vorbis_dec_chain_forward (GstVorbisDec * vd,
  86     gboolean discont, GstBuffer * buffer);
  87 static GstStateChangeReturn vorbis_dec_change_state (GstElement * element,
  88     GstStateChange transition);
  89
  90 static gboolean vorbis_dec_src_event (GstPad * pad, GstEvent * event);
  91 static gboolean vorbis_dec_src_query (GstPad * pad, GstQuery * query);
  92 static gboolean vorbis_dec_convert (GstPad * pad,
  93     GstFormat src_format, gint64 src_value,
  94     GstFormat * dest_format, gint64 * dest_value);
  95
  96 static gboolean vorbis_dec_sink_query (GstPad * pad, GstQuery * query);
  97
  98 static void
  99 gst_vorbis_dec_base_init (gpointer g_class)
 100 {
 101   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 102   GstPadTemplate *src_template, *sink_template;
 103
 104   src_template = gst_static_pad_template_get (&vorbis_dec_src_factory);
 105   gst_element_class_add_pad_template (element_class, src_template);
 106
 107   sink_template = gst_static_pad_template_get (&vorbis_dec_sink_factory);
 108   gst_element_class_add_pad_template (element_class, sink_template);
 109
 110   gst_element_class_set_details (element_class, &vorbis_dec_details);
 111 }
 112
 113 static void
 114 gst_vorbis_dec_class_init (GstVorbisDecClass * klass)
 115 {
 116   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 117   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
 118
 119   gobject_class->finalize = vorbis_dec_finalize;
 120
 121   gstelement_class->change_state = GST_DEBUG_FUNCPTR (vorbis_dec_change_state);
 122 }
 123
 124 static const GstQueryType *
 125 vorbis_get_query_types (GstPad * pad)
 126 {
 127   static const GstQueryType vorbis_dec_src_query_types[] = {
 128     GST_QUERY_POSITION,
 129     GST_QUERY_DURATION,
 130     GST_QUERY_CONVERT,
 131     0
 132   };
 133
 134   return vorbis_dec_src_query_types;
 135 }
 136
 137 static void
 138 gst_vorbis_dec_init (GstVorbisDec * dec, GstVorbisDecClass * g_class)
 139 {
 140   dec->sinkpad = gst_pad_new_from_static_template (&vorbis_dec_sink_factory,
 141       "sink");
 142
 143   gst_pad_set_event_function (dec->sinkpad,
 144       GST_DEBUG_FUNCPTR (vorbis_dec_sink_event));
 145   gst_pad_set_chain_function (dec->sinkpad,
 146       GST_DEBUG_FUNCPTR (vorbis_dec_chain));
 147   gst_pad_set_query_function (dec->sinkpad,
 148       GST_DEBUG_FUNCPTR (vorbis_dec_sink_query));
 149   gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad);
 150
 151   dec->srcpad = gst_pad_new_from_static_template (&vorbis_dec_src_factory,
 152       "src");
 153
 154   gst_pad_set_event_function (dec->srcpad,
 155       GST_DEBUG_FUNCPTR (vorbis_dec_src_event));
 156   gst_pad_set_query_type_function (dec->srcpad,
 157       GST_DEBUG_FUNCPTR (vorbis_get_query_types));
 158   gst_pad_set_query_function (dec->srcpad,
 159       GST_DEBUG_FUNCPTR (vorbis_dec_src_query));
 160   gst_pad_use_fixed_caps (dec->srcpad);
 161   gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad);
 162
 163   dec->queued = NULL;
 164   dec->pendingevents = NULL;
 165   dec->taglist = NULL;
 166 }
 167
 168 static void
 169 vorbis_dec_finalize (GObject * object)
 170 {
 171   /* Release any possibly allocated libvorbis data.
 172    * _clear functions can safely be called multiple times
 173    */
 174   GstVorbisDec *vd = GST_VORBIS_DEC (object);
 175
 176   vorbis_block_clear (&vd->vb);
 177   vorbis_dsp_clear (&vd->vd);
 178   vorbis_comment_clear (&vd->vc);
 179   vorbis_info_clear (&vd->vi);
 180
 181   G_OBJECT_CLASS (parent_class)->finalize (object);
 182 }
 183
 184 static void
 185 gst_vorbis_dec_reset (GstVorbisDec * dec)
 186 {
 187   dec->cur_timestamp = GST_CLOCK_TIME_NONE;
 188   dec->prev_timestamp = GST_CLOCK_TIME_NONE;
 189   dec->granulepos = -1;
 190   dec->discont = TRUE;
 191   dec->seqnum = gst_util_seqnum_next ();
 192   gst_segment_init (&dec->segment, GST_FORMAT_TIME);
 193
 194   g_list_foreach (dec->queued, (GFunc) gst_mini_object_unref, NULL);
 195   g_list_free (dec->queued);
 196   dec->queued = NULL;
 197   g_list_foreach (dec->gather, (GFunc) gst_mini_object_unref, NULL);
 198   g_list_free (dec->gather);
 199   dec->gather = NULL;
 200   g_list_foreach (dec->decode, (GFunc) gst_mini_object_unref, NULL);
 201   g_list_free (dec->decode);
 202   dec->decode = NULL;
 203   g_list_foreach (dec->pendingevents, (GFunc) gst_mini_object_unref, NULL);
 204   g_list_free (dec->pendingevents);
 205   dec->pendingevents = NULL;
 206
 207   if (dec->taglist)
 208     gst_tag_list_free (dec->taglist);
 209   dec->taglist = NULL;
 210 }
 211
 212
 213 static gboolean
 214 vorbis_dec_convert (GstPad * pad,
 215     GstFormat src_format, gint64 src_value,
 216     GstFormat * dest_format, gint64 * dest_value)
 217 {
 218   gboolean res = TRUE;
 219   GstVorbisDec *dec;
 220   guint64 scale = 1;
 221
 222   if (src_format == *dest_format) {
 223     *dest_value = src_value;
 224     return TRUE;
 225   }
 226
 227   dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
 228
 229   if (!dec->initialized)
 230     goto no_header;
 231
 232   if (dec->sinkpad == pad &&
 233       (src_format == GST_FORMAT_BYTES || *dest_format == GST_FORMAT_BYTES))
 234     goto no_format;
 235
 236   switch (src_format) {
 237     case GST_FORMAT_TIME:
 238       switch (*dest_format) {
 239         case GST_FORMAT_BYTES:
 240           scale = sizeof (float) * dec->vi.channels;
 241         case GST_FORMAT_DEFAULT:
 242           *dest_value =
 243               scale * gst_util_uint64_scale_int (src_value, dec->vi.rate,
 244               GST_SECOND);
 245           break;
 246         default:
 247           res = FALSE;
 248       }
 249       break;
 250     case GST_FORMAT_DEFAULT:
 251       switch (*dest_format) {
 252         case GST_FORMAT_BYTES:
 253           *dest_value = src_value * sizeof (float) * dec->vi.channels;
 254           break;
 255         case GST_FORMAT_TIME:
 256           *dest_value =
 257               gst_util_uint64_scale_int (src_value, GST_SECOND, dec->vi.rate);
 258           break;
 259         default:
 260           res = FALSE;
 261       }
 262       break;
 263     case GST_FORMAT_BYTES:
 264       switch (*dest_format) {
 265         case GST_FORMAT_DEFAULT:
 266           *dest_value = src_value / (sizeof (float) * dec->vi.channels);
 267           break;
 268         case GST_FORMAT_TIME:
 269           *dest_value = gst_util_uint64_scale_int (src_value, GST_SECOND,
 270               dec->vi.rate * sizeof (float) * dec->vi.channels);
 271           break;
 272         default:
 273           res = FALSE;
 274       }
 275       break;
 276     default:
 277       res = FALSE;
 278   }
 279 done:
 280   gst_object_unref (dec);
 281
 282   return res;
 283
 284   /* ERRORS */
 285 no_header:
 286   {
 287     GST_DEBUG_OBJECT (dec, "no header packets received");
 288     res = FALSE;
 289     goto done;
 290   }
 291 no_format:
 292   {
 293     GST_DEBUG_OBJECT (dec, "formats unsupported");
 294     res = FALSE;
 295     goto done;
 296   }
 297 }
 298
 299 static gboolean
 300 vorbis_dec_src_query (GstPad * pad, GstQuery * query)
 301 {
 302   GstVorbisDec *dec;
 303   gboolean res = FALSE;
 304
 305   dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
 306
 307   switch (GST_QUERY_TYPE (query)) {
 308     case GST_QUERY_POSITION:
 309     {
 310       gint64 granulepos, value;
 311       GstFormat my_format, format;
 312       gint64 time;
 313
 314       /* we start from the last seen granulepos */
 315       granulepos = dec->granulepos;
 316
 317       gst_query_parse_position (query, &format, NULL);
 318
 319       /* and convert to the final format in two steps with time as the
 320        * intermediate step */
 321       my_format = GST_FORMAT_TIME;
 322       if (!(res =
 323               vorbis_dec_convert (pad, GST_FORMAT_DEFAULT, granulepos,
 324                   &my_format, &time)))
 325         goto error;
 326
 327       /* correct for the segment values */
 328       time = gst_segment_to_stream_time (&dec->segment, GST_FORMAT_TIME, time);
 329
 330       GST_LOG_OBJECT (dec,
 331           "query %p: our time: %" GST_TIME_FORMAT, query, GST_TIME_ARGS (time));
 332
 333       /* and convert to the final format */
 334       if (!(res = vorbis_dec_convert (pad, my_format, time, &format, &value)))
 335         goto error;
 336
 337       gst_query_set_position (query, format, value);
 338
 339       GST_LOG_OBJECT (dec,
 340           "query %p: we return %lld (format %u)", query, value, format);
 341
 342       break;
 343     }
 344     case GST_QUERY_DURATION:
 345     {
 346       GstPad *peer;
 347
 348       if (!(peer = gst_pad_get_peer (dec->sinkpad))) {
 349         GST_WARNING_OBJECT (dec, "sink pad %" GST_PTR_FORMAT " is not linked",
 350             dec->sinkpad);
 351         goto error;
 352       }
 353
 354       res = gst_pad_query (peer, query);
 355       gst_object_unref (peer);
 356       if (!res)
 357         goto error;
 358
 359       break;
 360     }
 361     case GST_QUERY_CONVERT:
 362     {
 363       GstFormat src_fmt, dest_fmt;
 364       gint64 src_val, dest_val;
 365
 366       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
 367       if (!(res =
 368               vorbis_dec_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val)))
 369         goto error;
 370       gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
 371       break;
 372     }
 373     default:
 374       res = gst_pad_query_default (pad, query);
 375       break;
 376   }
 377 done:
 378   gst_object_unref (dec);
 379
 380   return res;
 381
 382   /* ERRORS */
 383 error:
 384   {
 385     GST_WARNING_OBJECT (dec, "error handling query");
 386     goto done;
 387   }
 388 }
 389
 390 static gboolean
 391 vorbis_dec_sink_query (GstPad * pad, GstQuery * query)
 392 {
 393   GstVorbisDec *dec;
 394   gboolean res;
 395
 396   dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
 397
 398   switch (GST_QUERY_TYPE (query)) {
 399     case GST_QUERY_CONVERT:
 400     {
 401       GstFormat src_fmt, dest_fmt;
 402       gint64 src_val, dest_val;
 403
 404       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
 405       if (!(res =
 406               vorbis_dec_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val)))
 407         goto error;
 408       gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
 409       break;
 410     }
 411     default:
 412       res = gst_pad_query_default (pad, query);
 413       break;
 414   }
 415
 416 done:
 417   gst_object_unref (dec);
 418
 419   return res;
 420
 421   /* ERRORS */
 422 error:
 423   {
 424     GST_DEBUG_OBJECT (dec, "error converting value");
 425     goto done;
 426   }
 427 }
 428
 429 static gboolean
 430 vorbis_dec_src_event (GstPad * pad, GstEvent * event)
 431 {
 432   gboolean res = TRUE;
 433   GstVorbisDec *dec;
 434
 435   dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
 436
 437   switch (GST_EVENT_TYPE (event)) {
 438     case GST_EVENT_SEEK:
 439     {
 440       GstFormat format, tformat;
 441       gdouble rate;
 442       GstEvent *real_seek;
 443       GstSeekFlags flags;
 444       GstSeekType cur_type, stop_type;
 445       gint64 cur, stop;
 446       gint64 tcur, tstop;
 447       guint32 seqnum;
 448
 449       gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur,
 450           &stop_type, &stop);
 451       seqnum = gst_event_get_seqnum (event);
 452       gst_event_unref (event);
 453
 454       /* we have to ask our peer to seek to time here as we know
 455        * nothing about how to generate a granulepos from the src
 456        * formats or anything.
 457        *
 458        * First bring the requested format to time
 459        */
 460       tformat = GST_FORMAT_TIME;
 461       if (!(res = vorbis_dec_convert (pad, format, cur, &tformat, &tcur)))
 462         goto convert_error;
 463       if (!(res = vorbis_dec_convert (pad, format, stop, &tformat, &tstop)))
 464         goto convert_error;
 465
 466       /* then seek with time on the peer */
 467       real_seek = gst_event_new_seek (rate, GST_FORMAT_TIME,
 468           flags, cur_type, tcur, stop_type, tstop);
 469       gst_event_set_seqnum (real_seek, seqnum);
 470
 471       res = gst_pad_push_event (dec->sinkpad, real_seek);
 472       break;
 473     }
 474     default:
 475       res = gst_pad_push_event (dec->sinkpad, event);
 476       break;
 477   }
 478 done:
 479   gst_object_unref (dec);
 480
 481   return res;
 482
 483   /* ERRORS */
 484 convert_error:
 485   {
 486     GST_DEBUG_OBJECT (dec, "cannot convert start/stop for seek");
 487     goto done;
 488   }
 489 }
 490
 491 static gboolean
 492 vorbis_dec_sink_event (GstPad * pad, GstEvent * event)
 493 {
 494   gboolean ret = FALSE;
 495   GstVorbisDec *dec;
 496
 497   dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
 498
 499   GST_LOG_OBJECT (dec, "handling event");
 500   switch (GST_EVENT_TYPE (event)) {
 501     case GST_EVENT_EOS:
 502       ret = gst_pad_push_event (dec->srcpad, event);
 503       break;
 504     case GST_EVENT_FLUSH_START:
 505       ret = gst_pad_push_event (dec->srcpad, event);
 506       break;
 507     case GST_EVENT_FLUSH_STOP:
 508       /* here we must clean any state in the decoder */
 509 #ifdef HAVE_VORBIS_SYNTHESIS_RESTART
 510       vorbis_synthesis_restart (&dec->vd);
 511 #endif
 512       gst_vorbis_dec_reset (dec);
 513       ret = gst_pad_push_event (dec->srcpad, event);
 514       break;
 515     case GST_EVENT_NEWSEGMENT:
 516     {
 517       GstFormat format;
 518       gdouble rate, arate;
 519       gint64 start, stop, time;
 520       gboolean update;
 521
 522       gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,
 523           &start, &stop, &time);
 524
 525       /* we need time for now */
 526       if (format != GST_FORMAT_TIME)
 527         goto newseg_wrong_format;
 528
 529       GST_DEBUG_OBJECT (dec,
 530           "newsegment: update %d, rate %g, arate %g, start %" GST_TIME_FORMAT
 531           ", stop %" GST_TIME_FORMAT ", time %" GST_TIME_FORMAT,
 532           update, rate, arate, GST_TIME_ARGS (start), GST_TIME_ARGS (stop),
 533           GST_TIME_ARGS (time));
 534
 535       /* now configure the values */
 536       gst_segment_set_newsegment_full (&dec->segment, update,
 537           rate, arate, format, start, stop, time);
 538       dec->seqnum = gst_event_get_seqnum (event);
 539
 540       if (dec->initialized)
 541         /* and forward */
 542         ret = gst_pad_push_event (dec->srcpad, event);
 543       else {
 544         /* store it to send once we're initialized */
 545         dec->pendingevents = g_list_append (dec->pendingevents, event);
 546         ret = TRUE;
 547       }
 548       break;
 549     }
 550     default:
 551       ret = gst_pad_push_event (dec->srcpad, event);
 552       break;
 553   }
 554 done:
 555   gst_object_unref (dec);
 556
 557   return ret;
 558
 559   /* ERRORS */
 560 newseg_wrong_format:
 561   {
 562     GST_DEBUG_OBJECT (dec, "received non TIME newsegment");
 563     goto done;
 564   }
 565 }
 566
 567 static GstFlowReturn
 568 vorbis_handle_identification_packet (GstVorbisDec * vd)
 569 {
 570   GstCaps *caps;
 571   const GstAudioChannelPosition *pos = NULL;
 572
 573   switch (vd->vi.channels) {
 574     case 1:
 575     case 2:
 576       /* nothing */
 577       break;
 578     case 3:{
 579       static const GstAudioChannelPosition pos3[] = {
 580         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
 581         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
 582         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT
 583       };
 584       pos = pos3;
 585       break;
 586     }
 587     case 4:{
 588       static const GstAudioChannelPosition pos4[] = {
 589         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
 590         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
 591         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
 592         GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT
 593       };
 594       pos = pos4;
 595       break;
 596     }
 597     case 5:{
 598       static const GstAudioChannelPosition pos5[] = {
 599         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
 600         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
 601         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
 602         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
 603         GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT
 604       };
 605       pos = pos5;
 606       break;
 607     }
 608     case 6:{
 609       static const GstAudioChannelPosition pos6[] = {
 610         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
 611         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
 612         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
 613         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
 614         GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
 615         GST_AUDIO_CHANNEL_POSITION_LFE
 616       };
 617       pos = pos6;
 618       break;
 619     }
 620       /* FIXME: for >6 channels the layout is not defined by the Vorbis
 621        * spec. These are the gstreamer "defaults" for 7/8 channels and
 622        * NONE layouts for more channels
 623        */
 624     case 7:{
 625       static const GstAudioChannelPosition pos7[] = {
 626         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
 627         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
 628         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
 629         GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
 630         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
 631         GST_AUDIO_CHANNEL_POSITION_LFE,
 632         GST_AUDIO_CHANNEL_POSITION_REAR_CENTER,
 633       };
 634       pos = pos7;
 635       /* fallthrough */
 636     }
 637     case 8:{
 638       static const GstAudioChannelPosition pos8[] = {
 639         GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
 640         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
 641         GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
 642         GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
 643         GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
 644         GST_AUDIO_CHANNEL_POSITION_LFE,
 645         GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT,
 646         GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT,
 647       };
 648
 649       pos = pos8;
 650       /* fallthrough */
 651     }
 652     default:{
 653       gint i;
 654       GstAudioChannelPosition *posn =
 655           g_new (GstAudioChannelPosition, vd->vi.channels);
 656
 657       GST_ELEMENT_WARNING (GST_ELEMENT (vd), STREAM, DECODE,
 658           (NULL), ("Using NONE channel layout for more than 8 channels"));
 659
 660       for (i = 0; i < vd->vi.channels; i++)
 661         posn[i] = GST_AUDIO_CHANNEL_POSITION_NONE;
 662
 663       pos = posn;
 664     }
 665   }
 666
 667   caps = gst_caps_new_simple ("audio/x-raw-float",
 668       "rate", G_TYPE_INT, vd->vi.rate,
 669       "channels", G_TYPE_INT, vd->vi.channels,
 670       "endianness", G_TYPE_INT, G_BYTE_ORDER, "width", G_TYPE_INT, 32, NULL);
 671
 672   if (pos) {
 673     gst_audio_set_channel_positions (gst_caps_get_structure (caps, 0), pos);
 674   }
 675
 676   if (vd->vi.channels > 8) {
 677     g_free ((GstAudioChannelPosition *) pos);
 678   }
 679
 680   gst_pad_set_caps (vd->srcpad, caps);
 681   gst_caps_unref (caps);
 682
 683   return GST_FLOW_OK;
 684 }
 685
 686 static GstFlowReturn
 687 vorbis_handle_comment_packet (GstVorbisDec * vd, ogg_packet * packet)
 688 {
 689   guint bitrate = 0;
 690   gchar *encoder = NULL;
 691   GstTagList *list, *old_list;
 692   GstBuffer *buf;
 693
 694   GST_DEBUG_OBJECT (vd, "parsing comment packet");
 695
 696   buf = gst_buffer_new ();
 697   GST_BUFFER_DATA (buf) = packet->packet;
 698   GST_BUFFER_SIZE (buf) = packet->bytes;
 699
 700   list =
 701       gst_tag_list_from_vorbiscomment_buffer (buf, (guint8 *) "\003vorbis", 7,
 702       &encoder);
 703
 704   old_list = vd->taglist;
 705   vd->taglist = gst_tag_list_merge (vd->taglist, list, GST_TAG_MERGE_REPLACE);
 706
 707   if (old_list)
 708     gst_tag_list_free (old_list);
 709   gst_tag_list_free (list);
 710   gst_buffer_unref (buf);
 711
 712   if (!vd->taglist) {
 713     GST_ERROR_OBJECT (vd, "couldn't decode comments");
 714     vd->taglist = gst_tag_list_new ();
 715   }
 716   if (encoder) {
 717     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 718         GST_TAG_ENCODER, encoder, NULL);
 719     g_free (encoder);
 720   }
 721   gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 722       GST_TAG_ENCODER_VERSION, vd->vi.version,
 723       GST_TAG_AUDIO_CODEC, "Vorbis", NULL);
 724   if (vd->vi.bitrate_nominal > 0 && vd->vi.bitrate_nominal <= 0x7FFFFFFF) {
 725     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 726         GST_TAG_NOMINAL_BITRATE, (guint) vd->vi.bitrate_nominal, NULL);
 727     bitrate = vd->vi.bitrate_nominal;
 728   }
 729   if (vd->vi.bitrate_upper > 0 && vd->vi.bitrate_upper <= 0x7FFFFFFF) {
 730     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 731         GST_TAG_MAXIMUM_BITRATE, (guint) vd->vi.bitrate_upper, NULL);
 732     if (!bitrate)
 733       bitrate = vd->vi.bitrate_upper;
 734   }
 735   if (vd->vi.bitrate_lower > 0 && vd->vi.bitrate_lower <= 0x7FFFFFFF) {
 736     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 737         GST_TAG_MINIMUM_BITRATE, (guint) vd->vi.bitrate_lower, NULL);
 738     if (!bitrate)
 739       bitrate = vd->vi.bitrate_lower;
 740   }
 741   if (bitrate) {
 742     gst_tag_list_add (vd->taglist, GST_TAG_MERGE_REPLACE,
 743         GST_TAG_BITRATE, (guint) bitrate, NULL);
 744   }
 745
 746   if (vd->initialized) {
 747     gst_element_found_tags_for_pad (GST_ELEMENT_CAST (vd), vd->srcpad,
 748         vd->taglist);
 749     vd->taglist = NULL;
 750   } else {
 751     /* Only post them as messages for the time being. *
 752      * They will be pushed on the pad once the decoder is initialized */
 753     gst_element_post_message (GST_ELEMENT_CAST (vd),
 754         gst_message_new_tag (GST_OBJECT (vd), gst_tag_list_copy (vd->taglist)));
 755   }
 756
 757   return GST_FLOW_OK;
 758 }
 759
 760 static GstFlowReturn
 761 vorbis_handle_type_packet (GstVorbisDec * vd)
 762 {
 763   GList *walk;
 764   gint res;
 765
 766   g_assert (vd->initialized == FALSE);
 767
 768   if (G_UNLIKELY ((res = vorbis_synthesis_init (&vd->vd, &vd->vi))))
 769     goto synthesis_init_error;
 770
 771   if (G_UNLIKELY ((res = vorbis_block_init (&vd->vd, &vd->vb))))
 772     goto block_init_error;
 773
 774   vd->initialized = TRUE;
 775
 776   if (vd->pendingevents) {
 777     for (walk = vd->pendingevents; walk; walk = g_list_next (walk))
 778       gst_pad_push_event (vd->srcpad, GST_EVENT_CAST (walk->data));
 779     g_list_free (vd->pendingevents);
 780     vd->pendingevents = NULL;
 781   }
 782
 783   if (vd->taglist) {
 784     /* The tags have already been sent on the bus as messages. */
 785     gst_pad_push_event (vd->srcpad, gst_event_new_tag (vd->taglist));
 786     vd->taglist = NULL;
 787   }
 788   return GST_FLOW_OK;
 789
 790   /* ERRORS */
 791 synthesis_init_error:
 792   {
 793     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
 794         (NULL), ("couldn't initialize synthesis (%d)", res));
 795     return GST_FLOW_ERROR;
 796   }
 797 block_init_error:
 798   {
 799     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
 800         (NULL), ("couldn't initialize block (%d)", res));
 801     return GST_FLOW_ERROR;
 802   }
 803 }
 804
 805 static GstFlowReturn
 806 vorbis_handle_header_packet (GstVorbisDec * vd, ogg_packet * packet)
 807 {
 808   GstFlowReturn res;
 809   gint ret;
 810
 811   GST_DEBUG_OBJECT (vd, "parsing header packet");
 812
 813   /* Packetno = 0 if the first byte is exactly 0x01 */
 814   packet->b_o_s = (packet->packet[0] == 0x1) ? 1 : 0;
 815
 816   if ((ret = vorbis_synthesis_headerin (&vd->vi, &vd->vc, packet)))
 817     goto header_read_error;
 818
 819   switch (packet->packet[0]) {
 820     case 0x01:
 821       res = vorbis_handle_identification_packet (vd);
 822       break;
 823     case 0x03:
 824       res = vorbis_handle_comment_packet (vd, packet);
 825       break;
 826     case 0x05:
 827       res = vorbis_handle_type_packet (vd);
 828       break;
 829     default:
 830       /* ignore */
 831       g_warning ("unknown vorbis header packet found");
 832       res = GST_FLOW_OK;
 833       break;
 834   }
 835   return res;
 836
 837   /* ERRORS */
 838 header_read_error:
 839   {
 840     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
 841         (NULL), ("couldn't read header packet (%d)", ret));
 842     return GST_FLOW_ERROR;
 843   }
 844 }
 845
 846 /* These samples can be outside of the float -1.0 -- 1.0 range, this
 847  * is allowed, downstream elements are supposed to clip */
 848 static void
 849 copy_samples (float *out, float **in, guint samples, gint channels)
 850 {
 851   gint i, j;
 852
 853 #ifdef GST_VORBIS_DEC_SEQUENTIAL
 854   for (i = 0; i < channels; i++) {
 855     memcpy (out, in[i], samples * sizeof (float));
 856     out += samples;
 857   }
 858 #else
 859   for (j = 0; j < samples; j++) {
 860     for (i = 0; i < channels; i++) {
 861       *out++ = in[i][j];
 862     }
 863   }
 864 #endif
 865 }
 866
 867 static GstFlowReturn
 868 vorbis_dec_push_forward (GstVorbisDec * dec, GstBuffer * buf)
 869 {
 870   GstFlowReturn result;
 871   gint64 outoffset, origoffset;
 872
 873   origoffset = GST_BUFFER_OFFSET (buf);
 874
 875 again:
 876   outoffset = origoffset;
 877
 878   if (outoffset == -1) {
 879     dec->queued = g_list_append (dec->queued, buf);
 880     GST_DEBUG_OBJECT (dec, "queued buffer");
 881     result = GST_FLOW_OK;
 882   } else {
 883     if (G_UNLIKELY (dec->queued)) {
 884       guint size;
 885       GstClockTime ts;
 886       GList *walk;
 887
 888       GST_DEBUG_OBJECT (dec, "first buffer with offset %lld", outoffset);
 889       ts = gst_util_uint64_scale_int (outoffset, GST_SECOND, dec->vi.rate);
 890
 891       size = g_list_length (dec->queued);
 892       /* we walk the queued up list in reverse, and set the buffer fields
 893        * calculating backwards */
 894       for (walk = g_list_last (dec->queued); walk;
 895           walk = g_list_previous (walk)) {
 896         GstBuffer *buffer = GST_BUFFER (walk->data);
 897         guint offset;
 898
 899         offset = GST_BUFFER_SIZE (buffer) / (sizeof (float) * dec->vi.channels);
 900
 901         if (outoffset >= offset)
 902           outoffset -= offset;
 903         else {
 904           /* we can't go below 0, this means this first offset was at the eos
 905            * page and we need to clip to it instead */
 906           GST_DEBUG_OBJECT (dec, "clipping %" G_GINT64_FORMAT,
 907               offset - outoffset);
 908           origoffset += (offset - outoffset);
 909           goto again;
 910         }
 911
 912         GST_BUFFER_OFFSET (buffer) = outoffset;
 913         GST_BUFFER_TIMESTAMP (buffer) =
 914             gst_util_uint64_scale_int (outoffset, GST_SECOND, dec->vi.rate);
 915         GST_BUFFER_DURATION (buffer) = GST_CLOCK_DIFF (GST_BUFFER_TIMESTAMP
 916             (buffer), ts);
 917         ts = GST_BUFFER_TIMESTAMP (buffer);
 918         GST_DEBUG_OBJECT (dec, "patch buffer %u, offset %" G_GUINT64_FORMAT
 919             ", timestamp %" GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT,
 920             size, outoffset,
 921             GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),
 922             GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)));
 923         size--;
 924       }
 925       for (walk = dec->queued; walk; walk = g_list_next (walk)) {
 926         GstBuffer *buffer = GST_BUFFER (walk->data);
 927
 928         /* clips to the configured segment, or returns NULL with buffer
 929          * unreffed when the input buffer is completely outside the segment */
 930         if (!(buffer = gst_audio_buffer_clip (buffer, &dec->segment,
 931                     dec->vi.rate, dec->vi.channels * sizeof (float))))
 932           continue;
 933
 934         if (dec->discont) {
 935           GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
 936           dec->discont = FALSE;
 937         }
 938         /* ignore the result */
 939         gst_pad_push (dec->srcpad, buffer);
 940       }
 941       g_list_free (dec->queued);
 942       dec->queued = NULL;
 943     }
 944
 945     /* clip */
 946     if (!(buf = gst_audio_buffer_clip (buf, &dec->segment, dec->vi.rate,
 947                 dec->vi.channels * sizeof (float))))
 948       return GST_FLOW_OK;
 949
 950     if (dec->discont) {
 951       GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
 952       dec->discont = FALSE;
 953     }
 954
 955     result = gst_pad_push (dec->srcpad, buf);
 956   }
 957
 958   return result;
 959 }
 960
 961 static GstFlowReturn
 962 vorbis_dec_push_reverse (GstVorbisDec * dec, GstBuffer * buf)
 963 {
 964   GstFlowReturn result = GST_FLOW_OK;
 965
 966   dec->queued = g_list_prepend (dec->queued, buf);
 967
 968   return result;
 969 }
 970
 971 static GstFlowReturn
 972 vorbis_handle_data_packet (GstVorbisDec * vd, ogg_packet * packet)
 973 {
 974   float **pcm;
 975   guint sample_count;
 976   GstBuffer *out;
 977   GstFlowReturn result;
 978   GstClockTime timestamp = GST_CLOCK_TIME_NONE, nextts;
 979   gint size;
 980
 981   if (!vd->initialized)
 982     goto not_initialized;
 983
 984   /* FIXME, we should queue undecoded packets here until we get
 985    * a timestamp, then we reverse timestamp the queued packets and
 986    * clip them, then we decode only the ones we want and don't
 987    * keep decoded data in memory.
 988    * Ideally, of course, the demuxer gives us a valid timestamp on
 989    * the first packet.
 990    */
 991
 992   /* normal data packet */
 993   /* FIXME, we can skip decoding if the packet is outside of the
 994    * segment, this is however not very trivial as we need a previous
 995    * packet to decode the current one so we must be carefull not to
 996    * throw away too much. For now we decode everything and clip right
 997    * before pushing data. */
 998   if (G_UNLIKELY (vorbis_synthesis (&vd->vb, packet)))
 999     goto could_not_read;
1000
1001   if (G_UNLIKELY (vorbis_synthesis_blockin (&vd->vd, &vd->vb) < 0))
1002     goto not_accepted;
1003
1004   /* assume all goes well here */
1005   result = GST_FLOW_OK;
1006
1007   /* count samples ready for reading */
1008   if ((sample_count = vorbis_synthesis_pcmout (&vd->vd, NULL)) == 0)
1009     goto done;
1010
1011   GST_LOG_OBJECT (vd, "%d samples ready for reading", sample_count);
1012   size = sample_count * vd->vi.channels * sizeof (float);
1013
1014   /* alloc buffer for it */
1015   result =
1016       gst_pad_alloc_buffer_and_set_caps (vd->srcpad, GST_BUFFER_OFFSET_NONE,
1017       size, GST_PAD_CAPS (vd->srcpad), &out);
1018   if (G_UNLIKELY (result != GST_FLOW_OK))
1019     goto done;
1020
1021   /* get samples ready for reading now, should be sample_count */
1022   if (G_UNLIKELY ((vorbis_synthesis_pcmout (&vd->vd, &pcm)) != sample_count))
1023     goto wrong_samples;
1024
1025   /* copy samples in buffer */
1026   copy_samples ((float *) GST_BUFFER_DATA (out), pcm, sample_count,
1027       vd->vi.channels);
1028
1029   GST_BUFFER_SIZE (out) = size;
1030
1031   /* this should not overflow */
1032   GST_BUFFER_DURATION (out) = sample_count * GST_SECOND / vd->vi.rate;
1033
1034   if (packet->granulepos != -1)
1035     vd->granulepos = packet->granulepos - sample_count;
1036
1037   if (vd->cur_timestamp != GST_CLOCK_TIME_NONE) {
1038     /* we have incoming timestamps */
1039     timestamp = vd->cur_timestamp;
1040     GST_DEBUG_OBJECT (vd,
1041         "cur_timestamp: %" GST_TIME_FORMAT " + %" GST_TIME_FORMAT " = %"
1042         GST_TIME_FORMAT, GST_TIME_ARGS (vd->cur_timestamp),
1043         GST_TIME_ARGS (GST_BUFFER_DURATION (out)),
1044         GST_TIME_ARGS (vd->cur_timestamp + GST_BUFFER_DURATION (out)));
1045     vd->cur_timestamp += GST_BUFFER_DURATION (out);
1046     GST_BUFFER_OFFSET (out) = GST_CLOCK_TIME_TO_FRAMES (timestamp, vd->vi.rate);
1047     GST_BUFFER_OFFSET_END (out) = GST_BUFFER_OFFSET (out) + sample_count;
1048   } else {
1049     /* we have incoming granulepos */
1050     GST_BUFFER_OFFSET (out) = vd->granulepos;
1051     if (vd->granulepos != -1) {
1052       GST_DEBUG_OBJECT (vd, "granulepos: %" G_GINT64_FORMAT, vd->granulepos);
1053       GST_BUFFER_OFFSET_END (out) = vd->granulepos + sample_count;
1054       timestamp =
1055           gst_util_uint64_scale_int (vd->granulepos, GST_SECOND, vd->vi.rate);
1056       nextts =
1057           gst_util_uint64_scale_int (vd->granulepos + sample_count,
1058           GST_SECOND, vd->vi.rate);
1059       GST_DEBUG_OBJECT (vd, "corresponding timestamp %" GST_TIME_FORMAT,
1060           GST_TIME_ARGS (timestamp));
1061       /* calculate a nano-second accurate duration */
1062       GST_BUFFER_DURATION (out) = GST_CLOCK_DIFF (timestamp, nextts);
1063       GST_DEBUG_OBJECT (vd, "set duration %" GST_TIME_FORMAT,
1064           GST_TIME_ARGS (GST_BUFFER_DURATION (out)));
1065     } else {
1066       timestamp = -1;
1067     }
1068   }
1069   GST_BUFFER_TIMESTAMP (out) = timestamp;
1070
1071   if (vd->granulepos != -1)
1072     vd->granulepos += sample_count;
1073
1074   if (vd->segment.rate >= 0.0)
1075     result = vorbis_dec_push_forward (vd, out);
1076   else
1077     result = vorbis_dec_push_reverse (vd, out);
1078
1079 done:
1080   vorbis_synthesis_read (&vd->vd, sample_count);
1081
1082   GST_DEBUG_OBJECT (vd,
1083       "decoded %ld bytes into %d samples, ts %" GST_TIME_FORMAT, packet->bytes,
1084       sample_count, GST_TIME_ARGS (timestamp));
1085
1086   /* granulepos is the last sample in the packet */
1087   if (packet->granulepos != -1)
1088     vd->granulepos = packet->granulepos;
1089
1090   return result;
1091
1092   /* ERRORS */
1093 not_initialized:
1094   {
1095     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
1096         (NULL), ("no header sent yet"));
1097     return GST_FLOW_ERROR;
1098   }
1099 could_not_read:
1100   {
1101     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
1102         (NULL), ("couldn't read data packet"));
1103     return GST_FLOW_ERROR;
1104   }
1105 not_accepted:
1106   {
1107     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
1108         (NULL), ("vorbis decoder did not accept data packet"));
1109     return GST_FLOW_ERROR;
1110   }
1111 wrong_samples:
1112   {
1113     gst_buffer_unref (out);
1114     GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,
1115         (NULL), ("vorbis decoder reported wrong number of samples"));
1116     return GST_FLOW_ERROR;
1117   }
1118 }
1119
1120 static GstFlowReturn
1121 vorbis_dec_decode_buffer (GstVorbisDec * vd, GstBuffer * buffer)
1122 {
1123   ogg_packet packet;
1124   GstFlowReturn result = GST_FLOW_OK;
1125   GstClockTime timestamp;
1126   guint64 offset_end;
1127
1128   timestamp = GST_BUFFER_TIMESTAMP (buffer);
1129   offset_end = GST_BUFFER_OFFSET_END (buffer);
1130
1131   /* only ogg has granulepos, demuxers of other container formats
1132    * might provide us with timestamps instead (e.g. matroskademux) */
1133   if (offset_end == GST_BUFFER_OFFSET_NONE && timestamp != GST_CLOCK_TIME_NONE) {
1134     /* we might get multiple consecutive buffers with the same timestamp */
1135     if (timestamp != vd->prev_timestamp) {
1136       vd->cur_timestamp = timestamp;
1137       vd->prev_timestamp = timestamp;
1138     }
1139   } else {
1140     vd->cur_timestamp = GST_CLOCK_TIME_NONE;
1141     vd->prev_timestamp = GST_CLOCK_TIME_NONE;
1142   }
1143
1144   /* make ogg_packet out of the buffer */
1145   packet.packet = GST_BUFFER_DATA (buffer);
1146   packet.bytes = GST_BUFFER_SIZE (buffer);
1147   packet.granulepos = offset_end;
1148   packet.packetno = 0;          /* we don't care */
1149   /*
1150    * FIXME. Is there anyway to know that this is the last packet and
1151    * set e_o_s??
1152    * Yes there is, keep one packet at all times and only push out when
1153    * you receive a new one.  Implement this.
1154    */
1155   packet.e_o_s = 0;
1156
1157   /* error out on empty header packets, but just skip empty data packets */
1158   if (G_UNLIKELY (packet.bytes == 0)) {
1159     if (vd->initialized)
1160       goto empty_buffer;
1161     else
1162       goto empty_header;
1163   }
1164
1165   GST_DEBUG_OBJECT (vd, "vorbis granule: %" G_GINT64_FORMAT,
1166       (gint64) packet.granulepos);
1167
1168   /* switch depending on packet type */
1169   if (packet.packet[0] & 1) {
1170     if (vd->initialized) {
1171       GST_WARNING_OBJECT (vd, "Already initialized, so ignoring header packet");
1172       goto done;
1173     }
1174     result = vorbis_handle_header_packet (vd, &packet);
1175   } else {
1176     result = vorbis_handle_data_packet (vd, &packet);
1177   }
1178
1179 done:
1180   return result;
1181
1182 empty_buffer:
1183   {
1184     /* don't error out here, just ignore the buffer, it's invalid for vorbis
1185      * but not fatal. */
1186     GST_WARNING_OBJECT (vd, "empty buffer received, ignoring");
1187     if (packet.granulepos != -1)
1188       vd->granulepos = packet.granulepos;
1189     result = GST_FLOW_OK;
1190     goto done;
1191   }
1192
1193 /* ERRORS */
1194 empty_header:
1195   {
1196     GST_ELEMENT_ERROR (vd, STREAM, DECODE, (NULL), ("empty header received"));
1197     result = GST_FLOW_ERROR;
1198     vd->discont = TRUE;
1199     goto done;
1200   }
1201 }
1202
1203 /*
1204  * Input:
1205  *  Buffer decoding order:  7  8  9  4  5  6  3  1  2  EOS
1206  *  Discont flag:           D        D        D  D
1207  *
1208  * - Each Discont marks a discont in the decoding order.
1209  *
1210  * for vorbis, each buffer is a keyframe when we have the previous
1211  * buffer. This means that to decode buffer 7, we need buffer 6, which
1212  * arrives out of order.
1213  *
1214  * we first gather buffers in the gather queue until we get a DISCONT. We
1215  * prepend each incomming buffer so that they are in reversed order.
1216  *
1217  *    gather queue:    9  8  7
1218  *    decode queue:
1219  *    output queue:
1220  *
1221  * When a DISCONT is received (buffer 4), we move the gather queue to the
1222  * decode queue. This is simply done be taking the head of the gather queue
1223  * and prepending it to the decode queue. This yields:
1224  *
1225  *    gather queue:
1226  *    decode queue:    7  8  9
1227  *    output queue:
1228  *
1229  * Then we decode each buffer in the decode queue in order and put the output
1230  * buffer in the output queue. The first buffer (7) will not produce any output
1231  * because it needs the previous buffer (6) which did not arrive yet. This
1232  * yields:
1233  *
1234  *    gather queue:
1235  *    decode queue:    7  8  9
1236  *    output queue:    9  8
1237  *
1238  * Then we remove the consumed buffers from the decode queue. Buffer 7 is not
1239  * completely consumed, we need to keep it around for when we receive buffer
1240  * 6. This yields:
1241  *
1242  *    gather queue:
1243  *    decode queue:    7
1244  *    output queue:    9  8
1245  *
1246  * Then we accumulate more buffers:
1247  *
1248  *    gather queue:    6  5  4
1249  *    decode queue:    7
1250  *    output queue:
1251  *
1252  * prepending to the decode queue on DISCONT yields:
1253  *
1254  *    gather queue:
1255  *    decode queue:    4  5  6  7
1256  *    output queue:
1257  *
1258  * after decoding and keeping buffer 4:
1259  *
1260  *    gather queue:
1261  *    decode queue:    4
1262  *    output queue:    7  6  5
1263  *
1264  * Etc..
1265  */
1266 static GstFlowReturn
1267 vorbis_dec_flush_decode (GstVorbisDec * dec)
1268 {
1269   GstFlowReturn res = GST_FLOW_OK;
1270   GList *walk;
1271
1272   walk = dec->decode;
1273
1274   GST_DEBUG_OBJECT (dec, "flushing buffers to decoder");
1275
1276   while (walk) {
1277     GList *next;
1278     GstBuffer *buf = GST_BUFFER_CAST (walk->data);
1279
1280     GST_DEBUG_OBJECT (dec, "decoding buffer %p, ts %" GST_TIME_FORMAT,
1281         buf, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
1282
1283     next = g_list_next (walk);
1284
1285     /* decode buffer, prepend to output queue */
1286     res = vorbis_dec_decode_buffer (dec, buf);
1287
1288     /* if we generated output, we can discard the buffer, else we
1289      * keep it in the queue */
1290     if (dec->queued) {
1291       GST_DEBUG_OBJECT (dec, "decoded buffer to %p", dec->queued->data);
1292       dec->decode = g_list_delete_link (dec->decode, walk);
1293       gst_buffer_unref (buf);
1294     } else {
1295       GST_DEBUG_OBJECT (dec, "buffer did not decode, keeping");
1296     }
1297     walk = next;
1298   }
1299   if (dec->granulepos != -1) {
1300     GstClockTime endts;
1301
1302     endts =
1303         gst_util_uint64_scale_int (dec->granulepos, GST_SECOND, dec->vi.rate);
1304
1305     GST_DEBUG_OBJECT (dec, "we have granulepos %" G_GUINT64_FORMAT ", ts %"
1306         GST_TIME_FORMAT, dec->granulepos, GST_TIME_ARGS (endts));
1307
1308     while (dec->queued) {
1309       GstBuffer *buf;
1310       guint sample_count;
1311
1312       buf = GST_BUFFER_CAST (dec->queued->data);
1313
1314       sample_count =
1315           GST_BUFFER_SIZE (buf) / (dec->vi.channels * sizeof (float));
1316
1317       GST_BUFFER_OFFSET_END (buf) = dec->granulepos;
1318       endts =
1319           gst_util_uint64_scale_int (dec->granulepos, GST_SECOND, dec->vi.rate);
1320       dec->granulepos -= sample_count;
1321       GST_BUFFER_OFFSET (buf) = dec->granulepos;
1322       GST_BUFFER_TIMESTAMP (buf) =
1323           gst_util_uint64_scale_int (dec->granulepos, GST_SECOND, dec->vi.rate);
1324       GST_BUFFER_DURATION (buf) = endts - GST_BUFFER_TIMESTAMP (buf);
1325
1326       /* clip, this will unref the buffer in case of clipping */
1327       if (!(buf = gst_audio_buffer_clip (buf, &dec->segment, dec->vi.rate,
1328                   dec->vi.channels * sizeof (float)))) {
1329         GST_DEBUG_OBJECT (dec, "clipped buffer %p", buf);
1330         goto next;
1331       }
1332
1333       if (dec->discont) {
1334         GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
1335         dec->discont = FALSE;
1336       }
1337       GST_DEBUG_OBJECT (dec, "pushing buffer %p, samples %u, "
1338           "ts %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT,
1339           buf, sample_count, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
1340           GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
1341
1342       res = gst_pad_push (dec->srcpad, buf);
1343     next:
1344       dec->queued = g_list_delete_link (dec->queued, dec->queued);
1345     }
1346   } else {
1347     GST_DEBUG_OBJECT (dec, "we don't have a granulepos yet, delayed push");
1348   }
1349   return res;
1350 }
1351
1352 static GstFlowReturn
1353 vorbis_dec_chain_reverse (GstVorbisDec * vd, gboolean discont, GstBuffer * buf)
1354 {
1355   GstFlowReturn result = GST_FLOW_OK;
1356
1357   /* if we have a discont, move buffers to the decode list */
1358   if (G_UNLIKELY (discont)) {
1359     GST_DEBUG_OBJECT (vd, "received discont");
1360     while (vd->gather) {
1361       GstBuffer *gbuf;
1362
1363       gbuf = GST_BUFFER_CAST (vd->gather->data);
1364       /* remove from the gather list */
1365       vd->gather = g_list_delete_link (vd->gather, vd->gather);
1366       /* copy to decode queue */
1367       vd->decode = g_list_prepend (vd->decode, gbuf);
1368     }
1369     /* flush and decode the decode queue */
1370     result = vorbis_dec_flush_decode (vd);
1371   }
1372
1373   GST_DEBUG_OBJECT (vd, "gathering buffer %p, size %u", buf,
1374       GST_BUFFER_SIZE (buf));
1375   /* add buffer to gather queue */
1376   vd->gather = g_list_prepend (vd->gather, buf);
1377
1378   return result;
1379 }
1380
1381 static GstFlowReturn
1382 vorbis_dec_chain_forward (GstVorbisDec * vd, gboolean discont,
1383     GstBuffer * buffer)
1384 {
1385   GstFlowReturn result;
1386
1387   result = vorbis_dec_decode_buffer (vd, buffer);
1388
1389   gst_buffer_unref (buffer);
1390
1391   return result;
1392
1393 }
1394
1395 static GstFlowReturn
1396 vorbis_dec_chain (GstPad * pad, GstBuffer * buffer)
1397 {
1398   GstVorbisDec *vd;
1399   GstFlowReturn result = GST_FLOW_OK;
1400   gboolean discont;
1401
1402   vd = GST_VORBIS_DEC (gst_pad_get_parent (pad));
1403
1404   discont = GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT);
1405
1406   /* resync on DISCONT */
1407   if (G_UNLIKELY (discont)) {
1408     GST_DEBUG_OBJECT (vd, "received DISCONT buffer");
1409     vd->granulepos = -1;
1410     vd->cur_timestamp = GST_CLOCK_TIME_NONE;
1411     vd->prev_timestamp = GST_CLOCK_TIME_NONE;
1412 #ifdef HAVE_VORBIS_SYNTHESIS_RESTART
1413     vorbis_synthesis_restart (&vd->vd);
1414 #endif
1415     vd->discont = TRUE;
1416   }
1417
1418   if (vd->segment.rate >= 0.0)
1419     result = vorbis_dec_chain_forward (vd, discont, buffer);
1420   else
1421     result = vorbis_dec_chain_reverse (vd, discont, buffer);
1422
1423   gst_object_unref (vd);
1424
1425   return result;
1426 }
1427
1428 static GstStateChangeReturn
1429 vorbis_dec_change_state (GstElement * element, GstStateChange transition)
1430 {
1431   GstVorbisDec *vd = GST_VORBIS_DEC (element);
1432   GstStateChangeReturn res;
1433
1434   switch (transition) {
1435     case GST_STATE_CHANGE_NULL_TO_READY:
1436       break;
1437     case GST_STATE_CHANGE_READY_TO_PAUSED:
1438       vorbis_info_init (&vd->vi);
1439       vorbis_comment_init (&vd->vc);
1440       vd->initialized = FALSE;
1441       gst_vorbis_dec_reset (vd);
1442       break;
1443     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1444       break;
1445     default:
1446       break;
1447   }
1448
1449   res = parent_class->change_state (element, transition);
1450
1451   switch (transition) {
1452     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1453       break;
1454     case GST_STATE_CHANGE_PAUSED_TO_READY:
1455       GST_DEBUG_OBJECT (vd, "PAUSED -> READY, clearing vorbis structures");
1456       vd->initialized = FALSE;
1457       vorbis_block_clear (&vd->vb);
1458       vorbis_dsp_clear (&vd->vd);
1459       vorbis_comment_clear (&vd->vc);
1460       vorbis_info_clear (&vd->vi);
1461       gst_vorbis_dec_reset (vd);
1462       break;
1463     case GST_STATE_CHANGE_READY_TO_NULL:
1464       break;
1465     default:
1466       break;
1467   }
1468
1469   return res;
1470 }