/* GStreamer

 * Copyright (C) 2005 Wim Taymans <wim@fluendo.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:gstringbuffer

 * @short_description: Base class for audio ringbuffer implementations

 * @see_also: #GstBaseAudioSink, #GstAudioSink

 *

 * <refsect2>

 * <para>

 * This object is the base class for audio ringbuffers used by the base

 * audio source and sink classes.

 * </para>

 * <para>

 * The ringbuffer abstracts a circular buffer of data. One reader and

 * one writer can operate on the data from different threads in a lockfree

 * manner. The base class is sufficiently flexible to be used as an

 * abstraction for DMA based ringbuffers as well as a pure software

 * implementations.

 * </para>

 * </refsect2>

 *

 * Last reviewed on 2006-02-02 (0.10.4)

 */

#include <string.h>

#include "gstringbuffer.h"

GST_DEBUG_CATEGORY_STATIC (gst_ring_buffer_debug);

#define GST_CAT_DEFAULT gst_ring_buffer_debug

static void gst_ring_buffer_class_init (GstRingBufferClass * klass);

static void gst_ring_buffer_init (GstRingBuffer * ringbuffer);

static void gst_ring_buffer_dispose (GObject * object);

static void gst_ring_buffer_finalize (GObject * object);

static gboolean gst_ring_buffer_pause_unlocked (GstRingBuffer * buf);

static GstObjectClass *parent_class = NULL;

/* ringbuffer abstract base class */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GType

gst_ring_buffer_get_type (void)

{

  static GType ringbuffer_type = 0;

  if (G_UNLIKELY (!ringbuffer_type)) {

    static const GTypeInfo ringbuffer_info = {

      sizeof (GstRingBufferClass),

      NULL,

      NULL,

      (GClassInitFunc) gst_ring_buffer_class_init,

      NULL,

      NULL,

      sizeof (GstRingBuffer),

      0,

      (GInstanceInitFunc) gst_ring_buffer_init,

      NULL

    };

    ringbuffer_type = g_type_register_static (GST_TYPE_OBJECT, "GstRingBuffer",

        &ringbuffer_info, G_TYPE_FLAG_ABSTRACT);

    GST_DEBUG_CATEGORY_INIT (gst_ring_buffer_debug, "ringbuffer", 0,

        "ringbuffer class");

  }

  return ringbuffer_type;

}

static void

gst_ring_buffer_class_init (GstRingBufferClass * klass)

{

  GObjectClass *gobject_class;

  GstObjectClass *gstobject_class;

  gobject_class = (GObjectClass *) klass;

  gstobject_class = (GstObjectClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_ring_buffer_dispose);

  gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_ring_buffer_finalize);

}

static void

gst_ring_buffer_init (GstRingBuffer * ringbuffer)

{

  ringbuffer->open = FALSE;

  ringbuffer->acquired = FALSE;

  ringbuffer->state = GST_RING_BUFFER_STATE_STOPPED;

  ringbuffer->cond = g_cond_new ();

  ringbuffer->waiting = 0;

  ringbuffer->empty_seg = NULL;

  ringbuffer->abidata.ABI.flushing = TRUE;

}

static void

gst_ring_buffer_dispose (GObject * object)

{

  GstRingBuffer *ringbuffer = GST_RING_BUFFER (object);

  gst_caps_replace (&ringbuffer->spec.caps, NULL);

  G_OBJECT_CLASS (parent_class)->dispose (G_OBJECT (ringbuffer));

}

static void

gst_ring_buffer_finalize (GObject * object)

{

  GstRingBuffer *ringbuffer = GST_RING_BUFFER (object);

  g_cond_free (ringbuffer->cond);

  g_free (ringbuffer->empty_seg);

  G_OBJECT_CLASS (parent_class)->finalize (G_OBJECT (ringbuffer));

}

typedef struct

{

  const GstBufferFormat format;

  const guint8 silence[4];

} FormatDef;

static const FormatDef linear_defs[4 * 2 * 2] = {

  {GST_S8, {0x00, 0x00, 0x00, 0x00}},

  {GST_S8, {0x00, 0x00, 0x00, 0x00}},

  {GST_U8, {0x80, 0x80, 0x80, 0x80}},

  {GST_U8, {0x80, 0x80, 0x80, 0x80}},

  {GST_S16_LE, {0x00, 0x00, 0x00, 0x00}},

  {GST_S16_BE, {0x00, 0x00, 0x00, 0x00}},

  {GST_U16_LE, {0x00, 0x80, 0x00, 0x80}},

  {GST_U16_BE, {0x80, 0x00, 0x80, 0x00}},

  {GST_S24_LE, {0x00, 0x00, 0x00, 0x00}},

  {GST_S24_BE, {0x00, 0x00, 0x00, 0x00}},

  {GST_U24_LE, {0x00, 0x00, 0x80, 0x00}},

  {GST_U24_BE, {0x80, 0x00, 0x00, 0x00}},

  {GST_S32_LE, {0x00, 0x00, 0x00, 0x00}},

  {GST_S32_BE, {0x00, 0x00, 0x00, 0x00}},

  {GST_U32_LE, {0x00, 0x00, 0x00, 0x80}},

  {GST_U32_BE, {0x80, 0x00, 0x00, 0x00}}

};

static const FormatDef linear24_defs[3 * 2 * 2] = {

  {GST_S24_3LE, {0x00, 0x00, 0x00, 0x00}},

  {GST_S24_3BE, {0x00, 0x00, 0x00, 0x00}},

  {GST_U24_3LE, {0x00, 0x00, 0x80, 0x00}},

  {GST_U24_3BE, {0x80, 0x00, 0x00, 0x00}},

  {GST_S20_3LE, {0x00, 0x00, 0x00, 0x00}},

  {GST_S20_3BE, {0x00, 0x00, 0x00, 0x00}},

  {GST_U20_3LE, {0x00, 0x00, 0x08, 0x00}},

  {GST_U20_3BE, {0x08, 0x00, 0x00, 0x00}},

  {GST_S18_3LE, {0x00, 0x00, 0x00, 0x00}},

  {GST_S18_3BE, {0x00, 0x00, 0x00, 0x00}},

  {GST_U18_3LE, {0x00, 0x00, 0x02, 0x00}},

  {GST_U18_3BE, {0x02, 0x00, 0x00, 0x00}}

};

static const FormatDef *

build_linear_format (int depth, int width, int unsignd, int big_endian)

{

  const FormatDef *formats;

  if (width == 24) {

    switch (depth) {

      case 24:

        formats = &linear24_defs[0];

        break;

      case 20:

        formats = &linear24_defs[4];

        break;

      case 18:

        formats = &linear24_defs[8];

        break;

      default:

        return NULL;

    }

  } else {

    switch (depth) {

      case 8:

        formats = &linear_defs[0];

        break;

      case 16:

        formats = &linear_defs[4];

        break;

      case 24:

        formats = &linear_defs[8];

        break;

      case 32:

        formats = &linear_defs[12];

        break;

      default:

        return NULL;

    }

  }

  if (unsignd)

    formats += 2;

  if (big_endian)

    formats += 1;

  return formats;

}

/**

 * gst_ring_buffer_debug_spec_caps:

 * @spec: the spec to debug

 *

 * Print debug info about the parsed caps in @spec to the debug log.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_ring_buffer_debug_spec_caps (GstRingBufferSpec * spec)

{

  gint i, bytes;

  GST_DEBUG ("spec caps: %p %" GST_PTR_FORMAT, spec->caps, spec->caps);

  GST_DEBUG ("parsed caps: type:         %d", spec->type);

  GST_DEBUG ("parsed caps: format:       %d", spec->format);

  GST_DEBUG ("parsed caps: width:        %d", spec->width);

  GST_DEBUG ("parsed caps: depth:        %d", spec->depth);

  GST_DEBUG ("parsed caps: sign:         %d", spec->sign);

  GST_DEBUG ("parsed caps: bigend:       %d", spec->bigend);

  GST_DEBUG ("parsed caps: rate:         %d", spec->rate);

  GST_DEBUG ("parsed caps: channels:     %d", spec->channels);

  GST_DEBUG ("parsed caps: sample bytes: %d", spec->bytes_per_sample);

  bytes = (spec->width >> 3) * spec->channels;

  for (i = 0; i < bytes; i++) {

    GST_DEBUG ("silence byte %d: %02x", i, spec->silence_sample[i]);

  }

}

/**

 * gst_ring_buffer_debug_spec_buff:

 * @spec: the spec to debug

 *

 * Print debug info about the buffer sized in @spec to the debug log.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_ring_buffer_debug_spec_buff (GstRingBufferSpec * spec)

{

  GST_DEBUG ("acquire ringbuffer: buffer time: %" G_GINT64_FORMAT " usec",

      spec->buffer_time);

  GST_DEBUG ("acquire ringbuffer: latency time: %" G_GINT64_FORMAT " usec",

      spec->latency_time);

  GST_DEBUG ("acquire ringbuffer: total segments: %d", spec->segtotal);

  GST_DEBUG ("acquire ringbuffer: segment size: %d bytes = %d samples",

      spec->segsize, spec->segsize / spec->bytes_per_sample);

  GST_DEBUG ("acquire ringbuffer: buffer size: %d bytes = %d samples",

      spec->segsize * spec->segtotal,

      spec->segsize * spec->segtotal / spec->bytes_per_sample);

}

/**

 * gst_ring_buffer_parse_caps:

 * @spec: a spec

 * @caps: a #GstCaps

 *

 * Parse @caps into @spec.

 *

 * Returns: TRUE if the caps could be parsed.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_ring_buffer_parse_caps (GstRingBufferSpec * spec, GstCaps * caps)

{

  const gchar *mimetype;

  GstStructure *structure;

  gint i;

  structure = gst_caps_get_structure (caps, 0);

  /* we have to differentiate between int and float formats */

  mimetype = gst_structure_get_name (structure);

  if (!strncmp (mimetype, "audio/x-raw-int", 15)) {

    gint endianness;

    const FormatDef *def;

    gint j, bytes;

    spec->type = GST_BUFTYPE_LINEAR;

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &spec->rate) &&

            gst_structure_get_int (structure, "channels", &spec->channels) &&

            gst_structure_get_int (structure, "width", &spec->width) &&

            gst_structure_get_int (structure, "depth", &spec->depth) &&

            gst_structure_get_boolean (structure, "signed", &spec->sign)))

      goto parse_error;

    /* extract endianness if needed */

    if (spec->width > 8) {

      if (!gst_structure_get_int (structure, "endianness", &endianness))

        goto parse_error;

    } else {

      endianness = G_BYTE_ORDER;

    }

    spec->bigend = endianness == G_LITTLE_ENDIAN ? FALSE : TRUE;

    def = build_linear_format (spec->depth, spec->width, spec->sign ? 0 : 1,

        spec->bigend ? 1 : 0);

    if (def == NULL)

      goto parse_error;

    spec->format = def->format;

    bytes = spec->width >> 3;

    for (i = 0; i < spec->channels; i++) {

      for (j = 0; j < bytes; j++) {

        spec->silence_sample[i * bytes + j] = def->silence[j];

      }

    }

  } else if (!strncmp (mimetype, "audio/x-raw-float", 17)) {

    spec->type = GST_BUFTYPE_FLOAT;

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &spec->rate) &&

            gst_structure_get_int (structure, "channels", &spec->channels) &&

            gst_structure_get_int (structure, "width", &spec->width)))

      goto parse_error;

    /* match layout to format wrt to endianness */

    switch (spec->width) {

      case 32:

        spec->format =

            G_BYTE_ORDER == G_LITTLE_ENDIAN ? GST_FLOAT32_LE : GST_FLOAT32_BE;

        break;

      case 64:

        spec->format =

            G_BYTE_ORDER == G_LITTLE_ENDIAN ? GST_FLOAT64_LE : GST_FLOAT64_BE;

        break;

      default:

        goto parse_error;

    }

    /* float silence is all zeros.. */

    memset (spec->silence_sample, 0, 32);

  } else if (!strncmp (mimetype, "audio/x-alaw", 12)) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &spec->rate) &&

            gst_structure_get_int (structure, "channels", &spec->channels)))

      goto parse_error;

    spec->type = GST_BUFTYPE_A_LAW;

    spec->format = GST_A_LAW;

    spec->width = 8;

    spec->depth = 8;

    for (i = 0; i < spec->channels; i++)

      spec->silence_sample[i] = 0xd5;

  } else if (!strncmp (mimetype, "audio/x-mulaw", 13)) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &spec->rate) &&

            gst_structure_get_int (structure, "channels", &spec->channels)))

      goto parse_error;

    spec->type = GST_BUFTYPE_MU_LAW;

    spec->format = GST_MU_LAW;

    spec->width = 8;

    spec->depth = 8;

    for (i = 0; i < spec->channels; i++)

      spec->silence_sample[i] = 0xff;

  } else if (!strncmp (mimetype, "audio/x-iec958", 14)) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &spec->rate)))

      goto parse_error;

    spec->type = GST_BUFTYPE_IEC958;

    spec->format = GST_IEC958;

    spec->width = 16;

    spec->depth = 16;

    spec->channels = 2;

  } else if (!strncmp (mimetype, "audio/x-ac3", 11)) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &spec->rate)))

      goto parse_error;

    spec->type = GST_BUFTYPE_AC3;

    spec->format = GST_AC3;

    spec->width = 16;

    spec->depth = 16;

    spec->channels = 2;

  } else {

    goto parse_error;

  }

  spec->bytes_per_sample = (spec->width >> 3) * spec->channels;

  gst_caps_replace (&spec->caps, caps);

  g_return_val_if_fail (spec->latency_time != 0, FALSE);

  /* calculate suggested segsize and segtotal. segsize should be one unit

   * of 'latency_time' samples, scaling for the fact that latency_time is

   * currently stored in microseconds (FIXME: in 0.11) */

  spec->segsize = gst_util_uint64_scale (spec->rate * spec->bytes_per_sample,

      spec->latency_time, GST_SECOND / GST_USECOND);

  /* Round to an integer number of samples */

  spec->segsize -= spec->segsize % spec->bytes_per_sample;

  spec->segtotal = spec->buffer_time / spec->latency_time;

  gst_ring_buffer_debug_spec_caps (spec);

  gst_ring_buffer_debug_spec_buff (spec);

  return TRUE;

  /* ERRORS */

parse_error:

  {

    GST_DEBUG ("could not parse caps");

    return FALSE;

  }

}

/**

 * gst_ring_buffer_set_callback:

 * @buf: the #GstRingBuffer to set the callback on

 * @cb: the callback to set

 * @user_data: user data passed to the callback

 *

 * Sets the given callback function on the buffer. This function

 * will be called every time a segment has been written to a device.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_ring_buffer_set_callback (GstRingBuffer * buf, GstRingBufferCallback cb,

    gpointer user_data)

{

  g_return_if_fail (GST_IS_RING_BUFFER (buf));

  GST_OBJECT_LOCK (buf);

  buf->callback = cb;

  buf->cb_data = user_data;

  GST_OBJECT_UNLOCK (buf);

}

/**

 * gst_ring_buffer_open_device:

 * @buf: the #GstRingBuffer

 *

 * Open the audio device associated with the ring buffer. Does not perform any

 * setup on the device. You must open the device before acquiring the ring

 * buffer.

 *

 * Returns: TRUE if the device could be opened, FALSE on error.

 *

 * MT safe.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_ring_buffer_open_device (GstRingBuffer * buf)

{

  gboolean res = TRUE;

  GstRingBufferClass *rclass;

  g_return_val_if_fail (GST_IS_RING_BUFFER (buf), FALSE);

  GST_DEBUG_OBJECT (buf, "opening device");

  GST_OBJECT_LOCK (buf);

  if (G_UNLIKELY (buf->open))

    goto was_opened;

  buf->open = TRUE;

  /* if this fails, something is wrong in this file */

  g_assert (!buf->acquired);

  rclass = GST_RING_BUFFER_GET_CLASS (buf);

  if (G_LIKELY (rclass->open_device))

    res = rclass->open_device (buf);

  if (G_UNLIKELY (!res))

    goto open_failed;

  GST_DEBUG_OBJECT (buf, "opened device");

done:

  GST_OBJECT_UNLOCK (buf);

  return res;

  /* ERRORS */