/* GStreamer

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

 * Copyright (C) <2006-2007> Jan Schmidt <thaytan@mad.scientist.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.

 */

#ifdef HAVE_CONFIG_H

#include "../../config.h"

#endif

#include <string.h>

#include "gstmpegaudioparse.h"

GST_DEBUG_CATEGORY_STATIC (mp3parse_debug);

#define GST_CAT_DEFAULT mp3parse_debug

#define MP3_CHANNEL_MODE_UNKNOWN -1

#define MP3_CHANNEL_MODE_STEREO 0

#define MP3_CHANNEL_MODE_JOINT_STEREO 1

#define MP3_CHANNEL_MODE_DUAL_CHANNEL 2

#define MP3_CHANNEL_MODE_MONO 3

#define CRC_UNKNOWN -1

#define CRC_PROTECTED 0

#define CRC_NOT_PROTECTED 1

#define XING_FRAMES_FLAG     0x0001

#define XING_BYTES_FLAG      0x0002

#define XING_TOC_FLAG        0x0004

#define XING_VBR_SCALE_FLAG  0x0008

#ifndef GST_READ_UINT24_BE

#define GST_READ_UINT24_BE(p) (p[2] | (p[1] << 8) | (p[0] << 16))

#endif

/* Minimum number of consecutive, valid-looking frames to consider

   for resyncing */

#define MIN_RESYNC_FRAMES 3

static inline MPEGAudioSeekEntry *

mpeg_audio_seek_entry_new ()

{

  return g_slice_new (MPEGAudioSeekEntry);

}

static inline void

mpeg_audio_seek_entry_free (MPEGAudioSeekEntry * entry)

{

  g_slice_free (MPEGAudioSeekEntry, entry);

}

/* elementfactory information */

static GstElementDetails mp3parse_details = {

  "MPEG1 Audio Parser",

  "Codec/Parser/Audio",

  "Parses and frames mpeg1 audio streams (levels 1-3), provides seek",

  "Jan Schmidt <thaytan@mad.scientist.com>\n"

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

};

static GstStaticPadTemplate mp3_src_template = GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("audio/mpeg, "

        "mpegversion = (int) 1, "

        "layer = (int) [ 1, 3 ], "

        "rate = (int) [ 8000, 48000 ], channels = (int) [ 1, 2 ],"

        "parsed=(boolean) true")

    );

static GstStaticPadTemplate mp3_sink_template = GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("audio/mpeg, mpegversion = (int) 1, parsed=(boolean)false")

    );

/* GstMPEGAudioParse signals and args */

enum

{

  /* FILL ME */

  LAST_SIGNAL

};

enum

{

  ARG_0,

  ARG_SKIP,

  ARG_BIT_RATE

      /* FILL ME */

};

static void gst_mp3parse_class_init (GstMPEGAudioParseClass * klass);

static void gst_mp3parse_base_init (gpointer klass);

static void gst_mp3parse_init (GstMPEGAudioParse * mp3parse,

    GstMPEGAudioParseClass * klass);

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

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

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

static const GstQueryType *mp3parse_get_query_types (GstPad * pad);

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

static int head_check (GstMPEGAudioParse * mp3parse, unsigned long head);

static void gst_mp3parse_dispose (GObject * object);

static void gst_mp3parse_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_mp3parse_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static GstStateChangeReturn gst_mp3parse_change_state (GstElement * element,

    GstStateChange transition);

static GstFlowReturn

gst_mp3parse_handle_data (GstMPEGAudioParse * mp3parse, gboolean at_eos);

static gboolean mp3parse_bytepos_to_time (GstMPEGAudioParse * mp3parse,

    gint64 bytepos, GstClockTime * ts, gboolean from_total_time);

static gboolean

mp3parse_total_bytes (GstMPEGAudioParse * mp3parse, gint64 * total);

static gboolean

mp3parse_total_time (GstMPEGAudioParse * mp3parse, GstClockTime * total);

GST_BOILERPLATE (GstMPEGAudioParse, gst_mp3parse, GstElement, GST_TYPE_ELEMENT);

#define GST_TYPE_MP3_CHANNEL_MODE (gst_mp3_channel_mode_get_type())

static const GEnumValue mp3_channel_mode[] = {

  {MP3_CHANNEL_MODE_UNKNOWN, "Unknown", "unknown"},

  {MP3_CHANNEL_MODE_MONO, "Mono", "mono"},

  {MP3_CHANNEL_MODE_DUAL_CHANNEL, "Dual Channel", "dual-channel"},

  {MP3_CHANNEL_MODE_JOINT_STEREO, "Joint Stereo", "joint-stereo"},

  {MP3_CHANNEL_MODE_STEREO, "Stereo", "stereo"},

  {0, NULL, NULL},

};

static GType

gst_mp3_channel_mode_get_type (void)

{

  static GType mp3_channel_mode_type = 0;

  if (!mp3_channel_mode_type) {

    mp3_channel_mode_type =

        g_enum_register_static ("GstMp3ChannelMode", mp3_channel_mode);

  }

  return mp3_channel_mode_type;

}

static const gchar *

gst_mp3_channel_mode_get_nick (gint mode)

{

  guint i;

  for (i = 0; i < G_N_ELEMENTS (mp3_channel_mode); i++) {

    if (mp3_channel_mode[i].value == mode)

      return mp3_channel_mode[i].value_nick;

  }

  return NULL;

}

static const guint mp3types_bitrates[2][3][16] = {

  {

        {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},

        {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},

        {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}

      },

  {

        {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},

        {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},

        {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}

      },

};

static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},

{22050, 24000, 16000},

{11025, 12000, 8000}

};

static inline guint

mp3_type_frame_length_from_header (GstMPEGAudioParse * mp3parse, guint32 header,

    guint * put_version, guint * put_layer, guint * put_channels,

    guint * put_bitrate, guint * put_samplerate, guint * put_mode,

    guint * put_crc)

{

  guint length;

  gulong mode, samplerate, bitrate, layer, channels, padding, crc;

  gulong version;

  gint lsf, mpg25;

  if (header & (1 << 20)) {

    lsf = (header & (1 << 19)) ? 0 : 1;

    mpg25 = 0;

  } else {

    lsf = 1;

    mpg25 = 1;

  }

  version = 1 + lsf + mpg25;

  layer = 4 - ((header >> 17) & 0x3);

  crc = (header >> 16) & 0x1;

  bitrate = (header >> 12) & 0xF;

  bitrate = mp3types_bitrates[lsf][layer - 1][bitrate] * 1000;

  /* The caller has ensured we have a valid header, so bitrate can't be

     zero here. */

  g_assert (bitrate != 0);

  samplerate = (header >> 10) & 0x3;

  samplerate = mp3types_freqs[lsf + mpg25][samplerate];

  padding = (header >> 9) & 0x1;

  mode = (header >> 6) & 0x3;

  channels = (mode == 3) ? 1 : 2;

  switch (layer) {

    case 1:

      length = 4 * ((bitrate * 12) / samplerate + padding);

      break;

    case 2:

      length = (bitrate * 144) / samplerate + padding;

      break;

    default:

    case 3:

      length = (bitrate * 144) / (samplerate << lsf) + padding;

      break;

  }

  GST_DEBUG_OBJECT (mp3parse, "Calculated mp3 frame length of %u bytes",

      length);

  GST_DEBUG_OBJECT (mp3parse, "samplerate = %lu, bitrate = %lu, version = %lu, "

      "layer = %lu, channels = %lu, mode = %s", samplerate, bitrate, version,

      layer, channels, gst_mp3_channel_mode_get_nick (mode));

  if (put_version)

    *put_version = version;

  if (put_layer)

    *put_layer = layer;

  if (put_channels)

    *put_channels = channels;

  if (put_bitrate)

    *put_bitrate = bitrate;

  if (put_samplerate)

    *put_samplerate = samplerate;

  if (put_mode)

    *put_mode = mode;

  if (put_crc)

    *put_crc = crc;

  return length;

}

static GstCaps *

mp3_caps_create (guint version, guint layer, guint channels, guint samplerate)

{

  GstCaps *new;

  g_assert (version);

  g_assert (layer);

  g_assert (samplerate);

  g_assert (channels);

  new = gst_caps_new_simple ("audio/mpeg",

      "mpegversion", G_TYPE_INT, 1,

      "mpegaudioversion", G_TYPE_INT, version,

      "layer", G_TYPE_INT, layer,

      "rate", G_TYPE_INT, samplerate,

      "channels", G_TYPE_INT, channels, "parsed", G_TYPE_BOOLEAN, TRUE, NULL);

  return new;

}

static void

gst_mp3parse_base_init (gpointer klass)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&mp3_sink_template));

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&mp3_src_template));

  GST_DEBUG_CATEGORY_INIT (mp3parse_debug, "mp3parse", 0, "MPEG Audio Parser");

  gst_element_class_set_details (element_class, &mp3parse_details);

}

static void

gst_mp3parse_class_init (GstMPEGAudioParseClass * klass)

{

  GObjectClass *gobject_class;

  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass *) klass;

  gstelement_class = (GstElementClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  gobject_class->set_property = gst_mp3parse_set_property;

  gobject_class->get_property = gst_mp3parse_get_property;

  gobject_class->dispose = gst_mp3parse_dispose;

  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SKIP,

      g_param_spec_int ("skip", "skip", "skip",

          G_MININT, G_MAXINT, 0, G_PARAM_READWRITE));

  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BIT_RATE,

      g_param_spec_int ("bitrate", "Bitrate", "Bit Rate",

          G_MININT, G_MAXINT, 0, G_PARAM_READABLE));

  gstelement_class->change_state = gst_mp3parse_change_state;

/* register tags */

#define GST_TAG_CRC    "has-crc"

#define GST_TAG_MODE     "channel-mode"

  gst_tag_register (GST_TAG_CRC, GST_TAG_FLAG_META, G_TYPE_BOOLEAN,

      "has crc", "Using CRC", NULL);

  gst_tag_register (GST_TAG_MODE, GST_TAG_FLAG_ENCODED, G_TYPE_STRING,

      "channel mode", "MPEG audio channel mode", NULL);

  g_type_class_ref (GST_TYPE_MP3_CHANNEL_MODE);

}

static void

gst_mp3parse_reset (GstMPEGAudioParse * mp3parse)

{

  mp3parse->skip = 0;

  mp3parse->resyncing = TRUE;

  mp3parse->next_ts = GST_CLOCK_TIME_NONE;

  mp3parse->cur_offset = -1;

  mp3parse->sync_offset = 0;

  mp3parse->tracked_offset = 0;

  mp3parse->pending_ts = GST_CLOCK_TIME_NONE;

  mp3parse->pending_offset = -1;

  gst_adapter_clear (mp3parse->adapter);

  mp3parse->rate = mp3parse->channels = mp3parse->layer = -1;

  mp3parse->version = 1;

  mp3parse->max_bitreservoir = GST_CLOCK_TIME_NONE;

  mp3parse->avg_bitrate = 0;

  mp3parse->bitrate_sum = 0;

  mp3parse->last_posted_bitrate = 0;

  mp3parse->frame_count = 0;

  mp3parse->sent_codec_tag = FALSE;

  mp3parse->last_posted_crc = CRC_UNKNOWN;

  mp3parse->last_posted_channel_mode = MP3_CHANNEL_MODE_UNKNOWN;

  mp3parse->xing_flags = 0;

  mp3parse->xing_bitrate = 0;

  mp3parse->xing_frames = 0;

  mp3parse->xing_total_time = 0;

  mp3parse->xing_bytes = 0;

  mp3parse->xing_vbr_scale = 0;

  memset (mp3parse->xing_seek_table, 0, 100);

  memset (mp3parse->xing_seek_table_inverse, 0, 256);

  mp3parse->vbri_bitrate = 0;

  mp3parse->vbri_frames = 0;

  mp3parse->vbri_total_time = 0;

  mp3parse->vbri_bytes = 0;

  mp3parse->vbri_seek_points = 0;

  g_free (mp3parse->vbri_seek_table);

  mp3parse->vbri_seek_table = NULL;

  if (mp3parse->seek_table) {

    g_list_foreach (mp3parse->seek_table, (GFunc) mpeg_audio_seek_entry_free,

        NULL);

    g_list_free (mp3parse->seek_table);

    mp3parse->seek_table = NULL;

  }

  g_mutex_lock (mp3parse->pending_seeks_lock);

  if (mp3parse->pending_accurate_seeks) {

    g_slist_foreach (mp3parse->pending_accurate_seeks, (GFunc) g_free, NULL);

    g_slist_free (mp3parse->pending_accurate_seeks);

    mp3parse->pending_accurate_seeks = NULL;

  }

  if (mp3parse->pending_nonaccurate_seeks) {

    g_slist_foreach (mp3parse->pending_nonaccurate_seeks, (GFunc) g_free, NULL);

    g_slist_free (mp3parse->pending_nonaccurate_seeks);

    mp3parse->pending_nonaccurate_seeks = NULL;

  }

  g_mutex_unlock (mp3parse->pending_seeks_lock);

  if (mp3parse->pending_segment) {

    GstEvent **eventp = &mp3parse->pending_segment;

    gst_event_replace (eventp, NULL);

  }

  mp3parse->exact_position = FALSE;

  gst_segment_init (&mp3parse->segment, GST_FORMAT_TIME);

}

static void

gst_mp3parse_init (GstMPEGAudioParse * mp3parse, GstMPEGAudioParseClass * klass)

{

  mp3parse->sinkpad =

      gst_pad_new_from_static_template (&mp3_sink_template, "sink");

  gst_pad_set_event_function (mp3parse->sinkpad, gst_mp3parse_sink_event);

  gst_pad_set_chain_function (mp3parse->sinkpad, gst_mp3parse_chain);

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

  mp3parse->srcpad =

      gst_pad_new_from_static_template (&mp3_src_template, "src");

  gst_pad_use_fixed_caps (mp3parse->srcpad);

  gst_pad_set_event_function (mp3parse->srcpad, mp3parse_src_event);

  gst_pad_set_query_function (mp3parse->srcpad, mp3parse_src_query);

  gst_pad_set_query_type_function (mp3parse->srcpad, mp3parse_get_query_types);

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

  mp3parse->adapter = gst_adapter_new ();

  mp3parse->pending_seeks_lock = g_mutex_new ();

  gst_mp3parse_reset (mp3parse);

}

static void

gst_mp3parse_dispose (GObject * object)

{

  GstMPEGAudioParse *mp3parse = GST_MP3PARSE (object);

  gst_mp3parse_reset (mp3parse);

  if (mp3parse->adapter) {

    g_object_unref (mp3parse->adapter);

    mp3parse->adapter = NULL;

  }

  g_mutex_free (mp3parse->pending_seeks_lock);

  mp3parse->pending_seeks_lock = NULL;

  g_list_foreach (mp3parse->pending_events, (GFunc) gst_mini_object_unref,

      NULL);

  g_list_free (mp3parse->pending_events);

  mp3parse->pending_events = NULL;

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

static gboolean

gst_mp3parse_sink_event (GstPad * pad, GstEvent * event)

{

  gboolean res = TRUE;

  GstMPEGAudioParse *mp3parse;

  GstEvent **eventp;

  mp3parse = GST_MP3PARSE (gst_pad_get_parent (pad));

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_NEWSEGMENT:

    {

      gdouble rate, applied_rate;

      GstFormat format;

      gint64 start, stop, pos;

      gboolean update;

      MPEGAudioPendingAccurateSeek *seek = NULL;

      GSList *node;

      gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,

          &format, &start, &stop, &pos);

      g_mutex_lock (mp3parse->pending_seeks_lock);

      if (format == GST_FORMAT_BYTES && mp3parse->pending_accurate_seeks) {

        for (node = mp3parse->pending_accurate_seeks; node; node = node->next) {

          MPEGAudioPendingAccurateSeek *tmp = node->data;

          if (tmp->upstream_start == pos) {

            seek = tmp;

            break;

          }

        }

        if (seek) {

          GstSegment *s = &seek->segment;

          event =

              gst_event_new_new_segment_full (FALSE, s->rate, s->applied_rate,

              GST_FORMAT_TIME, s->start, s->stop, s->last_stop);

          mp3parse->segment = seek->segment;

          mp3parse->resyncing = FALSE;

          mp3parse->cur_offset = pos;

          mp3parse->next_ts = seek->timestamp_start;

          mp3parse->pending_ts = GST_CLOCK_TIME_NONE;

          mp3parse->tracked_offset = 0;

          mp3parse->sync_offset = 0;

          gst_event_parse_new_segment_full (event, &update, &rate,

              &applied_rate, &format, &start, &stop, &pos);

          GST_DEBUG_OBJECT (mp3parse,

              "Pushing accurate newseg rate %g, applied rate %g, "

              "format %d, start %" G_GINT64_FORMAT ", stop %" G_GINT64_FORMAT

              ", pos %" G_GINT64_FORMAT, rate, applied_rate, format, start,

              stop, pos);

          g_free (seek);

          mp3parse->pending_accurate_seeks =

              g_slist_delete_link (mp3parse->pending_accurate_seeks, node);

          g_mutex_unlock (mp3parse->pending_seeks_lock);

          res = gst_pad_push_event (mp3parse->srcpad, event);

          return res;

        } else {

          GST_WARNING_OBJECT (mp3parse,

              "Accurate seek not possible, didn't get an appropiate upstream segment");

        }

      }