gst/audiobuffer/: Add first version of an audioringbuffer element that can be inserted in the pipeline to convert pus...

Original commit message from CVS:
* gst/audiobuffer/Makefile.am:
* gst/audiobuffer/gstaudioringbuffer.c:
(gst_int_ring_buffer_acquire), (gst_int_ring_buffer_release),
(gst_int_ring_buffer_start), (gst_int_ring_buffer_base_init),
(gst_int_ring_buffer_class_init), (gst_int_ring_buffer_init),
(gst_int_ring_buffer_new), (gst_audio_ringbuffer_get_type),
(gst_audio_ringbuffer_class_init), (gst_audio_ringbuffer_init),
(gst_audio_ringbuffer_finalize), (gst_audio_ringbuffer_getcaps),
(gst_audio_ringbuffer_setcaps), (gst_audio_ringbuffer_bufferalloc),
(gst_audio_ringbuffer_handle_sink_event),
(gst_audio_ringbuffer_render), (gst_audio_ringbuffer_chain),
(gst_audio_ringbuffer_handle_src_event),
(gst_audio_ringbuffer_handle_src_query),
(gst_audio_ringbuffer_get_range),
(gst_audio_ringbuffer_src_checkgetrange_function),
(gst_audio_ringbuffer_sink_activate_push),
(gst_audio_ringbuffer_src_activate_push),
(gst_audio_ringbuffer_src_activate_pull),
(gst_audio_ringbuffer_change_state),
(gst_audio_ringbuffer_set_property),
(gst_audio_ringbuffer_get_property), (plugin_init):
Add first version of an audioringbuffer element that can be inserted in
the pipeline to convert push-based upstream into a pull-based
downstream.

2 files changed, 1196 insertions, 0 deletions

diff --git a/gst/audiobuffer/Makefile.am b/gst/audiobuffer/Makefile.am
new file mode 100644
index 00000000..6f2a3828
--- /dev/null
+++ b/gst/audiobuffer/Makefile.am
@@ -0,0 +1,10 @@
+plugin_LTLIBRARIES = libgstaudiobuffer.la
+
+libgstaudiobuffer_la_SOURCES = gstaudioringbuffer.c
+libgstaudiobuffer_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS) \
+    $(GST_CFLAGS) 
+libgstaudiobuffer_la_LIBADD = $(GST_PLUGINS_BASE_LIBS) $(GST_BASE_LIBS) \
+			   -lgstaudio-$(GST_MAJORMINOR)
+
+libgstaudiobuffer_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
+
diff --git a/gst/audiobuffer/gstaudioringbuffer.c b/gst/audiobuffer/gstaudioringbuffer.c
new file mode 100644
index 00000000..19a9c48b
--- /dev/null
+++ b/gst/audiobuffer/gstaudioringbuffer.c
@@ -0,0 +1,1186 @@
+/* GStreamer
+ * Copyright (C) 2008 Wim Taymans <wim.taymans@gmail.com>
+ *
+ * gstaudioringbuffer.c:
+ *
+ * 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-audioringbuffer
+ * @short_description: Asynchronous audio ringbuffer.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+
+#include <glib/gstdio.h>
+
+#include <gst/gst.h>
+#include <gst/gst-i18n-plugin.h>
+
+#include <gst/audio/gstringbuffer.h>
+
+static const GstElementDetails gst_audio_ringbuffer_details =
+GST_ELEMENT_DETAILS ("AudioRingbuffer",
+    "Generic",
+    "Asynchronous Audio ringbuffer",
+    "Wim Taymans <wim.taymans@gmail.com>");
+
+static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS_ANY);
+
+static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS_ANY);
+
+GST_DEBUG_CATEGORY_STATIC (audioringbuffer_debug);
+#define GST_CAT_DEFAULT (audioringbuffer_debug)
+
+enum
+{
+  LAST_SIGNAL
+};
+
+#define DEFAULT_BUFFER_TIME     ((200 * GST_MSECOND) / GST_USECOND)
+#define DEFAULT_SEGMENT_TIME    ((10 * GST_MSECOND) / GST_USECOND)
+
+
+enum
+{
+  PROP_0,
+  PROP_BUFFER_TIME,
+  PROP_SEGMENT_TIME,
+  PROP_LAST
+};
+
+#define GST_TYPE_AUDIO_RINGBUFFER \
+  (gst_audio_ringbuffer_get_type())
+#define GST_AUDIO_RINGBUFFER(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_RINGBUFFER,GstAudioRingbuffer))
+#define GST_AUDIO_RINGBUFFER_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIO_RINGBUFFER,GstAudioRingbufferClass))
+#define GST_IS_AUDIO_RINGBUFFER(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_RINGBUFFER))
+#define GST_IS_AUDIO_RINGBUFFER_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIO_RINGBUFFER))
+#define GST_AUDIO_RINGBUFFER_CAST(obj) \
+  ((GstAudioRingbuffer *)(obj))
+
+static GType gst_audio_ringbuffer_get_type (void);
+
+typedef struct _GstAudioRingbuffer GstAudioRingbuffer;
+typedef struct _GstAudioRingbufferClass GstAudioRingbufferClass;
+
+typedef struct _GstIntRingBuffer GstIntRingBuffer;
+typedef struct _GstIntRingBufferClass GstIntRingBufferClass;
+
+struct _GstAudioRingbuffer
+{
+  GstElement element;
+
+  /*< private > */
+  GstPad *sinkpad;
+  GstPad *srcpad;
+
+  gboolean pushing;
+  gboolean pulling;
+
+  /* segments to keep track of timestamps */
+  GstSegment sink_segment;
+  GstSegment src_segment;
+
+  /* flowreturn when srcpad is paused */
+  gboolean is_eos;
+  gboolean flushing;
+  gboolean waiting;
+
+  GCond *cond;
+
+  GstRingBuffer *buffer;
+
+  GstClockTime buffer_time;
+  GstClockTime segment_time;
+
+  guint64 next_sample;
+  guint64 last_align;
+};
+
+struct _GstAudioRingbufferClass
+{
+  GstElementClass parent_class;
+};
+
+
+#define GST_TYPE_INT_RING_BUFFER             (gst_int_ring_buffer_get_type())
+#define GST_INT_RING_BUFFER(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_INT_RING_BUFFER,GstIntRingBuffer))
+#define GST_INT_RING_BUFFER_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_INT_RING_BUFFER,GstIntRingBufferClass))
+#define GST_INT_RING_BUFFER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_INT_RING_BUFFER, GstIntRingBufferClass))
+#define GST_INT_RING_BUFFER_CAST(obj)        ((GstIntRingBuffer *)obj)
+#define GST_IS_INT_RING_BUFFER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_INT_RING_BUFFER))
+#define GST_IS_INT_RING_BUFFER_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_INT_RING_BUFFER))
+
+
+struct _GstIntRingBuffer
+{
+  GstRingBuffer object;
+};
+
+struct _GstIntRingBufferClass
+{
+  GstRingBufferClass parent_class;
+};
+
+GST_BOILERPLATE (GstIntRingBuffer, gst_int_ring_buffer, GstRingBuffer,
+    GST_TYPE_RING_BUFFER);
+
+static gboolean
+gst_int_ring_buffer_acquire (GstRingBuffer * buf, GstRingBufferSpec * spec)
+{
+  spec->seglatency = spec->segtotal;
+
+  buf->data = gst_buffer_new_and_alloc (spec->segtotal * spec->segsize);
+  memset (GST_BUFFER_DATA (buf->data), 0, GST_BUFFER_SIZE (buf->data));
+
+  return TRUE;
+}
+
+static gboolean
+gst_int_ring_buffer_release (GstRingBuffer * buf)
+{
+  gst_buffer_unref (buf->data);
+  buf->data = NULL;
+
+  return TRUE;
+}
+
+static gboolean
+gst_int_ring_buffer_start (GstRingBuffer * buf)
+{
+  GstAudioRingbuffer *ringbuffer;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (GST_OBJECT_PARENT (buf));
+
+  GST_OBJECT_LOCK (ringbuffer);
+  if (G_UNLIKELY (ringbuffer->waiting)) {
+    ringbuffer->waiting = FALSE;
+    GST_DEBUG_OBJECT (ringbuffer, "start, sending signal");
+    g_cond_broadcast (ringbuffer->cond);
+  }
+  GST_OBJECT_UNLOCK (ringbuffer);
+
+  return TRUE;
+}
+
+
+static void
+gst_int_ring_buffer_base_init (gpointer klass)
+{
+}
+
+static void
+gst_int_ring_buffer_class_init (GstIntRingBufferClass * klass)
+{
+  GstRingBufferClass *gstringbuffer_class;
+
+  gstringbuffer_class = (GstRingBufferClass *) klass;
+
+  gstringbuffer_class->acquire =
+      GST_DEBUG_FUNCPTR (gst_int_ring_buffer_acquire);
+  gstringbuffer_class->release =
+      GST_DEBUG_FUNCPTR (gst_int_ring_buffer_release);
+  gstringbuffer_class->start = GST_DEBUG_FUNCPTR (gst_int_ring_buffer_start);
+}
+
+static void
+gst_int_ring_buffer_init (GstIntRingBuffer * buff,
+    GstIntRingBufferClass * g_class)
+{
+}
+
+static GstRingBuffer *
+gst_int_ring_buffer_new (void)
+{
+  GstRingBuffer *res;
+
+  res = g_object_new (GST_TYPE_INT_RING_BUFFER, NULL);
+
+  return res;
+}
+
+/* can't use boilerplate as we need to register with Queue2 to avoid conflicts
+ * with ringbuffer in core elements */
+static void gst_audio_ringbuffer_class_init (GstAudioRingbufferClass * klass);
+static void gst_audio_ringbuffer_init (GstAudioRingbuffer * ringbuffer,
+    GstAudioRingbufferClass * g_class);
+static GstElementClass *elem_parent_class;
+
+static GType
+gst_audio_ringbuffer_get_type (void)
+{
+  static GType gst_audio_ringbuffer_type = 0;
+
+  if (!gst_audio_ringbuffer_type) {
+    static const GTypeInfo gst_audio_ringbuffer_info = {
+      sizeof (GstAudioRingbufferClass),
+      NULL,
+      NULL,
+      (GClassInitFunc) gst_audio_ringbuffer_class_init,
+      NULL,
+      NULL,
+      sizeof (GstAudioRingbuffer),
+      0,
+      (GInstanceInitFunc) gst_audio_ringbuffer_init,
+      NULL
+    };
+
+    gst_audio_ringbuffer_type =
+        g_type_register_static (GST_TYPE_ELEMENT, "GstAudioRingbuffer",
+        &gst_audio_ringbuffer_info, 0);
+  }
+  return gst_audio_ringbuffer_type;
+}
+
+static void gst_audio_ringbuffer_finalize (GObject * object);
+
+static void gst_audio_ringbuffer_set_property (GObject * object,
+    guint prop_id, const GValue * value, GParamSpec * pspec);
+static void gst_audio_ringbuffer_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec);
+
+static GstFlowReturn gst_audio_ringbuffer_chain (GstPad * pad,
+    GstBuffer * buffer);
+static GstFlowReturn gst_audio_ringbuffer_bufferalloc (GstPad * pad,
+    guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf);
+
+static gboolean gst_audio_ringbuffer_handle_sink_event (GstPad * pad,
+    GstEvent * event);
+
+static gboolean gst_audio_ringbuffer_handle_src_event (GstPad * pad,
+    GstEvent * event);
+static gboolean gst_audio_ringbuffer_handle_src_query (GstPad * pad,
+    GstQuery * query);
+
+static GstCaps *gst_audio_ringbuffer_getcaps (GstPad * pad);
+static gboolean gst_audio_ringbuffer_setcaps (GstPad * pad, GstCaps * caps);
+
+static GstFlowReturn gst_audio_ringbuffer_get_range (GstPad * pad,
+    guint64 offset, guint length, GstBuffer ** buffer);
+static gboolean gst_audio_ringbuffer_src_checkgetrange_function (GstPad * pad);
+
+static gboolean gst_audio_ringbuffer_src_activate_pull (GstPad * pad,
+    gboolean active);
+static gboolean gst_audio_ringbuffer_src_activate_push (GstPad * pad,
+    gboolean active);
+static gboolean gst_audio_ringbuffer_sink_activate_push (GstPad * pad,
+    gboolean active);
+
+static GstStateChangeReturn gst_audio_ringbuffer_change_state (GstElement *
+    element, GstStateChange transition);
+
+/* static guint gst_audio_ringbuffer_signals[LAST_SIGNAL] = { 0 }; */
+
+static void
+gst_audio_ringbuffer_class_init (GstAudioRingbufferClass * klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
+
+  elem_parent_class = g_type_class_peek_parent (klass);
+
+  gobject_class->set_property =
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_set_property);
+  gobject_class->get_property =
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_get_property);
+
+  g_object_class_install_property (gobject_class, PROP_BUFFER_TIME,
+      g_param_spec_int64 ("buffer-time", "Buffer Time",
+          "Size of audio buffer in nanoseconds", 1,
+          G_MAXINT64, DEFAULT_BUFFER_TIME,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  g_object_class_install_property (gobject_class, PROP_SEGMENT_TIME,
+      g_param_spec_int64 ("segment-time", "Segment Time",
+          "Audio segment duration in nanoseconds", 1,
+          G_MAXINT64, DEFAULT_SEGMENT_TIME,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  gst_element_class_add_pad_template (gstelement_class,
+      gst_static_pad_template_get (&srctemplate));
+  gst_element_class_add_pad_template (gstelement_class,
+      gst_static_pad_template_get (&sinktemplate));
+
+  gst_element_class_set_details (gstelement_class,
+      &gst_audio_ringbuffer_details);
+
+  /* set several parent class virtual functions */
+  gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_finalize);
+
+  gstelement_class->change_state =
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_change_state);
+}
+
+static void
+gst_audio_ringbuffer_init (GstAudioRingbuffer * ringbuffer,
+    GstAudioRingbufferClass * g_class)
+{
+  ringbuffer->sinkpad =
+      gst_pad_new_from_static_template (&sinktemplate, "sink");
+
+  gst_pad_set_chain_function (ringbuffer->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_chain));
+  gst_pad_set_activatepush_function (ringbuffer->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_sink_activate_push));
+  gst_pad_set_event_function (ringbuffer->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_handle_sink_event));
+  gst_pad_set_getcaps_function (ringbuffer->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_getcaps));
+  gst_pad_set_setcaps_function (ringbuffer->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_setcaps));
+  gst_pad_set_bufferalloc_function (ringbuffer->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_bufferalloc));
+  gst_element_add_pad (GST_ELEMENT (ringbuffer), ringbuffer->sinkpad);
+
+  ringbuffer->srcpad = gst_pad_new_from_static_template (&srctemplate, "src");
+
+  gst_pad_set_activatepull_function (ringbuffer->srcpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_src_activate_pull));
+  gst_pad_set_activatepush_function (ringbuffer->srcpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_src_activate_push));
+  gst_pad_set_getrange_function (ringbuffer->srcpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_get_range));
+  gst_pad_set_checkgetrange_function (ringbuffer->srcpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_src_checkgetrange_function));
+  gst_pad_set_getcaps_function (ringbuffer->srcpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_getcaps));
+  gst_pad_set_event_function (ringbuffer->srcpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_handle_src_event));
+  gst_pad_set_query_function (ringbuffer->srcpad,
+      GST_DEBUG_FUNCPTR (gst_audio_ringbuffer_handle_src_query));
+  gst_element_add_pad (GST_ELEMENT (ringbuffer), ringbuffer->srcpad);
+
+  gst_segment_init (&ringbuffer->sink_segment, GST_FORMAT_TIME);
+
+  ringbuffer->cond = g_cond_new ();
+
+  ringbuffer->is_eos = FALSE;
+
+  ringbuffer->buffer_time = DEFAULT_BUFFER_TIME;
+  ringbuffer->segment_time = DEFAULT_SEGMENT_TIME;
+
+  GST_DEBUG_OBJECT (ringbuffer,
+      "initialized ringbuffer's not_empty & not_full conditions");
+}
+
+/* called only once, as opposed to dispose */
+static void
+gst_audio_ringbuffer_finalize (GObject * object)
+{
+  GstAudioRingbuffer *ringbuffer = GST_AUDIO_RINGBUFFER (object);
+
+  GST_DEBUG_OBJECT (ringbuffer, "finalizing ringbuffer");
+
+  g_cond_free (ringbuffer->cond);
+
+  G_OBJECT_CLASS (elem_parent_class)->finalize (object);
+}
+
+static GstCaps *
+gst_audio_ringbuffer_getcaps (GstPad * pad)
+{
+  GstAudioRingbuffer *ringbuffer;
+  GstPad *otherpad;
+  GstCaps *result;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (GST_PAD_PARENT (pad));
+
+  otherpad =
+      (pad == ringbuffer->srcpad ? ringbuffer->sinkpad : ringbuffer->srcpad);
+  result = gst_pad_peer_get_caps (otherpad);
+  if (result == NULL)
+    result = gst_caps_new_any ();
+
+  return result;
+}
+
+static gboolean
+gst_audio_ringbuffer_setcaps (GstPad * pad, GstCaps * caps)
+{
+  GstAudioRingbuffer *ringbuffer;
+  GstRingBufferSpec *spec;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (GST_PAD_PARENT (pad));
+
+  if (!ringbuffer->buffer)
+    return FALSE;
+
+  spec = &ringbuffer->buffer->spec;
+
+  GST_DEBUG_OBJECT (ringbuffer, "release old ringbuffer");
+
+  /* release old ringbuffer */
+  gst_ring_buffer_activate (ringbuffer->buffer, FALSE);
+  gst_ring_buffer_release (ringbuffer->buffer);
+
+  GST_DEBUG_OBJECT (ringbuffer, "parse caps");
+
+  spec->buffer_time = ringbuffer->buffer_time;
+  spec->latency_time = ringbuffer->segment_time;
+
+  /* parse new caps */
+  if (!gst_ring_buffer_parse_caps (spec, caps))
+    goto parse_error;
+
+  gst_ring_buffer_debug_spec_buff (spec);
+
+  GST_DEBUG_OBJECT (ringbuffer, "acquire ringbuffer");
+  if (!gst_ring_buffer_acquire (ringbuffer->buffer, spec))
+    goto acquire_error;
+
+  GST_DEBUG_OBJECT (ringbuffer, "activate ringbuffer");
+  gst_ring_buffer_activate (ringbuffer->buffer, TRUE);
+
+  /* calculate actual latency and buffer times. 
+   * FIXME: In 0.11, store the latency_time internally in ns */
+  spec->latency_time = gst_util_uint64_scale (spec->segsize,
+      (GST_SECOND / GST_USECOND), spec->rate * spec->bytes_per_sample);
+
+  spec->buffer_time = spec->segtotal * spec->latency_time;
+
+  gst_ring_buffer_debug_spec_buff (spec);
+
+  return TRUE;
+
+  /* ERRORS */
+parse_error:
+  {
+    GST_DEBUG_OBJECT (ringbuffer, "could not parse caps");
+    GST_ELEMENT_ERROR (ringbuffer, STREAM, FORMAT,
+        (NULL), ("cannot parse audio format."));
+    return FALSE;
+  }
+acquire_error:
+  {
+    GST_DEBUG_OBJECT (ringbuffer, "could not acquire ringbuffer");
+    return FALSE;
+  }
+}
+
+static GstFlowReturn
+gst_audio_ringbuffer_bufferalloc (GstPad * pad, guint64 offset, guint size,
+    GstCaps * caps, GstBuffer ** buf)
+{
+  GstAudioRingbuffer *ringbuffer;
+  GstFlowReturn result;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (GST_PAD_PARENT (pad));
+
+  /* Forward to src pad, without setting caps on the src pad */
+  result = gst_pad_alloc_buffer (ringbuffer->srcpad, offset, size, caps, buf);
+
+  return result;
+}
+
+static gboolean
+gst_audio_ringbuffer_handle_sink_event (GstPad * pad, GstEvent * event)
+{
+  GstAudioRingbuffer *ringbuffer;
+  gboolean forward;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (GST_OBJECT_PARENT (pad));
+
+  forward = ringbuffer->pushing || ringbuffer->pulling;
+
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_FLUSH_START:
+    {
+      GST_LOG_OBJECT (ringbuffer, "received flush start event");
+      break;
+    }
+    case GST_EVENT_FLUSH_STOP:
+    {
+      ringbuffer->is_eos = FALSE;
+      GST_LOG_OBJECT (ringbuffer, "received flush stop event");
+      break;
+    }
+    case GST_EVENT_NEWSEGMENT:
+    {
+      gboolean update;
+      gdouble rate, arate;
+      GstFormat format;
+      gint64 start, stop, time;
+
+      gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,
+          &start, &stop, &time);
+
+      gst_segment_set_newsegment_full (&ringbuffer->sink_segment, update, rate,
+          arate, format, start, stop, time);
+      break;
+    }
+    case GST_EVENT_EOS:
+      ringbuffer->is_eos = TRUE;
+      break;
+    default:
+      break;
+  }
+  if (forward) {
+    gst_pad_push_event (ringbuffer->srcpad, event);
+  } else {
+    if (event)
+      gst_event_unref (event);
+  }
+  return TRUE;
+}
+
+#define DIFF_TOLERANCE  2
+
+static GstFlowReturn
+gst_audio_ringbuffer_render (GstAudioRingbuffer * ringbuffer, GstBuffer * buf)
+{
+  GstRingBuffer *rbuf;
+  gint bps, accum;
+  guint size;
+  guint samples, written, out_samples;
+  gint64 diff, align, ctime, cstop;
+  guint8 *data;
+  guint64 in_offset;
+  GstClockTime time, stop, render_start, render_stop, sample_offset;
+  gboolean align_next;
+
+  rbuf = ringbuffer->buffer;
+
+  /* can't do anything when we don't have the device */
+  if (G_UNLIKELY (!gst_ring_buffer_is_acquired (rbuf)))
+    goto wrong_state;
+
+  bps = rbuf->spec.bytes_per_sample;
+
+  size = GST_BUFFER_SIZE (buf);
+  if (G_UNLIKELY (size % bps) != 0)
+    goto wrong_size;
+
+  samples = size / bps;
+  out_samples = samples;
+
+  in_offset = GST_BUFFER_OFFSET (buf);
+  time = GST_BUFFER_TIMESTAMP (buf);
+
+  GST_DEBUG_OBJECT (ringbuffer,
+      "time %" GST_TIME_FORMAT ", offset %llu, start %" GST_TIME_FORMAT
+      ", samples %u", GST_TIME_ARGS (time), in_offset,
+      GST_TIME_ARGS (ringbuffer->sink_segment.start), samples);
+
+  data = GST_BUFFER_DATA (buf);
+
+  stop = time + gst_util_uint64_scale_int (samples, GST_SECOND,
+      rbuf->spec.rate);
+
+  if (!gst_segment_clip (&ringbuffer->sink_segment, GST_FORMAT_TIME, time, stop,
+          &ctime, &cstop))
+    goto out_of_segment;
+
+  /* see if some clipping happened */
+  diff = ctime - time;
+  if (diff > 0) {
+    /* bring clipped time to samples */
+    diff = gst_util_uint64_scale_int (diff, rbuf->spec.rate, GST_SECOND);
+    GST_DEBUG_OBJECT (ringbuffer, "clipping start to %" GST_TIME_FORMAT " %"
+        G_GUINT64_FORMAT " samples", GST_TIME_ARGS (ctime), diff);
+    samples -= diff;
+    data += diff * bps;
+    time = ctime;
+  }
+  diff = stop - cstop;
+  if (diff > 0) {
+    /* bring clipped time to samples */
+    diff = gst_util_uint64_scale_int (diff, rbuf->spec.rate, GST_SECOND);
+    GST_DEBUG_OBJECT (ringbuffer, "clipping stop to %" GST_TIME_FORMAT " %"
+        G_GUINT64_FORMAT " samples", GST_TIME_ARGS (cstop), diff);
+    samples -= diff;
+    stop = cstop;
+  }
+
+  /* bring buffer start and stop times to running time */
+  render_start =
+      gst_segment_to_running_time (&ringbuffer->sink_segment, GST_FORMAT_TIME,
+      time);
+  render_stop =
+      gst_segment_to_running_time (&ringbuffer->sink_segment, GST_FORMAT_TIME,
+      stop);
+
+  GST_DEBUG_OBJECT (ringbuffer,
+      "running: start %" GST_TIME_FORMAT " - stop %" GST_TIME_FORMAT,
+      GST_TIME_ARGS (render_start), GST_TIME_ARGS (render_stop));
+
+  /* and bring the time to the rate corrected offset in the buffer */
+  render_start = gst_util_uint64_scale_int (render_start,
+      rbuf->spec.rate, GST_SECOND);
+  render_stop = gst_util_uint64_scale_int (render_stop,
+      rbuf->spec.rate, GST_SECOND);
+
+  /* positive playback rate, first sample is render_start, negative rate, first
+   * sample is render_stop. When no rate conversion is active, render exactly
+   * the amount of input samples to avoid aligning to rounding errors. */
+  if (ringbuffer->sink_segment.rate >= 0.0) {
+    sample_offset = render_start;
+    if (ringbuffer->sink_segment.rate == 1.0)
+      render_stop = sample_offset + samples;
+  } else {
+    sample_offset = render_stop;
+    if (ringbuffer->sink_segment.rate == -1.0)
+      render_start = sample_offset + samples;
+  }
+
+  /* always resync after a discont */
+  if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DISCONT))) {
+    GST_DEBUG_OBJECT (ringbuffer, "resync after discont");
+    goto no_align;
+  }
+
+  /* resync when we don't know what to align the sample with */
+  if (G_UNLIKELY (ringbuffer->next_sample == -1)) {
+    GST_DEBUG_OBJECT (ringbuffer,
+        "no align possible: no previous sample position known");
+    goto no_align;
+  }
+
+  /* now try to align the sample to the previous one, first see how big the
+   * difference is. */
+  if (sample_offset >= ringbuffer->next_sample)
+    diff = sample_offset - ringbuffer->next_sample;
+  else
+    diff = ringbuffer->next_sample - sample_offset;
+
+  /* we tollerate half a second diff before we start resyncing. This
+   * should be enough to compensate for various rounding errors in the timestamp
+   * and sample offset position. We always resync if we got a discont anyway and
+   * non-discont should be aligned by definition. */
+  if (G_LIKELY (diff < rbuf->spec.rate / DIFF_TOLERANCE)) {
+    /* calc align with previous sample */
+    align = ringbuffer->next_sample - sample_offset;
+    GST_DEBUG_OBJECT (ringbuffer,
+        "align with prev sample, ABS (%" G_GINT64_FORMAT ") < %d", align,
+        rbuf->spec.rate / DIFF_TOLERANCE);
+  } else {
+    /* bring sample diff to seconds for error message */
+    diff = gst_util_uint64_scale_int (diff, GST_SECOND, rbuf->spec.rate);
+    /* timestamps drifted apart from previous samples too much, we need to
+     * resync. We log this as an element warning. */
+    GST_ELEMENT_WARNING (ringbuffer, CORE, CLOCK,
+        ("Compensating for audio synchronisation problems"),
+        ("Unexpected discontinuity in audio timestamps of more "
+            "than half a second (%" GST_TIME_FORMAT "), resyncing",
+            GST_TIME_ARGS (diff)));
+    align = 0;
+  }
+  ringbuffer->last_align = align;
+
+  /* apply alignment */
+  render_start += align;
+  render_stop += align;
+
+no_align:
+  /* number of target samples is difference between start and stop */
+  out_samples = render_stop - render_start;
+
+  /* we render the first or last sample first, depending on the rate */
+  if (ringbuffer->sink_segment.rate >= 0.0)
+    sample_offset = render_start;
+  else
+    sample_offset = render_stop;
+
+  GST_DEBUG_OBJECT (ringbuffer, "rendering at %" G_GUINT64_FORMAT " %d/%d",
+      sample_offset, samples, out_samples);
+
+  /* we need to accumulate over different runs for when we get interrupted */
+  accum = 0;
+  align_next = TRUE;
+  do {
+    written =
+        gst_ring_buffer_commit_full (rbuf, &sample_offset, data, samples,
+        out_samples, &accum);
+
+    GST_DEBUG_OBJECT (ringbuffer, "wrote %u of %u", written, samples);
+    /* if we wrote all, we're done */
+    if (written == samples)
+      break;
+
+    GST_OBJECT_LOCK (ringbuffer);
+    if (ringbuffer->flushing)
+      goto flushing;
+    GST_OBJECT_UNLOCK (ringbuffer);
+
+    /* if we got interrupted, we cannot assume that the next sample should
+     * be aligned to this one */
+    align_next = FALSE;
+
+    samples -= written;
+    data += written * bps;
+  } while (TRUE);
+
+  if (align_next)
+    ringbuffer->next_sample = sample_offset;
+  else
+    ringbuffer->next_sample = -1;
+
+  GST_DEBUG_OBJECT (ringbuffer, "next sample expected at %" G_GUINT64_FORMAT,
+      ringbuffer->next_sample);
+
+  if (GST_CLOCK_TIME_IS_VALID (stop) && stop >= ringbuffer->sink_segment.stop) {
+    GST_DEBUG_OBJECT (ringbuffer,
+        "start playback because we are at the end of segment");
+    gst_ring_buffer_start (rbuf);
+  }
+
+  return GST_FLOW_OK;
+
+  /* SPECIAL cases */
+out_of_segment:
+  {
+    GST_DEBUG_OBJECT (ringbuffer,
+        "dropping sample out of segment time %" GST_TIME_FORMAT ", start %"
+        GST_TIME_FORMAT, GST_TIME_ARGS (time),
+        GST_TIME_ARGS (ringbuffer->sink_segment.start));
+    return GST_FLOW_OK;
+  }
+  /* ERRORS */
+wrong_state:
+  {
+    GST_DEBUG_OBJECT (ringbuffer, "ringbuffer not negotiated");
+    GST_ELEMENT_ERROR (ringbuffer, STREAM, FORMAT, (NULL),
+        ("ringbuffer not negotiated."));
+    return GST_FLOW_NOT_NEGOTIATED;
+  }
+wrong_size:
+  {
+    GST_DEBUG_OBJECT (ringbuffer, "wrong size");
+    GST_ELEMENT_ERROR (ringbuffer, STREAM, WRONG_TYPE,
+        (NULL), ("ringbuffer received buffer of wrong size."));
+    return GST_FLOW_ERROR;
+  }
+flushing:
+  {
+    GST_DEBUG_OBJECT (ringbuffer, "ringbuffer is flushing");
+    GST_OBJECT_UNLOCK (ringbuffer);
+    return GST_FLOW_WRONG_STATE;
+  }
+}
+
+static GstFlowReturn
+gst_audio_ringbuffer_chain (GstPad * pad, GstBuffer * buffer)
+{
+  GstFlowReturn res;
+  GstAudioRingbuffer *ringbuffer;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (GST_OBJECT_PARENT (pad));
+
+  if (ringbuffer->pushing) {
+    GST_DEBUG_OBJECT (ringbuffer, "proxy pushing buffer");
+    res = gst_pad_push (ringbuffer->srcpad, buffer);
+  } else {
+    GST_DEBUG_OBJECT (ringbuffer, "render buffer in ringbuffer");
+    res = gst_audio_ringbuffer_render (ringbuffer, buffer);
+  }
+
+  return res;
+}
+
+static gboolean
+gst_audio_ringbuffer_handle_src_event (GstPad * pad, GstEvent * event)
+{
+  gboolean res = TRUE;
+  GstAudioRingbuffer *ringbuffer = GST_AUDIO_RINGBUFFER (GST_PAD_PARENT (pad));
+
+  /* just forward upstream */
+  res = gst_pad_push_event (ringbuffer->sinkpad, event);
+
+  return res;
+}
+
+static gboolean
+gst_audio_ringbuffer_handle_src_query (GstPad * pad, GstQuery * query)
+{
+  GstAudioRingbuffer *ringbuffer;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (GST_PAD_PARENT (pad));
+
+  switch (GST_QUERY_TYPE (query)) {
+    case GST_QUERY_POSITION:
+      break;
+    case GST_QUERY_DURATION:
+      break;
+    case GST_QUERY_BUFFERING:
+      break;
+    default:
+      break;
+  }
+
+  return TRUE;
+}
+
+static GstFlowReturn
+gst_audio_ringbuffer_get_range (GstPad * pad, guint64 offset, guint length,
+    GstBuffer ** buffer)
+{
+  GstAudioRingbuffer *ringbuffer;
+  GstRingBuffer *rbuf;
+  GstFlowReturn ret;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER_CAST (gst_pad_get_parent (pad));
+
+  rbuf = ringbuffer->buffer;
+
+  if (ringbuffer->pulling) {
+    GST_DEBUG_OBJECT (ringbuffer, "proxy pulling range");
+    ret = gst_pad_pull_range (ringbuffer->sinkpad, offset, length, buffer);
+  } else {
+    guint8 *data;
+    guint len;
+    guint64 sample;
+    gint bps, segsize, segtotal, sps;
+    gint sampleslen, segdone;
+    gint readseg, sampleoff;
+    guint8 *dest;
+
+    GST_DEBUG_OBJECT (ringbuffer,
+        "pulling data at %" G_GUINT64_FORMAT ", length %u", offset, length);
+
+    if (offset != ringbuffer->src_segment.last_stop) {
+      GST_DEBUG_OBJECT (ringbuffer, "expected offset %" G_GINT64_FORMAT,
+          ringbuffer->src_segment.last_stop);
+    }
+
+    /* first wait till we have something in the ringbuffer and it 
+     * is running */
+    GST_OBJECT_LOCK (ringbuffer);
+    if (ringbuffer->flushing)
+      goto flushing;
+
+    while (ringbuffer->waiting) {
+      GST_DEBUG_OBJECT (ringbuffer, "waiting for unlock");
+      g_cond_wait (ringbuffer->cond, GST_OBJECT_GET_LOCK (ringbuffer));
+      GST_DEBUG_OBJECT (ringbuffer, "unlocked");
+
+      if (ringbuffer->flushing)
+        goto flushing;
+    }
+    GST_OBJECT_UNLOCK (ringbuffer);
+
+    bps = rbuf->spec.bytes_per_sample;
+
+    if (G_UNLIKELY (length % bps) != 0)
+      goto wrong_size;
+
+    segsize = rbuf->spec.segsize;
+    segtotal = rbuf->spec.segtotal;
+    sps = rbuf->samples_per_seg;
+    dest = GST_BUFFER_DATA (rbuf->data);
+
+    sample = offset / bps;
+    len = length / bps;
+
+    *buffer = gst_buffer_new_and_alloc (length);
+    data = GST_BUFFER_DATA (*buffer);
+
+    while (len) {
+      gint diff;
+
+      /* figure out the segment and the offset inside the segment where
+       * the sample should be read from. */
+      readseg = sample / sps;
+      sampleoff = (sample % sps);
+
+      segdone = g_atomic_int_get (&rbuf->segdone) - rbuf->segbase;
+
+      diff = readseg - segdone;
+
+      /* we can read now */
+      readseg = readseg % segtotal;
+      sampleslen = MIN (sps - sampleoff, len);
+
+      GST_DEBUG_OBJECT (ringbuffer,
+          "read @%p seg %d, off %d, sampleslen %d, diff %d",
+          dest + readseg * segsize, readseg, sampleoff, sampleslen, diff);
+
+      memcpy (data, dest + (readseg * segsize) + (sampleoff * bps),
+          (sampleslen * bps));
+
+      if (diff > 0)
+        gst_ring_buffer_advance (rbuf, diff);
+
+      len -= sampleslen;
+      sample += sampleslen;
+      data += sampleslen * bps;
+    }
+
+    ringbuffer->src_segment.last_stop += length;
+
+    ret = GST_FLOW_OK;
+  }
+
+  gst_object_unref (ringbuffer);
+
+  return ret;
+
+  /* ERRORS */
+flushing:
+  {
+    GST_DEBUG_OBJECT (ringbuffer, "we are flushing");
+    GST_OBJECT_UNLOCK (ringbuffer);
+    gst_object_unref (ringbuffer);
+    return GST_FLOW_WRONG_STATE;
+  }
+wrong_size:
+  {
+    GST_DEBUG_OBJECT (ringbuffer, "wrong size");
+    GST_ELEMENT_ERROR (ringbuffer, STREAM, WRONG_TYPE,
+        (NULL), ("asked to pull buffer of wrong size."));
+    return GST_FLOW_ERROR;
+  }
+}
+
+static gboolean
+gst_audio_ringbuffer_src_checkgetrange_function (GstPad * pad)
+{
+  gboolean ret;
+
+  /* we can always operate in pull mode */
+  ret = TRUE;
+
+  return ret;
+}
+
+/* sink currently only operates in push mode */
+static gboolean
+gst_audio_ringbuffer_sink_activate_push (GstPad * pad, gboolean active)
+{
+  gboolean result = TRUE;
+  GstAudioRingbuffer *ringbuffer;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (gst_pad_get_parent (pad));
+
+  if (active) {
+    GST_DEBUG_OBJECT (ringbuffer, "activating push mode");
+    ringbuffer->is_eos = FALSE;
+    ringbuffer->pulling = FALSE;
+  } else {
+    /* unblock chain function */
+    GST_DEBUG_OBJECT (ringbuffer, "deactivating push mode");
+    ringbuffer->pulling = FALSE;
+  }
+
+  gst_object_unref (ringbuffer);
+
+  return result;
+}
+
+/* src operating in push mode, we will proxy the push from upstream, basically
+ * acting as a passthrough element. */
+static gboolean
+gst_audio_ringbuffer_src_activate_push (GstPad * pad, gboolean active)
+{
+  gboolean result = FALSE;
+  GstAudioRingbuffer *ringbuffer;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (gst_pad_get_parent (pad));
+
+  if (active) {
+    GST_DEBUG_OBJECT (ringbuffer, "activating push mode");
+    ringbuffer->is_eos = FALSE;
+    ringbuffer->pushing = TRUE;
+    ringbuffer->pulling = FALSE;
+    result = TRUE;
+  } else {
+    GST_DEBUG_OBJECT (ringbuffer, "deactivating push mode");
+    ringbuffer->pushing = FALSE;
+    ringbuffer->pulling = FALSE;
+    result = TRUE;
+  }
+
+  gst_object_unref (ringbuffer);
+
+  return result;
+}
+
+/* pull mode, downstream will call our getrange function */
+static gboolean
+gst_audio_ringbuffer_src_activate_pull (GstPad * pad, gboolean active)
+{
+  gboolean result;
+  GstAudioRingbuffer *ringbuffer;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (gst_pad_get_parent (pad));
+
+  if (active) {
+    GST_DEBUG_OBJECT (ringbuffer, "activating pull mode");
+
+    /* try to activate upstream in pull mode as well. If it fails, no problems,
+     * we'll be activated in push mode. Remember that we are pulling-through */
+    ringbuffer->pulling = gst_pad_activate_pull (ringbuffer->sinkpad, active);
+
+    ringbuffer->is_eos = FALSE;
+    ringbuffer->waiting = TRUE;
+    ringbuffer->flushing = FALSE;
+    gst_segment_init (&ringbuffer->src_segment, GST_FORMAT_BYTES);
+    result = TRUE;
+  } else {
+    GST_DEBUG_OBJECT (ringbuffer, "deactivating pull mode");
+
+    if (ringbuffer->pulling)
+      gst_pad_activate_pull (ringbuffer->sinkpad, active);
+
+    ringbuffer->pulling = FALSE;
+    ringbuffer->waiting = FALSE;
+    ringbuffer->flushing = TRUE;
+    result = TRUE;
+  }
+  gst_object_unref (ringbuffer);
+
+  return result;
+}
+
+static GstStateChangeReturn
+gst_audio_ringbuffer_change_state (GstElement * element,
+    GstStateChange transition)
+{
+  GstAudioRingbuffer *ringbuffer;
+  GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (element);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_NULL_TO_READY:
+      if (ringbuffer->buffer == NULL) {
+        ringbuffer->buffer = gst_int_ring_buffer_new ();
+        gst_object_set_parent (GST_OBJECT (ringbuffer->buffer),
+            GST_OBJECT (ringbuffer));
+        gst_ring_buffer_open_device (ringbuffer->buffer);
+      }
+      break;
+    case GST_STATE_CHANGE_READY_TO_PAUSED:
+      ringbuffer->next_sample = -1;
+      ringbuffer->last_align = -1;
+      gst_ring_buffer_set_flushing (ringbuffer->buffer, FALSE);
+      gst_ring_buffer_may_start (ringbuffer->buffer, TRUE);
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      GST_OBJECT_LOCK (ringbuffer);
+      ringbuffer->flushing = TRUE;
+      ringbuffer->waiting = FALSE;
+      g_cond_broadcast (ringbuffer->cond);
+      GST_OBJECT_UNLOCK (ringbuffer);
+
+      gst_ring_buffer_set_flushing (ringbuffer->buffer, TRUE);
+      gst_ring_buffer_may_start (ringbuffer->buffer, FALSE);
+      break;
+    default:
+      break;
+  }
+
+  ret =
+      GST_ELEMENT_CLASS (elem_parent_class)->change_state (element, transition);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      gst_ring_buffer_activate (ringbuffer->buffer, FALSE);
+      gst_ring_buffer_release (ringbuffer->buffer);
+      break;
+    case GST_STATE_CHANGE_READY_TO_NULL:
+      if (ringbuffer->buffer != NULL) {
+        gst_ring_buffer_close_device (ringbuffer->buffer);
+        gst_object_unparent (GST_OBJECT (ringbuffer->buffer));
+        ringbuffer->buffer = NULL;
+      }
+      break;
+    default:
+      break;
+  }
+
+  return ret;
+}
+
+static void
+gst_audio_ringbuffer_set_property (GObject * object,
+    guint prop_id, const GValue * value, GParamSpec * pspec)
+{
+  GstAudioRingbuffer *ringbuffer;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (object);
+
+  switch (prop_id) {
+    case PROP_BUFFER_TIME:
+      ringbuffer->buffer_time = g_value_get_int64 (value);
+      break;
+    case PROP_SEGMENT_TIME:
+      ringbuffer->segment_time = g_value_get_int64 (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static void
+gst_audio_ringbuffer_get_property (GObject * object,
+    guint prop_id, GValue * value, GParamSpec * pspec)
+{
+  GstAudioRingbuffer *ringbuffer;
+
+  ringbuffer = GST_AUDIO_RINGBUFFER (object);
+
+  switch (prop_id) {
+    case PROP_BUFFER_TIME:
+      g_value_set_int64 (value, ringbuffer->buffer_time);
+      break;
+    case PROP_SEGMENT_TIME:
+      g_value_set_int64 (value, ringbuffer->segment_time);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+  GST_DEBUG_CATEGORY_INIT (audioringbuffer_debug, "audioringbuffer", 0,
+      "Audio ringbuffer element");
+
+#ifdef ENABLE_NLS
+  GST_DEBUG ("binding text domain %s to locale dir %s", GETTEXT_PACKAGE,
+      LOCALEDIR);
+  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+#endif /* ENABLE_NLS */
+
+  return gst_element_register (plugin, "audioringbuffer", GST_RANK_NONE,
+      GST_TYPE_AUDIO_RINGBUFFER);
+}
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    "audioringbuffer",
+    "An audio ringbuffer", plugin_init, VERSION, GST_LICENSE,
+    GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)