/* GStreamer Base Class for Tag Demuxing

 * Copyright (C) 2005 Jan Schmidt <thaytan@mad.scientist.com>

 * Copyright (C) 2006-2007 Tim-Philipp Müller <tim centricular net>

 *

 * 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:gsttagdemux

 * @see_also: GstApeDemux, GstID3Demux

 * @short_description: Base class for demuxing tags that are in chunks

 *                     directly at the beginning or at the end of a file

 * 

 * <refsect2>

 * <para>

 * Provides a base class for demuxing tags at the beginning or end of a

 * stream and handles things like typefinding, querying, seeking, and

 * different modes of operation (chain-based, pull_range-based, and providing

 * downstream elements with random access if upstream supports that). The tag

 * is stripped from the output, and all offsets are adjusted for the tag

 * sizes, so that to the downstream element the stream will appear as if

 * there was no tag at all. Also, once the tag has been parsed, GstTagDemux

 * will try to determine the media type of the resulting stream and add a

 * source pad with the appropriate caps in order to facilitate auto-plugging.

 * </para>

 * <title>Deriving from GstTagDemux</title>

 * <para>

 * Subclasses have to do four things:

 * <itemizedlist>

 *  <listitem><para>

 *  In their base init function, they must add a pad template for the sink

 *  pad to the element class, describing the media type they can parse in

 *  the caps of the pad template.

 *  </para></listitem>

 *  <listitem><para>

 *  In their class init function, they must override

 *  GST_TAG_DEMUX_CLASS(demux_klass)->identify_tag with their own identify

 *  function.

 *  </para></listitem>

 *  <listitem><para>

 *  In their class init function, they must override

 *  GST_TAG_DEMUX_CLASS(demux_klass)->parse_tag with their own parse

 *  function.

 *  </para></listitem>

 *  <listitem><para>

 *  In their class init function, they must also set

 *  GST_TAG_DEMUX_CLASS(demux_klass)->min_start_size and/or 

 *  GST_TAG_DEMUX_CLASS(demux_klass)->min_end_size to the minimum size required

 *  for the identify function to decide whether the stream has a supported tag

 *  or not. A class parsing ID3v1 tags, for example, would set min_end_size to

 *  128 bytes.

 *  </para></listitem>

 * </itemizedlist>

 * </para>

 * </refsect2>

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gsttagdemux.h"

#include <gst/base/gsttypefindhelper.h>

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

#include <string.h>

typedef enum

{

  GST_TAG_DEMUX_READ_START_TAG,

  GST_TAG_DEMUX_TYPEFINDING,

  GST_TAG_DEMUX_STREAMING

} GstTagDemuxState;

struct _GstTagDemuxPrivate

{

  GstPad *srcpad;

  GstPad *sinkpad;

  /* Number of bytes to remove from the

   * start of file (tag at beginning) */

  guint strip_start;

  /* Number of bytes to remove from the

   * end of file (tag at end) */

  guint strip_end;

  gint64 upstream_size;

  GstTagDemuxState state;

  GstBuffer *collect;

  GstCaps *src_caps;

  GstTagList *event_tags;

  GstTagList *parsed_tags;

  gboolean send_tag_event;

  GstSegment segment;

  gboolean need_newseg;

  gboolean newseg_update;

};

/* Require at least 8kB of data before we attempt typefind. 

 * Seems a decent value based on test files

 * 40kB is massive overkill for the maximum, I think, but it 

 * doesn't do any harm (tpm: increased to 64kB after watching

 * typefinding fail on a wavpack file that needed 42kB to succeed) */

#define TYPE_FIND_MIN_SIZE 8192

#define TYPE_FIND_MAX_SIZE 65536

GST_DEBUG_CATEGORY_STATIC (tagdemux_debug);

#define GST_CAT_DEFAULT (tagdemux_debug)

static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_SOMETIMES,

    GST_STATIC_CAPS ("ANY")

    );

static void gst_tag_demux_dispose (GObject * object);

static GstFlowReturn gst_tag_demux_chain (GstPad * pad, GstBuffer * buf);

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

static gboolean gst_tag_demux_src_activate_pull (GstPad * pad, gboolean active);

static GstFlowReturn gst_tag_demux_read_range (GstTagDemux * tagdemux,

    guint64 offset, guint length, GstBuffer ** buffer);

static gboolean gst_tag_demux_src_checkgetrange (GstPad * srcpad);

static GstFlowReturn gst_tag_demux_src_getrange (GstPad * srcpad,

    guint64 offset, guint length, GstBuffer ** buffer);

static gboolean gst_tag_demux_add_srcpad (GstTagDemux * tagdemux,

    GstCaps * new_caps);

static gboolean gst_tag_demux_remove_srcpad (GstTagDemux * tagdemux);

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

static gboolean gst_tag_demux_sink_activate (GstPad * sinkpad);

static GstStateChangeReturn gst_tag_demux_change_state (GstElement * element,

    GstStateChange transition);

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

static const GstQueryType *gst_tag_demux_get_query_types (GstPad * pad);

static gboolean gst_tag_demux_get_upstream_size (GstTagDemux * tagdemux);

static void gst_tag_demux_send_tag_event (GstTagDemux * tagdemux);

static gboolean gst_tag_demux_send_new_segment (GstTagDemux * tagdemux);

static void gst_tag_demux_base_init (gpointer g_class);

static void gst_tag_demux_class_init (gpointer g_class, gpointer d);

static void gst_tag_demux_init (GstTagDemux * obj, GstTagDemuxClass * klass);

static gpointer parent_class;   /* NULL */

/* Cannot use boilerplate macros here because we want the abstract flag */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GType

gst_tag_demux_get_type (void)

{

  static GType object_type;     /* 0 */

  if (object_type == 0) {

    static const GTypeInfo object_info = {

      sizeof (GstTagDemuxClass),

      gst_tag_demux_base_init,

      NULL,                     /* base_finalize */

      gst_tag_demux_class_init,

      NULL,                     /* class_finalize */

      NULL,                     /* class_data */

      sizeof (GstTagDemux),

      0,                        /* n_preallocs */

      (GInstanceInitFunc) gst_tag_demux_init

    };

    object_type = g_type_register_static (GST_TYPE_ELEMENT,

        "GstTagDemux", &object_info, G_TYPE_FLAG_ABSTRACT);

  }

  return object_type;

}

static void

gst_tag_demux_base_init (gpointer klass)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&src_factory));

  GST_DEBUG_CATEGORY_INIT (tagdemux_debug, "tagdemux", 0,

      "tag demux base class");

}

static void

gst_tag_demux_class_init (gpointer klass, gpointer d)

{

  GstTagDemuxClass *tagdemux_class = GST_TAG_DEMUX_CLASS (klass);

  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

  gobject_class->dispose = gst_tag_demux_dispose;

  element_class->change_state = GST_DEBUG_FUNCPTR (gst_tag_demux_change_state);

  g_type_class_add_private (klass, sizeof (GstTagDemuxPrivate));

  /* subclasses must set at least one of these */

  tagdemux_class->min_start_size = 0;

  tagdemux_class->min_end_size = 0;

}

static void

gst_tag_demux_reset (GstTagDemux * tagdemux)

{

  GstBuffer **buffer_p = &tagdemux->priv->collect;

  GstCaps **caps_p = &tagdemux->priv->src_caps;

  tagdemux->priv->strip_start = 0;

  tagdemux->priv->strip_end = 0;

  tagdemux->priv->upstream_size = -1;

  tagdemux->priv->state = GST_TAG_DEMUX_READ_START_TAG;

  tagdemux->priv->send_tag_event = FALSE;

  gst_buffer_replace (buffer_p, NULL);

  gst_caps_replace (caps_p, NULL);

  gst_tag_demux_remove_srcpad (tagdemux);

  if (tagdemux->priv->event_tags) {

    gst_tag_list_free (tagdemux->priv->event_tags);

    tagdemux->priv->event_tags = NULL;

  }

  if (tagdemux->priv->parsed_tags) {

    gst_tag_list_free (tagdemux->priv->parsed_tags);

    tagdemux->priv->parsed_tags = NULL;

  }

  gst_segment_init (&tagdemux->priv->segment, GST_FORMAT_UNDEFINED);

  tagdemux->priv->need_newseg = TRUE;

  tagdemux->priv->newseg_update = FALSE;

}

static void

gst_tag_demux_init (GstTagDemux * demux, GstTagDemuxClass * gclass)

{

  GstElementClass *element_klass = GST_ELEMENT_CLASS (gclass);

  GstPadTemplate *tmpl;

  demux->priv = g_type_instance_get_private ((GTypeInstance *) demux,

      GST_TYPE_TAG_DEMUX);

  tmpl = gst_element_class_get_pad_template (element_klass, "sink");

  if (tmpl) {

    demux->priv->sinkpad = gst_pad_new_from_template (tmpl, "sink");

    gst_pad_set_activate_function (demux->priv->sinkpad,

        GST_DEBUG_FUNCPTR (gst_tag_demux_sink_activate));

    gst_pad_set_event_function (demux->priv->sinkpad,

        GST_DEBUG_FUNCPTR (gst_tag_demux_sink_event));

    gst_pad_set_chain_function (demux->priv->sinkpad,

        GST_DEBUG_FUNCPTR (gst_tag_demux_chain));

    gst_element_add_pad (GST_ELEMENT (demux), demux->priv->sinkpad);

  }

  gst_tag_demux_reset (demux);

}

static void

gst_tag_demux_dispose (GObject * object)

{

  GstTagDemux *tagdemux = GST_TAG_DEMUX (object);

  gst_tag_demux_reset (tagdemux);

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

static gboolean

gst_tag_demux_add_srcpad (GstTagDemux * tagdemux, GstCaps * new_caps)

{

  GstPad *srcpad = NULL;

  if (tagdemux->priv->src_caps == NULL ||

      !gst_caps_is_equal (new_caps, tagdemux->priv->src_caps)) {

    gst_caps_replace (&tagdemux->priv->src_caps, new_caps);

    if (tagdemux->priv->srcpad != NULL) {

      GST_DEBUG_OBJECT (tagdemux, "Changing src pad caps to %" GST_PTR_FORMAT,

          tagdemux->priv->src_caps);

      gst_pad_set_caps (tagdemux->priv->srcpad, tagdemux->priv->src_caps);

    }

  } else {

    /* Caps never changed */

  }

  if (tagdemux->priv->srcpad == NULL) {

    srcpad = tagdemux->priv->srcpad =

        gst_pad_new_from_template (gst_element_class_get_pad_template

        (GST_ELEMENT_GET_CLASS (tagdemux), "src"), "src");

    g_return_val_if_fail (tagdemux->priv->srcpad != NULL, FALSE);

    gst_pad_set_query_type_function (tagdemux->priv->srcpad,

        GST_DEBUG_FUNCPTR (gst_tag_demux_get_query_types));

    gst_pad_set_query_function (tagdemux->priv->srcpad,

        GST_DEBUG_FUNCPTR (gst_tag_demux_pad_query));

    gst_pad_set_event_function (tagdemux->priv->srcpad,

        GST_DEBUG_FUNCPTR (gst_tag_demux_srcpad_event));

    gst_pad_set_activatepull_function (tagdemux->priv->srcpad,

        GST_DEBUG_FUNCPTR (gst_tag_demux_src_activate_pull));

    gst_pad_set_checkgetrange_function (tagdemux->priv->srcpad,

        GST_DEBUG_FUNCPTR (gst_tag_demux_src_checkgetrange));

    gst_pad_set_getrange_function (tagdemux->priv->srcpad,

        GST_DEBUG_FUNCPTR (gst_tag_demux_src_getrange));

    gst_pad_use_fixed_caps (tagdemux->priv->srcpad);

    if (tagdemux->priv->src_caps)

      gst_pad_set_caps (tagdemux->priv->srcpad, tagdemux->priv->src_caps);

    GST_DEBUG_OBJECT (tagdemux, "Adding src pad with caps %" GST_PTR_FORMAT,

        tagdemux->priv->src_caps);

    gst_object_ref (tagdemux->priv->srcpad);

    gst_pad_set_active (tagdemux->priv->srcpad, TRUE);

    if (!gst_element_add_pad (GST_ELEMENT (tagdemux), tagdemux->priv->srcpad))

      return FALSE;

    gst_element_no_more_pads (GST_ELEMENT (tagdemux));

  }

  return TRUE;

}

static gboolean

gst_tag_demux_remove_srcpad (GstTagDemux * demux)

{

  gboolean res = TRUE;

  if (demux->priv->srcpad != NULL) {

    GST_DEBUG_OBJECT (demux, "Removing src pad");

    res = gst_element_remove_pad (GST_ELEMENT (demux), demux->priv->srcpad);

    g_return_val_if_fail (res != FALSE, FALSE);

    gst_object_unref (demux->priv->srcpad);

    demux->priv->srcpad = NULL;

  }

  return res;

};

/* will return FALSE if buffer is beyond end of data; will return TRUE

 * if buffer was trimmed successfully or didn't need trimming, but may

 * also return TRUE and set *buf_ref to NULL if the buffer was before

 * the start of the data */

static gboolean

gst_tag_demux_trim_buffer (GstTagDemux * tagdemux, GstBuffer ** buf_ref)

{

  GstBuffer *buf = *buf_ref;

  guint trim_start = 0;

  guint out_size = GST_BUFFER_SIZE (buf);

  guint64 out_offset = GST_BUFFER_OFFSET (buf);

  gboolean need_sub = FALSE;

  /* Adjust offset and length */

  if (!GST_BUFFER_OFFSET_IS_VALID (buf)) {

    /* Can't change anything without an offset */

    return TRUE;

  }

  /* If the buffer crosses the tag at the end of file, trim it */

  if (tagdemux->priv->strip_end > 0) {

    if (gst_tag_demux_get_upstream_size (tagdemux)) {

      guint64 v1tag_offset =

          tagdemux->priv->upstream_size - tagdemux->priv->strip_end;

      if (out_offset >= v1tag_offset) {

        GST_DEBUG_OBJECT (tagdemux, "Buffer is past the end of the data");

        goto no_out_buffer_end;

      }

      if (out_offset + out_size > v1tag_offset) {

        out_size = v1tag_offset - out_offset;

        need_sub = TRUE;

      }

    }

  }

  if (tagdemux->priv->strip_start > 0) {

    /* If the buffer crosses the tag at the start of file, trim it */

    if (out_offset <= tagdemux->priv->strip_start) {

      if (out_offset + out_size <= tagdemux->priv->strip_start) {

        GST_DEBUG_OBJECT (tagdemux, "Buffer is before the start of the data");

        goto no_out_buffer_start;

      }

      trim_start = tagdemux->priv->strip_start - out_offset;

      out_size -= trim_start;

      out_offset = 0;

    } else {

      out_offset -= tagdemux->priv->strip_start;

    }

    need_sub = TRUE;

  }

  if (need_sub == TRUE) {

    if (out_size != GST_BUFFER_SIZE (buf) || !gst_buffer_is_writable (buf)) {

      GstBuffer *sub;

      GST_DEBUG_OBJECT (tagdemux, "Sub-buffering to trim size %d offset %"

          G_GINT64_FORMAT " to %d offset %" G_GINT64_FORMAT,

          GST_BUFFER_SIZE (buf), GST_BUFFER_OFFSET (buf), out_size, out_offset);

      sub = gst_buffer_create_sub (buf, trim_start, out_size);

      g_return_val_if_fail (sub != NULL, FALSE);

      gst_buffer_unref (buf);

      *buf_ref = buf = sub;

    } else {

      GST_DEBUG_OBJECT (tagdemux, "Adjusting buffer from size %d offset %"

          G_GINT64_FORMAT " to %d offset %" G_GINT64_FORMAT,

          GST_BUFFER_SIZE (buf), GST_BUFFER_OFFSET (buf), out_size, out_offset);

    }

    GST_BUFFER_OFFSET (buf) = out_offset;

    GST_BUFFER_OFFSET_END (buf) = out_offset + out_size;

    gst_buffer_set_caps (buf, tagdemux->priv->src_caps);

  }

  return TRUE;

no_out_buffer_end:

  {

    gst_buffer_unref (buf);

    *buf_ref = NULL;

    return FALSE;

  }

no_out_buffer_start:

  {

    gst_buffer_unref (buf);

    *buf_ref = NULL;

    return TRUE;

  }

}

static void

gst_tag_demux_chain_parse_tag (GstTagDemux * demux, GstBuffer * collect)

{

  GstTagDemuxResult parse_ret;

  GstTagDemuxClass *klass;

  guint tagsize = 0;

  guint available;

  g_assert (gst_buffer_is_metadata_writable (collect));

  klass = GST_TAG_DEMUX_CLASS (G_OBJECT_GET_CLASS (demux));

  /* If we receive a buffer that's from the middle of the file, 

   * we can't read tags so move to typefinding */

  if (GST_BUFFER_OFFSET_IS_VALID (collect) && GST_BUFFER_OFFSET (collect) != 0) {

    GST_DEBUG_OBJECT (demux, "Received buffer from non-zero offset %"

        G_GINT64_FORMAT ". Can't read tags", GST_BUFFER_OFFSET (collect));

    demux->priv->state = GST_TAG_DEMUX_TYPEFINDING;

    return;

  }

  g_assert (klass->identify_tag != NULL);

  g_assert (klass->parse_tag != NULL);

  available = GST_BUFFER_SIZE (collect);

  if (available < klass->min_start_size) {

    GST_DEBUG_OBJECT (demux, "Only %u bytes available, but %u needed "

        "to identify tag", available, klass->min_start_size);

    return;                     /* wait for more data */

  }

  if (!klass->identify_tag (demux, collect, TRUE, &tagsize)) {

    GST_DEBUG_OBJECT (demux, "Could not identify start tag");

    demux->priv->state = GST_TAG_DEMUX_TYPEFINDING;

    return;

  }

  /* need to set offset of first buffer to 0 or trimming won't work */

  if (!GST_BUFFER_OFFSET_IS_VALID (collect)) {

    GST_WARNING_OBJECT (demux, "Fixing up first buffer without offset");

    GST_BUFFER_OFFSET (collect) = 0;

  }

  GST_DEBUG_OBJECT (demux, "Identified tag, size = %u bytes", tagsize);

  do {

    GstTagList *tags = NULL;

    guint newsize, saved_size;

    demux->priv->strip_start = tagsize;

    if (available < tagsize) {

      GST_DEBUG_OBJECT (demux, "Only %u bytes available, but %u needed "

          "to parse tag", available, tagsize);

      return;                   /* wait for more data */

    }

    saved_size = GST_BUFFER_SIZE (collect);

    GST_BUFFER_SIZE (collect) = tagsize;

    newsize = tagsize;