/* GStreamer

 * Copyright (C) 2004 Benjamin Otte <in7y118@public.uni-hamburg.de>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:element-vorbisdec

 * @short_description: a decoder that decodes Vorbis to raw audio

 * @see_also: vorbisenc, oggdemux

 *

 * <refsect2>

 * <para>

 * This element decodes a Vorbis stream to raw float audio.

 * <ulink url="http://www.vorbis.com/">Vorbis</ulink> is a royalty-free

 * audio codec maintained by the <ulink url="http://www.xiph.org/">Xiph.org

 * Foundation</ulink>.

 * </para>

 * <title>Example pipelines</title>

 * <para>

 * <programlisting>

 * gst-launch -v filesrc location=sine.ogg ! oggdemux ! vorbisdec ! audioconvert ! alsasink

 * </programlisting>

 * Decode an Ogg/Vorbis. To create an Ogg/Vorbis file refer to the documentation of vorbisenc.

 * </para>

 * </refsect2>

 *

 * Last reviewed on 2006-03-01 (0.10.4)

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include "vorbisdec.h"

#include <string.h>

#include <gst/audio/audio.h>

#include <gst/tag/tag.h>

#include <gst/audio/multichannel.h>

GST_DEBUG_CATEGORY_EXTERN (vorbisdec_debug);

#define GST_CAT_DEFAULT vorbisdec_debug

static const GstElementDetails vorbis_dec_details =

GST_ELEMENT_DETAILS ("Vorbis audio decoder",

    "Codec/Decoder/Audio",

    "decode raw vorbis streams to float audio",

    "Benjamin Otte <in7y118@public.uni-hamburg.de>");

static GstStaticPadTemplate vorbis_dec_src_factory =

GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("audio/x-raw-float, "

        "rate = (int) [ 1, MAX ], "

        "channels = (int) [ 1, 256 ], " "endianness = (int) BYTE_ORDER, "

/* no ifdef in macros, please

#ifdef GST_VORBIS_DEC_SEQUENTIAL

      "layout = \"sequential\", "

#endif

*/

        "width = (int) 32")

    );

static GstStaticPadTemplate vorbis_dec_sink_factory =

GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("audio/x-vorbis")

    );

GST_BOILERPLATE (GstVorbisDec, gst_vorbis_dec, GstElement, GST_TYPE_ELEMENT);

static void vorbis_dec_finalize (GObject * object);

static gboolean vorbis_dec_sink_event (GstPad * pad, GstEvent * event);

static GstFlowReturn vorbis_dec_chain (GstPad * pad, GstBuffer * buffer);

static GstFlowReturn vorbis_dec_chain_forward (GstVorbisDec * vd,

    gboolean discont, GstBuffer * buffer);

static GstStateChangeReturn vorbis_dec_change_state (GstElement * element,

    GstStateChange transition);

static gboolean vorbis_dec_src_event (GstPad * pad, GstEvent * event);

static gboolean vorbis_dec_src_query (GstPad * pad, GstQuery * query);

static gboolean vorbis_dec_convert (GstPad * pad,

    GstFormat src_format, gint64 src_value,

    GstFormat * dest_format, gint64 * dest_value);

static gboolean vorbis_dec_sink_query (GstPad * pad, GstQuery * query);

static void

gst_vorbis_dec_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  GstPadTemplate *src_template, *sink_template;

  src_template = gst_static_pad_template_get (&vorbis_dec_src_factory);

  gst_element_class_add_pad_template (element_class, src_template);

  sink_template = gst_static_pad_template_get (&vorbis_dec_sink_factory);

  gst_element_class_add_pad_template (element_class, sink_template);

  gst_element_class_set_details (element_class, &vorbis_dec_details);

}

static void

gst_vorbis_dec_class_init (GstVorbisDecClass * klass)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);

  gobject_class->finalize = vorbis_dec_finalize;

  gstelement_class->change_state = GST_DEBUG_FUNCPTR (vorbis_dec_change_state);

}

static const GstQueryType *

vorbis_get_query_types (GstPad * pad)

{

  static const GstQueryType vorbis_dec_src_query_types[] = {

    GST_QUERY_POSITION,

    GST_QUERY_DURATION,

    GST_QUERY_CONVERT,

    0

  };

  return vorbis_dec_src_query_types;

}

static void

gst_vorbis_dec_init (GstVorbisDec * dec, GstVorbisDecClass * g_class)

{

  dec->sinkpad = gst_pad_new_from_static_template (&vorbis_dec_sink_factory,

      "sink");

  gst_pad_set_event_function (dec->sinkpad,

      GST_DEBUG_FUNCPTR (vorbis_dec_sink_event));

  gst_pad_set_chain_function (dec->sinkpad,

      GST_DEBUG_FUNCPTR (vorbis_dec_chain));

  gst_pad_set_query_function (dec->sinkpad,

      GST_DEBUG_FUNCPTR (vorbis_dec_sink_query));

  gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad);

  dec->srcpad = gst_pad_new_from_static_template (&vorbis_dec_src_factory,

      "src");

  gst_pad_set_event_function (dec->srcpad,

      GST_DEBUG_FUNCPTR (vorbis_dec_src_event));

  gst_pad_set_query_type_function (dec->srcpad,

      GST_DEBUG_FUNCPTR (vorbis_get_query_types));

  gst_pad_set_query_function (dec->srcpad,

      GST_DEBUG_FUNCPTR (vorbis_dec_src_query));

  gst_pad_use_fixed_caps (dec->srcpad);

  gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad);

  dec->queued = NULL;

  dec->pendingevents = NULL;

  dec->taglist = NULL;

}

static void

vorbis_dec_finalize (GObject * object)

{

  /* Release any possibly allocated libvorbis data.

   * _clear functions can safely be called multiple times

   */

  GstVorbisDec *vd = GST_VORBIS_DEC (object);

  vorbis_block_clear (&vd->vb);

  vorbis_dsp_clear (&vd->vd);

  vorbis_comment_clear (&vd->vc);

  vorbis_info_clear (&vd->vi);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

gst_vorbis_dec_reset (GstVorbisDec * dec)

{

  dec->cur_timestamp = GST_CLOCK_TIME_NONE;

  dec->prev_timestamp = GST_CLOCK_TIME_NONE;

  dec->granulepos = -1;

  dec->discont = TRUE;

  gst_segment_init (&dec->segment, GST_FORMAT_TIME);

  g_list_foreach (dec->queued, (GFunc) gst_mini_object_unref, NULL);

  g_list_free (dec->queued);

  dec->queued = NULL;

  g_list_foreach (dec->gather, (GFunc) gst_mini_object_unref, NULL);

  g_list_free (dec->gather);

  dec->gather = NULL;

  g_list_foreach (dec->decode, (GFunc) gst_mini_object_unref, NULL);

  g_list_free (dec->decode);

  dec->decode = NULL;

  g_list_foreach (dec->pendingevents, (GFunc) gst_mini_object_unref, NULL);

  g_list_free (dec->pendingevents);

  dec->pendingevents = NULL;

  if (dec->taglist)

    gst_tag_list_free (dec->taglist);

  dec->taglist = NULL;

}

static gboolean

vorbis_dec_convert (GstPad * pad,

    GstFormat src_format, gint64 src_value,

    GstFormat * dest_format, gint64 * dest_value)

{

  gboolean res = TRUE;

  GstVorbisDec *dec;

  guint64 scale = 1;

  if (src_format == *dest_format) {

    *dest_value = src_value;

    return TRUE;

  }

  dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));

  if (!dec->initialized)

    goto no_header;

  if (dec->sinkpad == pad &&

      (src_format == GST_FORMAT_BYTES || *dest_format == GST_FORMAT_BYTES))

    goto no_format;

  switch (src_format) {

    case GST_FORMAT_TIME:

      switch (*dest_format) {

        case GST_FORMAT_BYTES:

          scale = sizeof (float) * dec->vi.channels;

        case GST_FORMAT_DEFAULT:

          *dest_value =

              scale * gst_util_uint64_scale_int (src_value, dec->vi.rate,

              GST_SECOND);

          break;

        default:

          res = FALSE;

      }

      break;

    case GST_FORMAT_DEFAULT:

      switch (*dest_format) {

        case GST_FORMAT_BYTES:

          *dest_value = src_value * sizeof (float) * dec->vi.channels;

          break;

        case GST_FORMAT_TIME:

          *dest_value =

              gst_util_uint64_scale_int (src_value, GST_SECOND, dec->vi.rate);

          break;

        default:

          res = FALSE;

      }

      break;

    case GST_FORMAT_BYTES:

      switch (*dest_format) {

        case GST_FORMAT_DEFAULT:

          *dest_value = src_value / (sizeof (float) * dec->vi.channels);

          break;

        case GST_FORMAT_TIME:

          *dest_value = gst_util_uint64_scale_int (src_value, GST_SECOND,

              dec->vi.rate * sizeof (float) * dec->vi.channels);

          break;

        default:

          res = FALSE;

      }

      break;

    default:

      res = FALSE;

  }

done:

  gst_object_unref (dec);

  return res;

  /* ERRORS */

no_header:

  {

    GST_DEBUG_OBJECT (dec, "no header packets received");

    res = FALSE;

    goto done;

  }

no_format:

  {

    GST_DEBUG_OBJECT (dec, "formats unsupported");

    res = FALSE;

    goto done;

  }

}

static gboolean

vorbis_dec_src_query (GstPad * pad, GstQuery * query)

{

  GstVorbisDec *dec;

  gboolean res = FALSE;

  dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));

  switch (GST_QUERY_TYPE (query)) {

    case GST_QUERY_POSITION:

    {

      gint64 granulepos, value;

      GstFormat my_format, format;

      gint64 time;

      /* we start from the last seen granulepos */

      granulepos = dec->granulepos;

      gst_query_parse_position (query, &format, NULL);

      /* and convert to the final format in two steps with time as the

       * intermediate step */

      my_format = GST_FORMAT_TIME;

      if (!(res =

              vorbis_dec_convert (pad, GST_FORMAT_DEFAULT, granulepos,

                  &my_format, &time)))

        goto error;

      /* correct for the segment values */

      time = gst_segment_to_stream_time (&dec->segment, GST_FORMAT_TIME, time);

      GST_LOG_OBJECT (dec,

          "query %p: our time: %" GST_TIME_FORMAT, query, GST_TIME_ARGS (time));

      /* and convert to the final format */

      if (!(res = vorbis_dec_convert (pad, my_format, time, &format, &value)))

        goto error;

      gst_query_set_position (query, format, value);

      GST_LOG_OBJECT (dec,

          "query %p: we return %lld (format %u)", query, value, format);

      break;

    }

    case GST_QUERY_DURATION:

    {

      GstPad *peer;

      if (!(peer = gst_pad_get_peer (dec->sinkpad))) {

        GST_WARNING_OBJECT (dec, "sink pad %" GST_PTR_FORMAT " is not linked",

            dec->sinkpad);

        goto error;

      }

      res = gst_pad_query (peer, query);

      gst_object_unref (peer);

      if (!res)

        goto error;

      break;

    }

    case GST_QUERY_CONVERT:

    {

      GstFormat src_fmt, dest_fmt;

      gint64 src_val, dest_val;

      gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);

      if (!(res =

              vorbis_dec_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val)))

        goto error;

      gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);

      break;

    }

    default:

      res = gst_pad_query_default (pad, query);

      break;

  }

done:

  gst_object_unref (dec);

  return res;

  /* ERRORS */

error:

  {

    GST_WARNING_OBJECT (dec, "error handling query");

    goto done;

  }

}

static gboolean

vorbis_dec_sink_query (GstPad * pad, GstQuery * query)

{

  GstVorbisDec *dec;

  gboolean res;

  dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));

  switch (GST_QUERY_TYPE (query)) {

    case GST_QUERY_CONVERT:

    {

      GstFormat src_fmt, dest_fmt;

      gint64 src_val, dest_val;

      gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);

      if (!(res =

              vorbis_dec_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val)))

        goto error;

      gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);

      break;

    }

    default:

      res = gst_pad_query_default (pad, query);

      break;

  }

done:

  gst_object_unref (dec);

  return res;

  /* ERRORS */

error:

  {

    GST_DEBUG_OBJECT (dec, "error converting value");

    goto done;

  }

}

static gboolean

vorbis_dec_src_event (GstPad * pad, GstEvent * event)

{

  gboolean res = TRUE;

  GstVorbisDec *dec;

  dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_SEEK:

    {

      GstFormat format, tformat;

      gdouble rate;

      GstEvent *real_seek;

      GstSeekFlags flags;

      GstSeekType cur_type, stop_type;

      gint64 cur, stop;

      gint64 tcur, tstop;

      gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur,

          &stop_type, &stop);

      gst_event_unref (event);

      /* we have to ask our peer to seek to time here as we know

       * nothing about how to generate a granulepos from the src

       * formats or anything.

       *

       * First bring the requested format to time

       */

      tformat = GST_FORMAT_TIME;

      if (!(res = vorbis_dec_convert (pad, format, cur, &tformat, &tcur)))

        goto convert_error;

      if (!(res = vorbis_dec_convert (pad, format, stop, &tformat, &tstop)))

        goto convert_error;

      /* then seek with time on the peer */

      real_seek = gst_event_new_seek (rate, GST_FORMAT_TIME,

          flags, cur_type, tcur, stop_type, tstop);

      res = gst_pad_push_event (dec->sinkpad, real_seek);

      break;

    }

    default:

      res = gst_pad_push_event (dec->sinkpad, event);

      break;

  }

done:

  gst_object_unref (dec);

  return res;

  /* ERRORS */

convert_error:

  {

    GST_DEBUG_OBJECT (dec, "cannot convert start/stop for seek");

    goto done;

  }

}

static gboolean

vorbis_dec_sink_event (GstPad * pad, GstEvent * event)

{

  gboolean ret = FALSE;

  GstVorbisDec *dec;

  dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));

  GST_LOG_OBJECT (dec, "handling event");

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_EOS:

      ret = gst_pad_push_event (dec->srcpad, event);

      break;

    case GST_EVENT_FLUSH_START:

      ret = gst_pad_push_event (dec->srcpad, event);

      break;

    case GST_EVENT_FLUSH_STOP:

      /* here we must clean any state in the decoder */

#ifdef HAVE_VORBIS_SYNTHESIS_RESTART

      vorbis_synthesis_restart (&dec->vd);

#endif

      gst_vorbis_dec_reset (dec);

      ret = gst_pad_push_event (dec->srcpad, event);

      break;

    case GST_EVENT_NEWSEGMENT:

    {

      GstFormat format;

      gdouble rate, arate;

      gint64 start, stop, time;

      gboolean update;

      gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,

          &start, &stop, &time);

      /* we need time for now */

      if (format != GST_FORMAT_TIME)