/* -*- Mode: C; tab-width: 2; indent-tabs-mode: t; c-basic-offset: 2 -*- */

/* GStreamer

 * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>

 * Copyright (C) <2006> Nokia Corporation, Stefan Kost <stefan.kost@nokia.com>.

 *

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

 *

 * Parse a .wav file into raw or compressed audio.

 *

 * Wavparse supports both push and pull mode operations, making it possible to

 * stream from a network source.

 *

 * <refsect2>

 * <title>Example launch line</title>

 * |[

 * gst-launch filesrc location=sine.wav ! wavparse ! audioconvert ! alsasink

 * ]| Read a wav file and output to the soundcard using the ALSA element. The

 * wav file is assumed to contain raw uncompressed samples.

 * |[

 * gst-launch gnomevfssrc location=http://www.example.org/sine.wav ! queue ! wavparse ! audioconvert ! alsasink

 * ]| Stream data from a network url.

 * </refsect2>

 *

 * Last reviewed on 2007-02-14 (0.10.6)

 */

/*

 * TODO:

 * http://replaygain.hydrogenaudio.org/file_format_wav.html

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <math.h>

#include "gstwavparse.h"

#include "gst/riff/riff-ids.h"

#include "gst/riff/riff-media.h"

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

GST_DEBUG_CATEGORY_STATIC (wavparse_debug);

#define GST_CAT_DEFAULT (wavparse_debug)

static void gst_wavparse_dispose (GObject * object);

static gboolean gst_wavparse_sink_activate (GstPad * sinkpad);

static gboolean gst_wavparse_sink_activate_pull (GstPad * sinkpad,

    gboolean active);

static gboolean gst_wavparse_send_event (GstElement * element,

    GstEvent * event);

static GstStateChangeReturn gst_wavparse_change_state (GstElement * element,

    GstStateChange transition);

static const GstQueryType *gst_wavparse_get_query_types (GstPad * pad);

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

static gboolean gst_wavparse_pad_convert (GstPad * pad,

    GstFormat src_format,

    gint64 src_value, GstFormat * dest_format, gint64 * dest_value);

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

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

static void gst_wavparse_loop (GstPad * pad);

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

static const GstElementDetails gst_wavparse_details =

GST_ELEMENT_DETAILS ("WAV audio demuxer",

    "Codec/Demuxer/Audio",

    "Parse a .wav file into raw audio",

    "Erik Walthinsen <omega@cse.ogi.edu>");

static GstStaticPadTemplate sink_template_factory =

GST_STATIC_PAD_TEMPLATE ("wavparse_sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("audio/x-wav")

    );

#define DEBUG_INIT(bla) \

  GST_DEBUG_CATEGORY_INIT (wavparse_debug, "wavparse", 0, "WAV parser");

GST_BOILERPLATE_FULL (GstWavParse, gst_wavparse, GstElement,

    GST_TYPE_ELEMENT, DEBUG_INIT);

static void

gst_wavparse_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  GstPadTemplate *src_template;

  /* register pads */

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&sink_template_factory));

  src_template = gst_pad_template_new ("wavparse_src", GST_PAD_SRC,

      GST_PAD_SOMETIMES, gst_riff_create_audio_template_caps ());

  gst_element_class_add_pad_template (element_class, src_template);

  gst_object_unref (src_template);

  gst_element_class_set_details (element_class, &gst_wavparse_details);

}

static void

gst_wavparse_class_init (GstWavParseClass * klass)

{

  GstElementClass *gstelement_class;

  GObjectClass *object_class;

  gstelement_class = (GstElementClass *) klass;

  object_class = (GObjectClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  object_class->dispose = gst_wavparse_dispose;

  gstelement_class->change_state = gst_wavparse_change_state;

  gstelement_class->send_event = gst_wavparse_send_event;

}

static void

gst_wavparse_reset (GstWavParse * wav)

{

  wav->state = GST_WAVPARSE_START;

  /* These will all be set correctly in the fmt chunk */

  wav->depth = 0;

  wav->rate = 0;

  wav->width = 0;

  wav->channels = 0;

  wav->blockalign = 0;

  wav->bps = 0;

  wav->fact = 0;

  wav->offset = 0;

  wav->end_offset = 0;

  wav->dataleft = 0;

  wav->datasize = 0;

  wav->datastart = 0;

  wav->duration = 0;

  wav->got_fmt = FALSE;

  wav->first = TRUE;

  if (wav->seek_event)

    gst_event_unref (wav->seek_event);

  wav->seek_event = NULL;

  if (wav->adapter) {

    gst_adapter_clear (wav->adapter);

    g_object_unref (wav->adapter);

    wav->adapter = NULL;

  }

  if (wav->tags)

    gst_tag_list_free (wav->tags);

  wav->tags = NULL;

}

static void

gst_wavparse_dispose (GObject * object)

{

  GstWavParse *wav = GST_WAVPARSE (object);

  GST_DEBUG_OBJECT (wav, "WAV: Dispose");

  gst_wavparse_reset (wav);

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

static void

gst_wavparse_init (GstWavParse * wavparse, GstWavParseClass * g_class)

{

  gst_wavparse_reset (wavparse);

  /* sink */

  wavparse->sinkpad =

      gst_pad_new_from_static_template (&sink_template_factory, "sink");

  gst_pad_set_activate_function (wavparse->sinkpad,

      GST_DEBUG_FUNCPTR (gst_wavparse_sink_activate));

  gst_pad_set_activatepull_function (wavparse->sinkpad,

      GST_DEBUG_FUNCPTR (gst_wavparse_sink_activate_pull));

  gst_pad_set_chain_function (wavparse->sinkpad,

      GST_DEBUG_FUNCPTR (gst_wavparse_chain));

  gst_pad_set_event_function (wavparse->sinkpad,

      GST_DEBUG_FUNCPTR (gst_wavparse_sink_event));

  gst_element_add_pad (GST_ELEMENT_CAST (wavparse), wavparse->sinkpad);

  /* src, will be created later */

  wavparse->srcpad = NULL;

}

static void

gst_wavparse_destroy_sourcepad (GstWavParse * wavparse)

{

  if (wavparse->srcpad) {

    gst_element_remove_pad (GST_ELEMENT_CAST (wavparse), wavparse->srcpad);

    wavparse->srcpad = NULL;

  }

}

static void

gst_wavparse_create_sourcepad (GstWavParse * wavparse)

{

  GstElementClass *klass = GST_ELEMENT_GET_CLASS (wavparse);

  GstPadTemplate *src_template;

  /* destroy previous one */

  gst_wavparse_destroy_sourcepad (wavparse);

  /* source */

  src_template = gst_element_class_get_pad_template (klass, "wavparse_src");

  wavparse->srcpad = gst_pad_new_from_template (src_template, "src");

  gst_pad_use_fixed_caps (wavparse->srcpad);

  gst_pad_set_query_type_function (wavparse->srcpad,

      GST_DEBUG_FUNCPTR (gst_wavparse_get_query_types));

  gst_pad_set_query_function (wavparse->srcpad,

      GST_DEBUG_FUNCPTR (gst_wavparse_pad_query));

  gst_pad_set_event_function (wavparse->srcpad,

      GST_DEBUG_FUNCPTR (gst_wavparse_srcpad_event));

  GST_DEBUG_OBJECT (wavparse, "srcpad created");

}

/* Compute (value * nom) % denom, avoiding overflow.  This can be used

 * to perform ceiling or rounding division together with

 * gst_util_uint64_scale[_int]. */

#define uint64_scale_modulo(val, nom, denom) \

  ((val % denom) * (nom % denom) % denom)

/* Like gst_util_uint64_scale, but performs ceiling division. */

static guint64

uint64_ceiling_scale_int (guint64 val, gint num, gint denom)

{

  guint64 result = gst_util_uint64_scale_int (val, num, denom);

  if (uint64_scale_modulo (val, num, denom) == 0)

    return result;

  else

    return result + 1;

}

/* Like gst_util_uint64_scale, but performs ceiling division. */

static guint64

uint64_ceiling_scale (guint64 val, guint64 num, guint64 denom)

{

  guint64 result = gst_util_uint64_scale (val, num, denom);

  if (uint64_scale_modulo (val, num, denom) == 0)

    return result;

  else

    return result + 1;

}

/* FIXME: why is that not in use? */

#if 0

static void

gst_wavparse_parse_adtl (GstWavParse * wavparse, int len)

{

  guint32 got_bytes;

  GstByteStream *bs = wavparse->bs;

  gst_riff_chunk *temp_chunk, chunk;

  guint8 *tempdata;

  struct _gst_riff_labl labl, *temp_labl;

  struct _gst_riff_ltxt ltxt, *temp_ltxt;

  struct _gst_riff_note note, *temp_note;

  char *label_name;

  GstProps *props;

  GstPropsEntry *entry;

  GstCaps *new_caps;

  GList *caps = NULL;

  props = wavparse->metadata->properties;

  while (len > 0) {

    got_bytes =

        gst_bytestream_peek_bytes (bs, &tempdata, sizeof (gst_riff_chunk));

    if (got_bytes != sizeof (gst_riff_chunk)) {

      return;

    }

    temp_chunk = (gst_riff_chunk *) tempdata;

    chunk.id = GUINT32_FROM_LE (temp_chunk->id);

    chunk.size = GUINT32_FROM_LE (temp_chunk->size);

    if (chunk.size == 0) {

      gst_bytestream_flush (bs, sizeof (gst_riff_chunk));

      len -= sizeof (gst_riff_chunk);

      continue;

    }

    switch (chunk.id) {

      case GST_RIFF_adtl_labl:

        got_bytes =

            gst_bytestream_peek_bytes (bs, &tempdata,

            sizeof (struct _gst_riff_labl));

        if (got_bytes != sizeof (struct _gst_riff_labl)) {

          return;

        }

        temp_labl = (struct _gst_riff_labl *) tempdata;

        labl.id = GUINT32_FROM_LE (temp_labl->id);

        labl.size = GUINT32_FROM_LE (temp_labl->size);

        labl.identifier = GUINT32_FROM_LE (temp_labl->identifier);

        gst_bytestream_flush (bs, sizeof (struct _gst_riff_labl));

        len -= sizeof (struct _gst_riff_labl);

        got_bytes = gst_bytestream_peek_bytes (bs, &tempdata, labl.size - 4);

        if (got_bytes != labl.size - 4) {

          return;

        }

        label_name = (char *) tempdata;

        gst_bytestream_flush (bs, ((labl.size - 4) + 1) & ~1);

        len -= (((labl.size - 4) + 1) & ~1);

        new_caps = gst_caps_new ("label",

            "application/x-gst-metadata",

            gst_props_new ("identifier", G_TYPE_INT (labl.identifier),

                "name", G_TYPE_STRING (label_name), NULL));

        if (gst_props_get (props, "labels", &caps, NULL)) {

          caps = g_list_append (caps, new_caps);

        } else {

          caps = g_list_append (NULL, new_caps);

          entry = gst_props_entry_new ("labels", GST_PROPS_GLIST (caps));

          gst_props_add_entry (props, entry);

        }

        break;

      case GST_RIFF_adtl_ltxt:

        got_bytes =

            gst_bytestream_peek_bytes (bs, &tempdata,

            sizeof (struct _gst_riff_ltxt));

        if (got_bytes != sizeof (struct _gst_riff_ltxt)) {

          return;

        }

        temp_ltxt = (struct _gst_riff_ltxt *) tempdata;

        ltxt.id = GUINT32_FROM_LE (temp_ltxt->id);

        ltxt.size = GUINT32_FROM_LE (temp_ltxt->size);

        ltxt.identifier = GUINT32_FROM_LE (temp_ltxt->identifier);

        ltxt.length = GUINT32_FROM_LE (temp_ltxt->length);

        ltxt.purpose = GUINT32_FROM_LE (temp_ltxt->purpose);

        ltxt.country = GUINT16_FROM_LE (temp_ltxt->country);

        ltxt.language = GUINT16_FROM_LE (temp_ltxt->language);

        ltxt.dialect = GUINT16_FROM_LE (temp_ltxt->dialect);

        ltxt.codepage = GUINT16_FROM_LE (temp_ltxt->codepage);

        gst_bytestream_flush (bs, sizeof (struct _gst_riff_ltxt));

        len -= sizeof (struct _gst_riff_ltxt);

        if (ltxt.size - 20 > 0) {

          got_bytes = gst_bytestream_peek_bytes (bs, &tempdata, ltxt.size - 20);

          if (got_bytes != ltxt.size - 20) {

            return;

          }

          gst_bytestream_flush (bs, ((ltxt.size - 20) + 1) & ~1);

          len -= (((ltxt.size - 20) + 1) & ~1);

          label_name = (char *) tempdata;

        } else {

          label_name = "";

        }

        new_caps = gst_caps_new ("ltxt",

            "application/x-gst-metadata",

            gst_props_new ("identifier", G_TYPE_INT (ltxt.identifier),

                "name", G_TYPE_STRING (label_name),

                "length", G_TYPE_INT (ltxt.length), NULL));

        if (gst_props_get (props, "ltxts", &caps, NULL)) {

          caps = g_list_append (caps, new_caps);

        } else {

          caps = g_list_append (NULL, new_caps);

          entry = gst_props_entry_new ("ltxts", GST_PROPS_GLIST (caps));

          gst_props_add_entry (props, entry);

        }

        break;

      case GST_RIFF_adtl_note:

        got_bytes =

            gst_bytestream_peek_bytes (bs, &tempdata,

            sizeof (struct _gst_riff_note));

        if (got_bytes != sizeof (struct _gst_riff_note)) {

          return;

        }

        temp_note = (struct _gst_riff_note *) tempdata;

        note.id = GUINT32_FROM_LE (temp_note->id);

        note.size = GUINT32_FROM_LE (temp_note->size);

        note.identifier = GUINT32_FROM_LE (temp_note->identifier);

        gst_bytestream_flush (bs, sizeof (struct _gst_riff_note));

        len -= sizeof (struct _gst_riff_note);

        got_bytes = gst_bytestream_peek_bytes (bs, &tempdata, note.size - 4);

        if (got_bytes != note.size - 4) {

          return;

        }

        gst_bytestream_flush (bs, ((note.size - 4) + 1) & ~1);

        len -= (((note.size - 4) + 1) & ~1);

        label_name = (char *) tempdata;

        new_caps = gst_caps_new ("note",

            "application/x-gst-metadata",

            gst_props_new ("identifier", G_TYPE_INT (note.identifier),

                "name", G_TYPE_STRING (label_name), NULL));

        if (gst_props_get (props, "notes", &caps, NULL)) {

          caps = g_list_append (caps, new_caps);

        } else {

          caps = g_list_append (NULL, new_caps);

          entry = gst_props_entry_new ("notes", GST_PROPS_GLIST (caps));

          gst_props_add_entry (props, entry);

        }

        break;

      default:

        g_print ("Unknown chunk: %" GST_FOURCC_FORMAT "\n",

            GST_FOURCC_ARGS (chunk.id));

        return;

    }

  }

  g_object_notify (G_OBJECT (wavparse), "metadata");

}

static void

gst_wavparse_parse_cues (GstWavParse * wavparse, int len)

{

  guint32 got_bytes;

  GstByteStream *bs = wavparse->bs;

  struct _gst_riff_cue *temp_cue, cue;

  struct _gst_riff_cuepoints *points;

  guint8 *tempdata;

  int i;

  GList *cues = NULL;

  GstPropsEntry *entry;

  while (len > 0) {

    int required;

    got_bytes =

        gst_bytestream_peek_bytes (bs, &tempdata,

        sizeof (struct _gst_riff_cue));

    temp_cue = (struct _gst_riff_cue *) tempdata;

    /* fixup for our big endian friends */

    cue.id = GUINT32_FROM_LE (temp_cue->id);

    cue.size = GUINT32_FROM_LE (temp_cue->size);

    cue.cuepoints = GUINT32_FROM_LE (temp_cue->cuepoints);

    gst_bytestream_flush (bs, sizeof (struct _gst_riff_cue));

    if (got_bytes != sizeof (struct _gst_riff_cue)) {

      return;

    }

    len -= sizeof (struct _gst_riff_cue);

    /* -4 because cue.size contains the cuepoints size

       and we've already flushed that out of the system */

    required = cue.size - 4;

    got_bytes = gst_bytestream_peek_bytes (bs, &tempdata, required);

    gst_bytestream_flush (bs, ((required) + 1) & ~1);

    if (got_bytes != required) {

      return;

    }

    len -= (((cue.size - 4) + 1) & ~1);

    /* now we have an array of struct _gst_riff_cuepoints in tempdata */

    points = (struct _gst_riff_cuepoints *) tempdata;

    for (i = 0; i < cue.cuepoints; i++) {

      GstCaps *caps;

      caps = gst_caps_new ("cues",

          "application/x-gst-metadata",

          gst_props_new ("identifier", G_TYPE_INT (points[i].identifier),

              "position", G_TYPE_INT (points[i].offset), NULL));

      cues = g_list_append (cues, caps);

    }

    entry = gst_props_entry_new ("cues", GST_PROPS_GLIST (cues));

    gst_props_add_entry (wavparse->metadata->properties, entry);

  }

  g_object_notify (G_OBJECT (wavparse), "metadata");

}

/* Read 'fmt ' header */