/* 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., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstaudioringbuffer

 * @title: GstAudioRingBuffer

 * @short_description: Base class for audio ringbuffer implementations

 * @see_also: #GstAudioBaseSink, #GstAudioSink

 *

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

 * audio source and sink classes.

 *

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

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <gst/audio/audio.h>

#include "gstaudioringbuffer.h"

GST_DEBUG_CATEGORY_STATIC (gst_audio_ring_buffer_debug);

#define GST_CAT_DEFAULT gst_audio_ring_buffer_debug

static void gst_audio_ring_buffer_dispose (GObject * object);

static void gst_audio_ring_buffer_finalize (GObject * object);

static gboolean gst_audio_ring_buffer_pause_unlocked (GstAudioRingBuffer * buf);

static void default_clear_all (GstAudioRingBuffer * buf);

static guint default_commit (GstAudioRingBuffer * buf, guint64 * sample,

    guint8 * data, gint in_samples, gint out_samples, gint * accum);

/* ringbuffer abstract base class */

G_DEFINE_ABSTRACT_TYPE (GstAudioRingBuffer, gst_audio_ring_buffer,

    GST_TYPE_OBJECT);

static void

gst_audio_ring_buffer_class_init (GstAudioRingBufferClass * klass)

{

  GObjectClass *gobject_class;

  GstAudioRingBufferClass *gstaudioringbuffer_class;

  gobject_class = (GObjectClass *) klass;

  gstaudioringbuffer_class = (GstAudioRingBufferClass *) klass;

  GST_DEBUG_CATEGORY_INIT (gst_audio_ring_buffer_debug, "ringbuffer", 0,

      "ringbuffer class");

  gobject_class->dispose = gst_audio_ring_buffer_dispose;

  gobject_class->finalize = gst_audio_ring_buffer_finalize;

  gstaudioringbuffer_class->clear_all = GST_DEBUG_FUNCPTR (default_clear_all);

  gstaudioringbuffer_class->commit = GST_DEBUG_FUNCPTR (default_commit);

}

static void

gst_audio_ring_buffer_init (GstAudioRingBuffer * ringbuffer)

{

  ringbuffer->open = FALSE;

  ringbuffer->acquired = FALSE;

  ringbuffer->state = GST_AUDIO_RING_BUFFER_STATE_STOPPED;

  g_cond_init (&ringbuffer->cond);

  ringbuffer->waiting = 0;

  ringbuffer->empty_seg = NULL;

  ringbuffer->flushing = TRUE;

  ringbuffer->segbase = 0;

  ringbuffer->segdone = 0;

}

static void

gst_audio_ring_buffer_dispose (GObject * object)

{

  GstAudioRingBuffer *ringbuffer = GST_AUDIO_RING_BUFFER (object);

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

  G_OBJECT_CLASS (gst_audio_ring_buffer_parent_class)->dispose (G_OBJECT

      (ringbuffer));

}

static void

gst_audio_ring_buffer_finalize (GObject * object)

{

  GstAudioRingBuffer *ringbuffer = GST_AUDIO_RING_BUFFER (object);

  g_cond_clear (&ringbuffer->cond);

  g_free (ringbuffer->empty_seg);

  if (ringbuffer->cb_data_notify != NULL)

    ringbuffer->cb_data_notify (ringbuffer->cb_data);

  G_OBJECT_CLASS (gst_audio_ring_buffer_parent_class)->finalize (G_OBJECT

      (ringbuffer));

}

#ifndef GST_DISABLE_GST_DEBUG

static const gchar *format_type_names[] = {

  "raw",

  "mu law",

  "a law",

  "ima adpcm",

  "mpeg",

  "gsm",

  "iec958",

  "ac3",

  "eac3",

  "dts",

  "aac mpeg2",

  "aac mpeg4",

  "aac mpeg2 raw",

  "aac mpeg4 raw",

  "flac"

};

#endif

/**

 * gst_audio_ring_buffer_debug_spec_caps:

 * @spec: the spec to debug

 *

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

 */

void

gst_audio_ring_buffer_debug_spec_caps (GstAudioRingBufferSpec * spec)

{

#if 0

  gint i, bytes;

#endif

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

  GST_DEBUG ("parsed caps: type:         %d, '%s'", spec->type,

      format_type_names[spec->type]);

#if 0

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

  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]);

  }

#endif

}

/**

 * gst_audio_ring_buffer_debug_spec_buff:

 * @spec: the spec to debug

 *

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

 */

void

gst_audio_ring_buffer_debug_spec_buff (GstAudioRingBufferSpec * spec)

{

  gint bpf = GST_AUDIO_INFO_BPF (&spec->info);

  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: latency segments: %d", spec->seglatency);

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

      spec->segsize, (bpf != 0) ? (spec->segsize / bpf) : -1);

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

      spec->segsize * spec->segtotal,

      (bpf != 0) ? (spec->segsize * spec->segtotal / bpf) : -1);

}

/**

 * gst_audio_ring_buffer_parse_caps:

 * @spec: a spec

 * @caps: a #GstCaps

 *

 * Parse @caps into @spec.

 *

 * Returns: TRUE if the caps could be parsed.

 */

gboolean

gst_audio_ring_buffer_parse_caps (GstAudioRingBufferSpec * spec, GstCaps * caps)

{

  const gchar *mimetype;

  GstStructure *structure;

  gint i;

  GstAudioInfo info;

  structure = gst_caps_get_structure (caps, 0);

  gst_audio_info_init (&info;;

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

  mimetype = gst_structure_get_name (structure);

  if (g_str_equal (mimetype, "audio/x-raw")) {

    if (!gst_audio_info_from_caps (&info, caps))

      goto parse_error;

    spec->type = GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW;

  } else if (g_str_equal (mimetype, "audio/x-alaw")) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &info.rate) &&

            gst_structure_get_int (structure, "channels", &info.channels)))

      goto parse_error;

    if (!(gst_audio_channel_positions_from_mask (info.channels, 0,

                info.position)))

      goto parse_error;

    spec->type = GST_AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW;

    info.bpf = info.channels;

  } else if (g_str_equal (mimetype, "audio/x-mulaw")) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &info.rate) &&

            gst_structure_get_int (structure, "channels", &info.channels)))

      goto parse_error;

    if (!(gst_audio_channel_positions_from_mask (info.channels, 0,

                info.position)))

      goto parse_error;

    spec->type = GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW;

    info.bpf = info.channels;

  } else if (g_str_equal (mimetype, "audio/x-iec958")) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &info.rate)))

      goto parse_error;

    spec->type = GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IEC958;

    info.bpf = 4;

  } else if (g_str_equal (mimetype, "audio/x-ac3")) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &info.rate)))

      goto parse_error;

    gst_structure_get_int (structure, "channels", &info.channels);

    spec->type = GST_AUDIO_RING_BUFFER_FORMAT_TYPE_AC3;

    info.bpf = 4;

  } else if (g_str_equal (mimetype, "audio/x-eac3")) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &info.rate)))

      goto parse_error;

    gst_structure_get_int (structure, "channels", &info.channels);

    spec->type = GST_AUDIO_RING_BUFFER_FORMAT_TYPE_EAC3;

    info.bpf = 16;

  } else if (g_str_equal (mimetype, "audio/x-dts")) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &info.rate)))

      goto parse_error;

    gst_structure_get_int (structure, "channels", &info.channels);

    spec->type = GST_AUDIO_RING_BUFFER_FORMAT_TYPE_DTS;

    info.bpf = 4;

  } else if (g_str_equal (mimetype, "audio/mpeg") &&

      gst_structure_get_int (structure, "mpegaudioversion", &i) &&

      (i == 1 || i == 2 || i == 3)) {

    /* Now we know this is MPEG-1, MPEG-2 or MPEG-2.5 (non AAC) */

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &info.rate)))

      goto parse_error;

    gst_structure_get_int (structure, "channels", &info.channels);

    spec->type = GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG;

    info.bpf = 1;

  } else if (g_str_equal (mimetype, "audio/mpeg") &&

      gst_structure_get_int (structure, "mpegversion", &i) &&

      (i == 2 || i == 4) &&

      (!g_strcmp0 (gst_structure_get_string (structure, "stream-format"),

              "adts")

          || !g_strcmp0 (gst_structure_get_string (structure, "stream-format"),

              "raw"))) {

    /* MPEG-2 AAC or MPEG-4 AAC */

    if (!(gst_structure_get_int (structure, "rate", &info.rate)))

      goto parse_error;

    gst_structure_get_int (structure, "channels", &info.channels);

    if (!g_strcmp0 (gst_structure_get_string (structure, "stream-format"),

            "adts"))

      spec->type = (i == 2) ? GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC :

          GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC;

    else

      spec->type = (i == 2) ?

          GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG2_AAC_RAW :

          GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG4_AAC_RAW;

    info.bpf = 1;

  } else if (g_str_equal (mimetype, "audio/x-flac")) {

    /* extract the needed information from the cap */

    if (!(gst_structure_get_int (structure, "rate", &info.rate)))

      goto parse_error;

    gst_structure_get_int (structure, "channels", &info.channels);

    spec->type = GST_AUDIO_RING_BUFFER_FORMAT_TYPE_FLAC;

    info.bpf = 1;

  } else {

    goto parse_error;

  }

  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 (info.rate * info.bpf,

      spec->latency_time, GST_SECOND / GST_USECOND);

  /* Round to an integer number of samples */

  spec->segsize -= spec->segsize % info.bpf;

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

  /* leave the latency undefined now, implementations can change it but if it's

   * not changed, we assume the same value as segtotal */

  spec->seglatency = -1;

  spec->info = info;

  gst_audio_ring_buffer_debug_spec_caps (spec);

  gst_audio_ring_buffer_debug_spec_buff (spec);

  return TRUE;

  /* ERRORS */

parse_error:

  {

    GST_DEBUG ("could not parse caps");

    return FALSE;

  }

}

/**

 * gst_audio_ring_buffer_convert:

 * @buf: the #GstAudioRingBuffer

 * @src_fmt: the source format

 * @src_val: the source value

 * @dest_fmt: the destination format

 * @dest_val: (out): a location to store the converted value

 *

 * Convert @src_val in @src_fmt to the equivalent value in @dest_fmt. The result

 * will be put in @dest_val.

 *

 * Returns: TRUE if the conversion succeeded.

 */

gboolean

gst_audio_ring_buffer_convert (GstAudioRingBuffer * buf,

    GstFormat src_fmt, gint64 src_val, GstFormat dest_fmt, gint64 * dest_val)

{

  gboolean res;

  GST_OBJECT_LOCK (buf);

  res =

      gst_audio_info_convert (&buf->spec.info, src_fmt, src_val, dest_fmt,

      dest_val);

  GST_OBJECT_UNLOCK (buf);

  return res;

}

/**

 * gst_audio_ring_buffer_set_callback: (skip)

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

 * @cb: (allow-none): 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.

 */

void

gst_audio_ring_buffer_set_callback (GstAudioRingBuffer * buf,

    GstAudioRingBufferCallback cb, gpointer user_data)

{

  gst_audio_ring_buffer_set_callback_full (buf, cb, user_data, NULL);

}

/**

 * gst_audio_ring_buffer_set_callback_full: (rename-to gst_audio_ring_buffer_set_callback)

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

 * @cb: (allow-none): the callback to set

 * @user_data: user data passed to the callback

 * @notify: function to be called when @user_data is no longer needed

 *

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

 *

 * Since: 1.12

 */

void

gst_audio_ring_buffer_set_callback_full (GstAudioRingBuffer * buf,

    GstAudioRingBufferCallback cb, gpointer user_data, GDestroyNotify notify)

{

  gpointer old_data = NULL;

  GDestroyNotify old_notify;

  g_return_if_fail (GST_IS_AUDIO_RING_BUFFER (buf));

  GST_OBJECT_LOCK (buf);

  old_notify = buf->cb_data_notify;

  old_data = buf->cb_data;

  buf->callback = cb;

  buf->cb_data = user_data;

  buf->cb_data_notify = notify;

  GST_OBJECT_UNLOCK (buf);

  if (old_notify) {

    old_notify (old_data);

  }

}

/**

 * gst_audio_ring_buffer_open_device:

 * @buf: the #GstAudioRingBuffer

 *

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

 */

gboolean

gst_audio_ring_buffer_open_device (GstAudioRingBuffer * buf)

{

  gboolean res = TRUE;

  GstAudioRingBufferClass *rclass;

  g_return_val_if_fail (GST_IS_AUDIO_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_AUDIO_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 */

was_opened:

  {

    GST_DEBUG_OBJECT (buf, "Device for ring buffer already open");

    g_warning ("Device for ring buffer %p already open, fix your code", buf);

    res = TRUE;

    goto done;

  }

open_failed:

  {

    buf->open = FALSE;

    GST_DEBUG_OBJECT (buf, "failed opening device");

    goto done;

  }

}

/**

 * gst_audio_ring_buffer_close_device:

 * @buf: the #GstAudioRingBuffer

 *

 * Close the audio device associated with the ring buffer. The ring buffer

 * should already have been released via gst_audio_ring_buffer_release().

 *

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

 *

 * MT safe.

 */

gboolean

gst_audio_ring_buffer_close_device (GstAudioRingBuffer * buf)

{

  gboolean res = TRUE;

  GstAudioRingBufferClass *rclass;

  g_return_val_if_fail (GST_IS_AUDIO_RING_BUFFER (buf), FALSE);

  GST_DEBUG_OBJECT (buf, "closing device");

  GST_OBJECT_LOCK (buf);

  if (G_UNLIKELY (!buf->open))

    goto was_closed;

  if (G_UNLIKELY (buf->acquired))

    goto was_acquired;

  buf->open = FALSE;

  rclass = GST_AUDIO_RING_BUFFER_GET_CLASS (buf);

  if (G_LIKELY (rclass->close_device))

    res = rclass->close_device (buf);

  if (G_UNLIKELY (!res))

    goto close_error;

  GST_DEBUG_OBJECT (buf, "closed device");

done:

  GST_OBJECT_UNLOCK (buf);

  return res;

  /* ERRORS */

was_closed:

  {

    GST_DEBUG_OBJECT (buf, "Device for ring buffer already closed");

    g_warning ("Device for ring buffer %p already closed, fix your code", buf);

    res = TRUE;

    goto done;

  }

was_acquired:

  {

    GST_DEBUG_OBJECT (buf, "Resources for ring buffer still acquired");

    g_critical ("Resources for ring buffer %p still acquired", buf);

    res = FALSE;

    goto done;

  }

close_error:

  {

    buf->open = TRUE;

    GST_DEBUG_OBJECT (buf, "error closing device");

    goto done;

  }

}

/**

 * gst_audio_ring_buffer_device_is_open:

 * @buf: the #GstAudioRingBuffer

 *

 * Checks the status of the device associated with the ring buffer.

 *

 * Returns: TRUE if the device was open, FALSE if it was closed.

 *

 * MT safe.

 */

gboolean

gst_audio_ring_buffer_device_is_open (GstAudioRingBuffer * buf)

{

  gboolean res = TRUE;

  g_return_val_if_fail (GST_IS_AUDIO_RING_BUFFER (buf), FALSE);

  GST_OBJECT_LOCK (buf);

  res = buf->open;

  GST_OBJECT_UNLOCK (buf);

  return res;

}

/**

 * gst_audio_ring_buffer_acquire:

 * @buf: the #GstAudioRingBuffer to acquire

 * @spec: the specs of the buffer

 *

 * Allocate the resources for the ringbuffer. This function fills

 * in the data pointer of the ring buffer with a valid #GstBuffer

 * to which samples can be written.

 *

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

 *

 * MT safe.

 */

gboolean

gst_audio_ring_buffer_acquire (GstAudioRingBuffer * buf,

    GstAudioRingBufferSpec * spec)

{

  gboolean res = FALSE;

  GstAudioRingBufferClass *rclass;

  gint segsize, bpf, i;

  g_return_val_if_fail (GST_IS_AUDIO_RING_BUFFER (buf), FALSE);

  GST_DEBUG_OBJECT (buf, "acquiring device %p", buf);

  GST_OBJECT_LOCK (buf);

  if (G_UNLIKELY (!buf->open))

    goto not_opened;

  if (G_UNLIKELY (buf->acquired))

    goto was_acquired;

  buf->acquired = TRUE;

  buf->need_reorder = FALSE;

  rclass = GST_AUDIO_RING_BUFFER_GET_CLASS (buf);

  if (G_LIKELY (rclass->acquire))

    res = rclass->acquire (buf, spec);

  /* Only reorder for raw audio */

  buf->need_reorder = (buf->need_reorder

      && buf->spec.type == GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW);

  if (G_UNLIKELY (!res))

    goto acquire_failed;

  GST_INFO_OBJECT (buf, "Allocating an array for %d timestamps",

      spec->segtotal);

  buf->timestamps = g_slice_alloc0 (sizeof (GstClockTime) * spec->segtotal);

  /* initialize array with invalid timestamps */

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

    buf->timestamps[i] = GST_CLOCK_TIME_NONE;

  }

  if (G_UNLIKELY ((bpf = buf->spec.info.bpf) == 0))

    goto invalid_bpf;

  /* if the seglatency was overwritten with something else than -1, use it, else

   * assume segtotal as the latency */

  if (buf->spec.seglatency == -1)

    buf->spec.seglatency = buf->spec.segtotal;

  segsize = buf->spec.segsize;

  buf->samples_per_seg = segsize / bpf;

  /* create an empty segment */

  g_free (buf->empty_seg);

  buf->empty_seg = g_malloc (segsize);

  if (buf->spec.type == GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW) {

    gst_audio_format_fill_silence (buf->spec.info.finfo, buf->empty_seg,

        segsize);

  } else {

    /* FIXME, non-raw formats get 0 as the empty sample */

    memset (buf->empty_seg, 0, segsize);

  }

  GST_DEBUG_OBJECT (buf, "acquired device");

done:

  GST_OBJECT_UNLOCK (buf);

  return res;

  /* ERRORS */

not_opened:

  {

    GST_DEBUG_OBJECT (buf, "device not opened");

    g_critical ("Device for %p not opened", buf);

    res = FALSE;

    goto done;

  }

was_acquired:

  {

    res = TRUE;

    GST_DEBUG_OBJECT (buf, "device was acquired");

    goto done;

  }

acquire_failed:

  {

    buf->acquired = FALSE;

    GST_DEBUG_OBJECT (buf, "failed to acquire device");

    goto done;

  }

invalid_bpf:

  {

    g_warning

        ("invalid bytes_per_frame from acquire ringbuffer %p, fix the element",

        buf);

    buf->acquired = FALSE;

    res = FALSE;

    goto done;

  }

}

/**

 * gst_audio_ring_buffer_release:

 * @buf: the #GstAudioRingBuffer to release

 *

 * Free the resources of the ringbuffer.

 *

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

 *

 * MT safe.

 */

gboolean

gst_audio_ring_buffer_release (GstAudioRingBuffer * buf)

{

  gboolean res = FALSE;

  GstAudioRingBufferClass *rclass;

  g_return_val_if_fail (GST_IS_AUDIO_RING_BUFFER (buf), FALSE);

  GST_DEBUG_OBJECT (buf, "releasing device");

  gst_audio_ring_buffer_stop (buf);

  GST_OBJECT_LOCK (buf);

  if (G_LIKELY (buf->timestamps)) {

    GST_INFO_OBJECT (buf, "Freeing timestamp buffer, %d entries",

        buf->spec.segtotal);

    g_slice_free1 (sizeof (GstClockTime) * buf->spec.segtotal, buf->timestamps);

    buf->timestamps = NULL;

  }

  if (G_UNLIKELY (!buf->acquired))

    goto was_released;

  buf->acquired = FALSE;

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

  g_assert (buf->open);

  rclass = GST_AUDIO_RING_BUFFER_GET_CLASS (buf);

  if (G_LIKELY (rclass->release))

    res = rclass->release (buf);

  /* signal any waiters */

  GST_DEBUG_OBJECT (buf, "signal waiter");

  GST_AUDIO_RING_BUFFER_SIGNAL (buf);

  if (G_UNLIKELY (!res))

    goto release_failed;

  g_atomic_int_set (&buf->segdone, 0);

  buf->segbase = 0;

  g_free (buf->empty_seg);

  buf->empty_seg = NULL;

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

  gst_audio_info_init (&buf->spec.info);

  GST_DEBUG_OBJECT (buf, "released device");

done:

  GST_OBJECT_UNLOCK (buf);

  return res;

  /* ERRORS */

was_released:

  {

    res = TRUE;

    GST_DEBUG_OBJECT (buf, "device was released");

    goto done;

  }

release_failed:

  {

    buf->acquired = TRUE;

    GST_DEBUG_OBJECT (buf, "failed to release device");

    goto done;

  }

}

/**

 * gst_audio_ring_buffer_is_acquired:

 * @buf: the #GstAudioRingBuffer to check

 *

 * Check if the ringbuffer is acquired and ready to use.

 *

 * Returns: TRUE if the ringbuffer is acquired, FALSE on error.

 *

 * MT safe.

 */

gboolean

gst_audio_ring_buffer_is_acquired (GstAudioRingBuffer * buf)

{

  gboolean res;

  g_return_val_if_fail (GST_IS_AUDIO_RING_BUFFER (buf), FALSE);

  GST_OBJECT_LOCK (buf);

  res = buf->acquired;

  GST_OBJECT_UNLOCK (buf);

  return res;

}

/**

 * gst_audio_ring_buffer_activate:

 * @buf: the #GstAudioRingBuffer to activate

 * @active: the new mode

 *

 * Activate @buf to start or stop pulling data.

 *

 * MT safe.

 *

 * Returns: TRUE if the device could be activated in the requested mode,

 * FALSE on error.

 */

gboolean

gst_audio_ring_buffer_activate (GstAudioRingBuffer * buf, gboolean active)

{

  gboolean res = FALSE;

  GstAudioRingBufferClass *rclass;

  g_return_val_if_fail (GST_IS_AUDIO_RING_BUFFER (buf), FALSE);

  GST_DEBUG_OBJECT (buf, "activate device");

  GST_OBJECT_LOCK (buf);

  if (G_UNLIKELY (active && !buf->acquired))

    goto not_acquired;

  if (G_UNLIKELY (buf->active == active))

    goto was_active;

  rclass = GST_AUDIO_RING_BUFFER_GET_CLASS (buf);

  /* if there is no activate function we assume it was started/released

   * in the acquire method */

  if (G_LIKELY (rclass->activate))

    res = rclass->activate (buf, active);

  else

    res = TRUE;

  if (G_UNLIKELY (!res))

    goto activate_failed;

  buf->active = active;

done:

  GST_OBJECT_UNLOCK (buf);

  return res;

  /* ERRORS */

not_acquired:

  {

    GST_DEBUG_OBJECT (buf, "device not acquired");

    g_critical ("Device for %p not acquired", buf);

    res = FALSE;

    goto done;

  }

was_active:

  {

    res = TRUE;

    GST_DEBUG_OBJECT (buf, "device was active in mode %d", active);

    goto done;

  }

activate_failed:

  {

    GST_DEBUG_OBJECT (buf, "failed to activate device");

    goto done;

  }

}

/**

 * gst_audio_ring_buffer_is_active:

 * @buf: the #GstAudioRingBuffer

 *

 * Check if @buf is activated.

 *

 * MT safe.