/* GStreamer

 * Copyright (C) 2004 Wim Taymans <wim@fluendo.com>

 *

 * gstoggdemux.c: ogg stream demuxer

 *

 * 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-oggdemux

 * @short_description: a demuxer for ogg files

 *

 * <refsect2>

 * <para>

 * This element demuxes ogg files into their encoded audio and video components.

 * </para>

 * <title>Example pipelines</title>

 * <para>

 * <programlisting>

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

 * </programlisting>

 * Decodes the vorbis audio stored inside an ogg container.

 * </para>

 * </refsect2>

 *

 * Last reviewed on 2006-12-30 (0.10.5)

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <gst/gst-i18n-plugin.h>

#include <gst/base/gsttypefindhelper.h>

#include "gstoggdemux.h"

static const GstElementDetails gst_ogg_demux_details =

GST_ELEMENT_DETAILS ("Ogg demuxer",

    "Codec/Demuxer",

    "demux ogg streams (info about ogg: http://xiph.org)",

    "Wim Taymans <wim@fluendo.com>");

#define CHUNKSIZE (8500)        /* this is out of vorbisfile */

#define SKELETON_FISHEAD_SIZE 64

#define SKELETON_FISBONE_MIN_SIZE 52

#define GST_FLOW_LIMIT GST_FLOW_CUSTOM_ERROR

GST_DEBUG_CATEGORY_STATIC (gst_ogg_demux_debug);

GST_DEBUG_CATEGORY_STATIC (gst_ogg_demux_setup_debug);

#define GST_CAT_DEFAULT gst_ogg_demux_debug

static ogg_page *

gst_ogg_page_copy (ogg_page * page)

{

  ogg_page *p = g_new0 (ogg_page, 1);

  /* make a copy of the page */

  p->header = g_memdup (page->header, page->header_len);

  p->header_len = page->header_len;

  p->body = g_memdup (page->body, page->body_len);

  p->body_len = page->body_len;

  return p;

}

static void

gst_ogg_page_free (ogg_page * page)

{

  g_free (page->header);

  g_free (page->body);

  g_free (page);

}

static GstStaticPadTemplate internaltemplate =

GST_STATIC_PAD_TEMPLATE ("internal",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS_ANY);

static gboolean gst_ogg_demux_collect_chain_info (GstOggDemux * ogg,

    GstOggChain * chain);

static gboolean gst_ogg_demux_activate_chain (GstOggDemux * ogg,

    GstOggChain * chain, GstEvent * event);

static void gst_ogg_chain_mark_discont (GstOggChain * chain);

static gboolean gst_ogg_demux_perform_seek (GstOggDemux * ogg,

    GstEvent * event);

static gboolean gst_ogg_demux_receive_event (GstElement * element,

    GstEvent * event);

static void gst_ogg_pad_class_init (GstOggPadClass * klass);

static void gst_ogg_pad_init (GstOggPad * pad);

static void gst_ogg_pad_dispose (GObject * object);

static void gst_ogg_pad_finalize (GObject * object);

#if 0

static const GstFormat *gst_ogg_pad_formats (GstPad * pad);

static const GstEventMask *gst_ogg_pad_event_masks (GstPad * pad);

#endif

static const GstQueryType *gst_ogg_pad_query_types (GstPad * pad);

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

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

static GstCaps *gst_ogg_pad_getcaps (GstPad * pad);

static GstOggPad *gst_ogg_chain_get_stream (GstOggChain * chain,

    glong serialno);

static gboolean gst_ogg_pad_query_convert (GstOggPad * pad,

    GstFormat src_format, gint64 src_val,

    GstFormat * dest_format, gint64 * dest_val);

static GstClockTime gst_annodex_granule_to_time (gint64 granulepos,

    gint64 granulerate_n, gint64 granulerate_d, guint8 granuleshift);

static GstFlowReturn gst_ogg_demux_combine_flows (GstOggDemux * ogg,

    GstOggPad * pad, GstFlowReturn ret);

static GstPadClass *ogg_pad_parent_class = NULL;

static GType

gst_ogg_pad_get_type (void)

{

  static GType ogg_pad_type = 0;

  if (!ogg_pad_type) {

    static const GTypeInfo ogg_pad_info = {

      sizeof (GstOggPadClass),

      NULL,

      NULL,

      (GClassInitFunc) gst_ogg_pad_class_init,

      NULL,

      NULL,

      sizeof (GstOggPad),

      0,

      (GInstanceInitFunc) gst_ogg_pad_init,

    };

    ogg_pad_type =

        g_type_register_static (GST_TYPE_PAD, "GstOggPad", &ogg_pad_info, 0);

  }

  return ogg_pad_type;

}

static void

gst_ogg_pad_class_init (GstOggPadClass * klass)

{

  GObjectClass *gobject_class;

  gobject_class = (GObjectClass *) klass;

  ogg_pad_parent_class = g_type_class_peek_parent (klass);

  gobject_class->dispose = gst_ogg_pad_dispose;

  gobject_class->finalize = gst_ogg_pad_finalize;

}

static void

gst_ogg_pad_init (GstOggPad * pad)

{

  gst_pad_set_event_function (GST_PAD (pad),

      GST_DEBUG_FUNCPTR (gst_ogg_pad_event));

  gst_pad_set_getcaps_function (GST_PAD (pad),

      GST_DEBUG_FUNCPTR (gst_ogg_pad_getcaps));

  gst_pad_set_query_type_function (GST_PAD (pad),

      GST_DEBUG_FUNCPTR (gst_ogg_pad_query_types));

  gst_pad_set_query_function (GST_PAD (pad),

      GST_DEBUG_FUNCPTR (gst_ogg_pad_src_query));

  pad->mode = GST_OGG_PAD_MODE_INIT;

  pad->first_granule = -1;

  pad->current_granule = -1;

  pad->start_time = GST_CLOCK_TIME_NONE;

  pad->first_time = GST_CLOCK_TIME_NONE;

  pad->have_type = FALSE;

  pad->continued = NULL;

  pad->headers = NULL;

}

static void

gst_ogg_pad_dispose (GObject * object)

{

  GstOggPad *pad = GST_OGG_PAD (object);

  GstPad **elem_pad_p;

  GstElement **element_p;

  GstPad **elem_out_p;

  if (pad->element)

    gst_element_set_state (pad->element, GST_STATE_NULL);

  elem_pad_p = &pad->elem_pad;

  element_p = &pad->element;

  elem_out_p = &pad->elem_out;

  gst_object_replace ((GstObject **) elem_pad_p, NULL);

  gst_object_replace ((GstObject **) element_p, NULL);

  gst_object_replace ((GstObject **) elem_out_p, NULL);

  pad->chain = NULL;

  pad->ogg = NULL;

  g_list_foreach (pad->headers, (GFunc) gst_mini_object_unref, NULL);

  g_list_free (pad->headers);

  pad->headers = NULL;

  /* clear continued pages */

  g_list_foreach (pad->continued, (GFunc) gst_ogg_page_free, NULL);

  g_list_free (pad->continued);

  pad->continued = NULL;

  ogg_stream_reset (&pad->stream);

  G_OBJECT_CLASS (ogg_pad_parent_class)->dispose (object);

}

static void

gst_ogg_pad_finalize (GObject * object)

{

  GstOggPad *pad = GST_OGG_PAD (object);

  ogg_stream_clear (&pad->stream);

  G_OBJECT_CLASS (ogg_pad_parent_class)->finalize (object);

}

#if 0

static const GstFormat *

gst_ogg_pad_formats (GstPad * pad)

{

  static GstFormat src_formats[] = {

    GST_FORMAT_DEFAULT,         /* time */

    GST_FORMAT_TIME,            /* granulepos */

    0

  };

  static GstFormat sink_formats[] = {

    GST_FORMAT_BYTES,

    GST_FORMAT_DEFAULT,         /* bytes */

    0

  };

  return (GST_PAD_IS_SRC (pad) ? src_formats : sink_formats);

}

#endif

#if 0

static const GstEventMask *

gst_ogg_pad_event_masks (GstPad * pad)

{

  static const GstEventMask src_event_masks[] = {

    {GST_EVENT_SEEK, GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH},

    {0,}

  };

  return src_event_masks;

}

#endif

static const GstQueryType *

gst_ogg_pad_query_types (GstPad * pad)

{

  static const GstQueryType query_types[] = {

    GST_QUERY_DURATION,

    GST_QUERY_SEEKING,

    0

  };

  return query_types;

}

static GstCaps *

gst_ogg_pad_getcaps (GstPad * pad)

{

  return gst_caps_ref (GST_PAD_CAPS (pad));

}

static gboolean

gst_ogg_pad_src_query (GstPad * pad, GstQuery * query)

{

  gboolean res = TRUE;

  GstOggDemux *ogg;

  GstOggPad *cur;

  ogg = GST_OGG_DEMUX (gst_pad_get_parent (pad));

  cur = GST_OGG_PAD (pad);

  switch (GST_QUERY_TYPE (query)) {

    case GST_QUERY_DURATION:

    {

      GstFormat format;

      gst_query_parse_duration (query, &format, NULL);

      /* can only get position in time */

      if (format != GST_FORMAT_TIME)

        goto wrong_format;

      /* can only return the total time position */

      /* FIXME, return time for this specific stream */

      gst_query_set_duration (query, GST_FORMAT_TIME, ogg->total_time);

      break;

    }

    case GST_QUERY_SEEKING:

    {

      GstFormat format;

      gst_query_parse_seeking (query, &format, NULL, NULL, NULL);

      if (format == GST_FORMAT_TIME) {

        gst_query_set_seeking (query, GST_FORMAT_TIME, ogg->seekable,

            0, ogg->total_time);

      } else {

        res = FALSE;

      }

      break;

    }

    default:

      res = gst_pad_query_default (pad, query);

      break;

  }

done:

  gst_object_unref (ogg);

  return res;

  /* ERRORS */

wrong_format:

  {

    GST_DEBUG_OBJECT (ogg, "only query duration on TIME is supported");

    res = FALSE;

    goto done;

  }

}

static gboolean

gst_ogg_demux_receive_event (GstElement * element, GstEvent * event)

{

  gboolean res;

  GstOggDemux *ogg;

  ogg = GST_OGG_DEMUX (element);

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_SEEK:

      /* can't seek if we are not seekable, FIXME could pass the

       * seek query upstream after converting it to bytes using

       * the average bitrate of the stream. */

      if (!ogg->seekable) {

        GST_DEBUG_OBJECT (ogg, "seek on non seekable stream");

        goto error;

      }

      /* now do the seek */

      res = gst_ogg_demux_perform_seek (ogg, event);

      gst_event_unref (event);

      break;

    default:

      GST_DEBUG_OBJECT (ogg, "We only handle seek events here");

      goto error;

  }

  return res;

  /* ERRORS */

error:

  {

    GST_DEBUG_OBJECT (ogg, "error handling event");

    gst_event_unref (event);

    return FALSE;

  }

}

static gboolean

gst_ogg_pad_event (GstPad * pad, GstEvent * event)

{

  gboolean res;

  GstOggDemux *ogg;

  GstOggPad *cur;

  ogg = GST_OGG_DEMUX (gst_pad_get_parent (pad));

  cur = GST_OGG_PAD (pad);

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_SEEK:

      /* can't seek if we are not seekable, FIXME could pass the

       * seek query upstream after converting it to bytes using

       * the average bitrate of the stream. */

      if (!ogg->seekable) {

        GST_DEBUG_OBJECT (ogg, "seek on non seekable stream");

        goto error;

      }

      /* now do the seek */

      res = gst_ogg_demux_perform_seek (ogg, event);

      gst_event_unref (event);

      break;

    default:

      res = gst_pad_event_default (pad, event);

      break;

  }

done:

  gst_object_unref (ogg);

  return res;

  /* ERRORS */

error:

  {

    GST_DEBUG_OBJECT (ogg, "error handling event");

    gst_event_unref (event);

    res = FALSE;

    goto done;

  }

}

static void

gst_ogg_pad_reset (GstOggPad * pad)

{

  ogg_stream_reset (&pad->stream);

  /* clear continued pages */

  g_list_foreach (pad->continued, (GFunc) gst_ogg_page_free, NULL);

  g_list_free (pad->continued);

  pad->continued = NULL;

  pad->last_ret = GST_FLOW_OK;

}

/* the filter function for selecting the elements we can use in

 * autoplugging */

static gboolean

gst_ogg_demux_factory_filter (GstPluginFeature * feature, GstCaps * caps)

{

  guint rank;

  const gchar *klass;

  /* we only care about element factories */

  if (!GST_IS_ELEMENT_FACTORY (feature))

    return FALSE;

  klass = gst_element_factory_get_klass (GST_ELEMENT_FACTORY (feature));

  /* only demuxers and decoders can play */

  if (strstr (klass, "Demux") == NULL &&

      strstr (klass, "Decoder") == NULL && strstr (klass, "Parse") == NULL) {

    return FALSE;

  }

  /* only select elements with autoplugging rank */

  rank = gst_plugin_feature_get_rank (feature);

  if (rank < GST_RANK_MARGINAL)

    return FALSE;

  GST_DEBUG ("checking factory %s", GST_PLUGIN_FEATURE_NAME (feature));

  /* now see if it is compatible with the caps */

  {

    GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);

    const GList *templates;

    GList *walk;

    /* get the templates from the element factory */

    templates = gst_element_factory_get_static_pad_templates (factory);

    for (walk = (GList *) templates; walk; walk = g_list_next (walk)) {

      GstStaticPadTemplate *templ = walk->data;

      /* we only care about the sink templates */

      if (templ->direction == GST_PAD_SINK) {

        GstCaps *intersect;

        GstCaps *scaps;

        gboolean empty;

        /* try to intersect the caps with the caps of the template */

        scaps = gst_static_caps_get (&templ->static_caps);

        intersect = gst_caps_intersect (caps, scaps);

        gst_caps_unref (scaps);

        empty = gst_caps_is_empty (intersect);

        gst_caps_unref (intersect);

        /* check if the intersection is empty */

        if (!empty) {

          /* non empty intersection, we can use this element */

          goto found;

        }

      }

    }

  }

  return FALSE;

found:

  return TRUE;

}

/* function used to sort element features */

static gint

compare_ranks (GstPluginFeature * f1, GstPluginFeature * f2)

{

  gint diff;

  diff = gst_plugin_feature_get_rank (f2) - gst_plugin_feature_get_rank (f1);

  if (diff != 0)

    return diff;

  return strcmp (gst_plugin_feature_get_name (f2),

      gst_plugin_feature_get_name (f1));

}

/* called when the skeleton fishead is found. Caller ensures the packet is

 * precisely the correct size; we don't re-check this here. */

static void

gst_ogg_pad_parse_skeleton_fishead (GstOggPad * pad, ogg_packet * packet)

{

  GstOggDemux *ogg = pad->ogg;

  guint8 *data = packet->packet;

  guint16 major, minor;

  gint64 prestime_n, prestime_d;