/* GStreamer

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

 * Copyright (C) 2005 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.

 */

/* TODO:

 *

 *  - in ::start(), we want to post a tags message with an array or a list

 *    of tagslists of all tracks, so that applications know at least the

 *    number of tracks and all track durations immediately without having

 *    to do any querying. We have to decide what type and name to use for

 *    this array of track taglists.

 *

 *  - FIX cddb discid calculation algorithm for mixed mode CDs - do we use

 *    offsets and duration of ALL tracks (data + audio) for the CDDB ID

 *    calculation, or only audio tracks?

 *

 *  - Do we really need properties for the TOC bias/offset stuff? Wouldn't

 *    environment variables make much more sense? Do we need this at all

 *    (does it only affect ancient hardware?)

 */

/**

 * SECTION:gstcddabasesrc

 * @short_description: Base class for CD digital audio (CDDA) sources

 *

 * <refsect2>

 * <para>

 * Provides a base class for CDDA sources, which handles things like seeking,

 * querying, discid calculation, tags, and buffer timestamping.

 * </para>

 * <title>Using GstCddaBaseSrc-based elements in applications</title>

 * <para>

 * GstCddaBaseSrc registers two #GstFormat<!-- -->s of its own, namely

 * the "track" format and the "sector" format. Applications will usually

 * only find the "track" format interesting. You can retrieve that #GstFormat

 * for use in seek events or queries with gst_format_get_by_nick("track").

 * </para>

 * <para>

 * In order to query the number of tracks, for example, an application would

 * set the CDDA source element to READY or PAUSED state and then query the

 * the number of tracks via gst_element_query_duration() using the track

 * format acquired above. Applications can query the currently playing track

 * in the same way.

 * </para>

 * <para>

 * Alternatively, applications may retrieve the currently playing track and

 * the total number of tracks from the taglist that will posted on the bus

 * whenever the CD is opened or the currently playing track changes. The

 * taglist will contain GST_TAG_TRACK_NUMBER and GST_TAG_TRACK_COUNT tags.

 * </para>

 * <para>

 * Applications playing back CD audio using playbin and cdda://n URIs should

 * issue a seek command in track format to change between tracks, rather than

 * setting a new cdda://n+1 URI on playbin (as setting a new URI on playbin

 * involves closing and re-opening the CD device, which is much much slower).

 * </para>

 * <title>Tags and meta-information</title>

 * <para>

 * CDDA sources will automatically emit a number of tags, details about which

 * can be found in the libgsttag documentation. Those tags are:

 * #GST_TAG_CDDA_CDDB_DISCID, #GST_TAG_CDDA_CDDB_DISCID_FULL,

 * #GST_TAG_CDDA_MUSICBRAINZ_DISCID, #GST_TAG_CDDA_MUSICBRAINZ_DISCID_FULL,

 * among others.

 * </para>

 * </refsect2>

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <stdlib.h>             /* for strtol */

#include "gstcddabasesrc.h"

#include "gst/gst-i18n-plugin.h"

GST_DEBUG_CATEGORY_STATIC (gst_cdda_base_src_debug);

#define GST_CAT_DEFAULT gst_cdda_base_src_debug

#define DEFAULT_DEVICE                       "/dev/cdrom"

#define CD_FRAMESIZE_RAW                     (2352)

#define SECTORS_PER_SECOND                   (75)

#define SECTORS_PER_MINUTE                   (75*60)

#define SAMPLES_PER_SECTOR                   (CD_FRAMESIZE_RAW >> 2)

#define TIME_INTERVAL_FROM_SECTORS(sectors)  ((SAMPLES_PER_SECTOR * sectors * GST_SECOND) / 44100)

#define SECTORS_FROM_TIME_INTERVAL(dtime)    (dtime * 44100 / (SAMPLES_PER_SECTOR * GST_SECOND))

enum

{

  ARG_0,

  ARG_MODE,

  ARG_DEVICE,

  ARG_TRACK,

  ARG_TOC_OFFSET,

  ARG_TOC_BIAS

};

static void gst_cdda_base_src_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static void gst_cdda_base_src_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_cdda_base_src_finalize (GObject * obj);

static const GstQueryType *gst_cdda_base_src_get_query_types (GstPad * pad);

static gboolean gst_cdda_base_src_query (GstBaseSrc * src, GstQuery * query);

static gboolean gst_cdda_base_src_handle_event (GstBaseSrc * basesrc,

    GstEvent * event);

static gboolean gst_cdda_base_src_do_seek (GstBaseSrc * basesrc,

    GstSegment * segment);

static void gst_cdda_base_src_setup_interfaces (GType type);

static gboolean gst_cdda_base_src_start (GstBaseSrc * basesrc);

static gboolean gst_cdda_base_src_stop (GstBaseSrc * basesrc);

static GstFlowReturn gst_cdda_base_src_create (GstPushSrc * pushsrc,

    GstBuffer ** buf);

static gboolean gst_cdda_base_src_is_seekable (GstBaseSrc * basesrc);

static void gst_cdda_base_src_update_duration (GstCddaBaseSrc * src);

static void gst_cdda_base_src_set_index (GstElement * src, GstIndex * index);

static GstIndex *gst_cdda_base_src_get_index (GstElement * src);

GST_BOILERPLATE_FULL (GstCddaBaseSrc, gst_cdda_base_src, GstPushSrc,

    GST_TYPE_PUSH_SRC, gst_cdda_base_src_setup_interfaces);

#define SRC_CAPS \

  "audio/x-raw-int, "               \

  "endianness = (int) BYTE_ORDER, " \

  "signed = (boolean) true, "       \

  "width = (int) 16, "              \

  "depth = (int) 16, "              \

  "rate = (int) 44100, "            \

  "channels = (int) 2"              \

static GstStaticPadTemplate gst_cdda_base_src_src_template =

GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS (SRC_CAPS)

    );

/* our two formats */

static GstFormat track_format;

static GstFormat sector_format;

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GType

gst_cdda_base_src_mode_get_type (void)

{

  static GType mode_type;       /* 0 */

  static const GEnumValue modes[] = {

    {GST_CDDA_BASE_SRC_MODE_NORMAL, "Stream consists of a single track",

        "normal"},

    {GST_CDDA_BASE_SRC_MODE_CONTINUOUS, "Stream consists of the whole disc",

        "continuous"},

    {0, NULL, NULL}

  };

  if (mode_type == 0)

    mode_type = g_enum_register_static ("GstCddaBaseSrcMode", modes);

  return mode_type;

}

static void

gst_cdda_base_src_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&gst_cdda_base_src_src_template));

  /* our very own formats */

  track_format = gst_format_register ("track", "CD track");

  sector_format = gst_format_register ("sector", "CD sector");

  /* register CDDA tags */

  gst_tag_register_musicbrainz_tags ();

#if 0

  ///// FIXME: what type to use here? ///////

  gst_tag_register (GST_TAG_CDDA_TRACK_TAGS, GST_TAG_FLAG_META, GST_TYPE_TAG_LIST, "track-tags", "CDDA taglist for one track", gst_tag_merge_use_first);        ///////////// FIXME: right function??? ///////

#endif

  GST_DEBUG_CATEGORY_INIT (gst_cdda_base_src_debug, "cddabasesrc", 0,

      "CDDA Base Source");

}

static void

gst_cdda_base_src_class_init (GstCddaBaseSrcClass * klass)

{

  GstElementClass *element_class;

  GstPushSrcClass *pushsrc_class;

  GstBaseSrcClass *basesrc_class;

  GObjectClass *gobject_class;

  gobject_class = (GObjectClass *) klass;

  element_class = (GstElementClass *) klass;

  basesrc_class = (GstBaseSrcClass *) klass;

  pushsrc_class = (GstPushSrcClass *) klass;

  gobject_class->set_property = gst_cdda_base_src_set_property;

  gobject_class->get_property = gst_cdda_base_src_get_property;

  gobject_class->finalize = gst_cdda_base_src_finalize;

  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DEVICE,

      g_param_spec_string ("device", "Device", "CD device location",

          NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MODE,

      g_param_spec_enum ("mode", "Mode", "Mode", GST_TYPE_CDDA_BASE_SRC_MODE,

          GST_CDDA_BASE_SRC_MODE_NORMAL,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TRACK,

      g_param_spec_uint ("track", "Track", "Track", 1, 99, 1,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

#if 0

  /* Do we really need this toc adjustment stuff as properties? does the user

   * have a chance to set it in practice, e.g. when using sound-juicer, rb,

   * totem, whatever? Shouldn't we rather use environment variables

   * for this? (tpm) */

  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TOC_OFFSET,

      g_param_spec_int ("toc-offset", "Table of contents offset",

          "Add <n> sectors to the values reported", G_MININT, G_MAXINT, 0,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TOC_BIAS,

      g_param_spec_boolean ("toc-bias", "Table of contents bias",

          "Assume that the beginning offset of track 1 as reported in the TOC "

          "will be addressed as LBA 0.  Necessary for some Toshiba drives to "

          "get track boundaries", FALSE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

#endif

  element_class->set_index = GST_DEBUG_FUNCPTR (gst_cdda_base_src_set_index);

  element_class->get_index = GST_DEBUG_FUNCPTR (gst_cdda_base_src_get_index);

  basesrc_class->start = GST_DEBUG_FUNCPTR (gst_cdda_base_src_start);

  basesrc_class->stop = GST_DEBUG_FUNCPTR (gst_cdda_base_src_stop);

  basesrc_class->query = GST_DEBUG_FUNCPTR (gst_cdda_base_src_query);

  basesrc_class->event = GST_DEBUG_FUNCPTR (gst_cdda_base_src_handle_event);

  basesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_cdda_base_src_do_seek);

  basesrc_class->is_seekable =

      GST_DEBUG_FUNCPTR (gst_cdda_base_src_is_seekable);

  pushsrc_class->create = GST_DEBUG_FUNCPTR (gst_cdda_base_src_create);

}

static void

gst_cdda_base_src_init (GstCddaBaseSrc * src, GstCddaBaseSrcClass * klass)

{

  gst_pad_set_query_type_function (GST_BASE_SRC_PAD (src),

      GST_DEBUG_FUNCPTR (gst_cdda_base_src_get_query_types));

  /* we're not live and we operate in time */

  gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);

  gst_base_src_set_live (GST_BASE_SRC (src), FALSE);

  src->device = NULL;

  src->mode = GST_CDDA_BASE_SRC_MODE_NORMAL;

  src->uri_track = -1;

}

static void

gst_cdda_base_src_finalize (GObject * obj)

{

  GstCddaBaseSrc *cddasrc = GST_CDDA_BASE_SRC (obj);

  g_free (cddasrc->uri);

  g_free (cddasrc->device);

  G_OBJECT_CLASS (parent_class)->finalize (obj);

}

static void

gst_cdda_base_src_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (object);

  GST_OBJECT_LOCK (src);

  switch (prop_id) {

    case ARG_MODE:{

      src->mode = g_value_get_enum (value);

      break;

    }

    case ARG_DEVICE:{

      const gchar *dev = g_value_get_string (value);

      g_free (src->device);

      if (dev && *dev) {

        src->device = g_strdup (dev);

      } else {

        src->device = NULL;

      }

      break;

    }

    case ARG_TRACK:{

      guint track = g_value_get_uint (value);

      if (src->num_tracks > 0 && track > src->num_tracks) {

        g_warning ("Invalid track %u", track);

      } else if (track > 0 && src->tracks != NULL) {

        src->cur_sector = src->tracks[track - 1].start;

        src->uri_track = track;

      } else {

        src->uri_track = track; /* seek will be done in start() */

      }

      break;

    }

    case ARG_TOC_OFFSET:{

      src->toc_offset = g_value_get_int (value);

      break;

    }

    case ARG_TOC_BIAS:{

      src->toc_bias = g_value_get_boolean (value);

      break;

    }

    default:{

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

  }

  GST_OBJECT_UNLOCK (src);

}

static void

gst_cdda_base_src_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstCddaBaseSrcClass *klass = GST_CDDA_BASE_SRC_GET_CLASS (object);

  GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (object);

  GST_OBJECT_LOCK (src);

  switch (prop_id) {

    case ARG_MODE:

      g_value_set_enum (value, src->mode);

      break;

    case ARG_DEVICE:{

      if (src->device == NULL && klass->get_default_device != NULL) {

        gchar *d = klass->get_default_device (src);

        if (d != NULL) {

          g_value_set_string (value, DEFAULT_DEVICE);

          g_free (d);

          break;

        }

      }

      if (src->device == NULL)

        g_value_set_string (value, DEFAULT_DEVICE);

      else

        g_value_set_string (value, src->device);

      break;

    }

    case ARG_TRACK:{

      if (src->num_tracks <= 0 && src->uri_track > 0) {

        g_value_set_uint (value, src->uri_track);

      } else {

        g_value_set_uint (value, src->cur_track + 1);

      }

      break;

    }

    case ARG_TOC_OFFSET:

      g_value_set_int (value, src->toc_offset);

      break;

    case ARG_TOC_BIAS:

      g_value_set_boolean (value, src->toc_bias);

      break;

    default:{

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

  }

  GST_OBJECT_UNLOCK (src);

}

static gint

gst_cdda_base_src_get_track_from_sector (GstCddaBaseSrc * src, gint sector)

{

  gint i;

  for (i = 0; i < src->num_tracks; ++i) {

    if (sector >= src->tracks[i].start && sector <= src->tracks[i].end)

      return i;

  }

  return -1;

}

static const GstQueryType *

gst_cdda_base_src_get_query_types (GstPad * pad)

{

  static const GstQueryType src_query_types[] = {

    GST_QUERY_DURATION,

    GST_QUERY_POSITION,

    GST_QUERY_CONVERT,

    0

  };

  return src_query_types;

}

static gboolean

gst_cdda_base_src_convert (GstCddaBaseSrc * src, GstFormat src_format,

    gint64 src_val, GstFormat dest_format, gint64 * dest_val)

{

  gboolean started;

  GST_LOG_OBJECT (src, "converting value %" G_GINT64_FORMAT " from %s into %s",

      src_val, gst_format_get_name (src_format),

      gst_format_get_name (dest_format));

  if (src_format == dest_format) {

    *dest_val = src_val;

    return TRUE;

  }

  started = GST_OBJECT_FLAG_IS_SET (GST_BASE_SRC (src), GST_BASE_SRC_STARTED);

  if (src_format == track_format) {

    if (!started)

      goto not_started;

    if (src_val < 0 || src_val >= src->num_tracks) {

      GST_DEBUG_OBJECT (src, "track number %d out of bounds", (gint) src_val);

      goto wrong_value;

    }

    src_format = GST_FORMAT_DEFAULT;

    src_val = src->tracks[src_val].start * SAMPLES_PER_SECTOR;

  } else if (src_format == sector_format) {

    src_format = GST_FORMAT_DEFAULT;

    src_val = src_val * SAMPLES_PER_SECTOR;

  }

  if (src_format == dest_format) {

    *dest_val = src_val;

    goto done;

  }

  switch (src_format) {

    case GST_FORMAT_BYTES:

      /* convert to samples (4 bytes per sample) */

      src_val = src_val >> 2;

      /* fallthrough */

    case GST_FORMAT_DEFAULT:{

      switch (dest_format) {

        case GST_FORMAT_BYTES:{

          if (src_val < 0) {

            GST_DEBUG_OBJECT (src, "sample source value negative");

            goto wrong_value;

          }

          *dest_val = src_val << 2;     /* 4 bytes per sample */

          break;

        }

        case GST_FORMAT_TIME:{

          *dest_val = gst_util_uint64_scale_int (src_val, GST_SECOND, 44100);

          break;

        }

        default:{

          gint64 sector = src_val / SAMPLES_PER_SECTOR;

          if (dest_format == sector_format) {

            *dest_val = sector;

          } else if (dest_format == track_format) {

            if (!started)

              goto not_started;

            *dest_val = gst_cdda_base_src_get_track_from_sector (src, sector);

          } else {

            goto unknown_format;

          }

          break;

        }

      }

      break;

    }

    case GST_FORMAT_TIME:{

      gint64 sample_offset;

      if (src_val == GST_CLOCK_TIME_NONE) {

        GST_DEBUG_OBJECT (src, "source time value invalid");

        goto wrong_value;

      }

      sample_offset = gst_util_uint64_scale_int (src_val, 44100, GST_SECOND);

      switch (dest_format) {

        case GST_FORMAT_BYTES:{

          *dest_val = sample_offset << 2;       /* 4 bytes per sample */

          break;

        }

        case GST_FORMAT_DEFAULT:{

          *dest_val = sample_offset;

          break;

        }

        default:{

          gint64 sector = sample_offset / SAMPLES_PER_SECTOR;

          if (dest_format == sector_format) {

            *dest_val = sector;

          } else if (dest_format == track_format) {

            if (!started)

              goto not_started;

            *dest_val = gst_cdda_base_src_get_track_from_sector (src, sector);

          } else {

            goto unknown_format;

          }