audio: Add audio decoder/encoder base classes

Taken from http://cgit.collabora.com/git/user/manauw/gst-plugins-bad.git/log/?h=baseaudio

omx/gstbaseaudiodecoder.h

@@ -0,0 +1,262 @@
+/* GStreamer
+ * Copyright (C) 2009 Igalia S.L.
+ * Author: Iago Toral Quiroga <itoral@igalia.com>
+ * Copyright (C) 2011 Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>.
+ * Copyright (C) 2011 Nokia Corporation. All rights reserved.
+ *   Contact: Stefan Kost <stefan.kost@nokia.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.
+ */
+
+#ifndef _GST_BASE_AUDIO_DECODER_H_
+#define _GST_BASE_AUDIO_DECODER_H_
+
+#ifndef GST_USE_UNSTABLE_API
+#warning "GstBaseAudioDecoder is unstable API and may change in future."
+#warning "You can define GST_USE_UNSTABLE_API to avoid this warning."
+#endif
+
+#include <gst/gst.h>
+#include <gst/audio/gstbaseaudioutils.h>
+#include <gst/base/gstadapter.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_BASE_AUDIO_DECODER \
+  (gst_base_audio_decoder_get_type())
+#define GST_BASE_AUDIO_DECODER(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_BASE_AUDIO_DECODER,GstBaseAudioDecoder))
+#define GST_BASE_AUDIO_DECODER_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_BASE_AUDIO_DECODER,GstBaseAudioDecoderClass))
+#define GST_BASE_AUDIO_DECODER_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS((obj),GST_TYPE_BASE_AUDIO_DECODER,GstBaseAudioDecoderClass))
+#define GST_IS_BASE_AUDIO_DECODER(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_BASE_AUDIO_DECODER))
+#define GST_IS_BASE_AUDIO_DECODER_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_BASE_AUDIO_DECODER))
+
+/**
+ * GST_BASE_AUDIO_DECODER_SINK_NAME:
+ *
+ * The name of the templates for the sink pad.
+ */
+#define GST_BASE_AUDIO_DECODER_SINK_NAME    "sink"
+/**
+ * GST_BASE_AUDIO_DECODER_SRC_NAME:
+ *
+ * The name of the templates for the source pad.
+ */
+#define GST_BASE_AUDIO_DECODER_SRC_NAME     "src"
+
+/**
+ * GST_BASE_AUDIO_DECODER_SRC_PAD:
+ * @obj: base audio codec instance
+ *
+ * Gives the pointer to the source #GstPad object of the element.
+ */
+#define GST_BASE_AUDIO_DECODER_SRC_PAD(obj)         (((GstBaseAudioDecoder *) (obj))->srcpad)
+
+/**
+ * GST_BASE_AUDIO_DECODER_SINK_PAD:
+ * @obj: base audio codec instance
+ *
+ * Gives the pointer to the sink #GstPad object of the element.
+ */
+#define GST_BASE_AUDIO_DECODER_SINK_PAD(obj)        (((GstBaseAudioDecoder *) (obj))->sinkpad)
+
+typedef struct _GstBaseAudioDecoder GstBaseAudioDecoder;
+typedef struct _GstBaseAudioDecoderClass GstBaseAudioDecoderClass;
+
+typedef struct _GstBaseAudioDecoderPrivate GstBaseAudioDecoderPrivate;
+typedef struct _GstBaseAudioDecoderContext GstBaseAudioDecoderContext;
+
+/* do not use this one, use macro below */
+GstFlowReturn _gst_base_audio_decoder_error (GstBaseAudioDecoder *dec, gint weight,
+                                            GQuark domain, gint code,
+                                            gchar *txt, gchar *debug,
+                                            const gchar *file, const gchar *function,
+                                            gint line);
+
+/**
+ * GST_BASE_AUDIO_DECODER_ERROR:
+ * @el:     the base audio decoder element that generates the error
+ * @weight: element defined weight of the error, added to error count
+ * @domain: like CORE, LIBRARY, RESOURCE or STREAM (see #gstreamer-GstGError)
+ * @code:   error code defined for that domain (see #gstreamer-GstGError)
+ * @text:   the message to display (format string and args enclosed in
+ *          parentheses)
+ * @debug:  debugging information for the message (format string and args
+ *          enclosed in parentheses)
+ * @ret:    variable to receive return value
+ *
+ * Utility function that audio decoder elements can use in case they encountered
+ * a data processing error that may be fatal for the current "data unit" but
+ * need not prevent subsequent decoding.  Such errors are counted and if there
+ * are too many, as configured in the context's max_errors, the pipeline will
+ * post an error message and the application will be requested to stop further
+ * media processing.  Otherwise, it is considered a "glitch" and only a warning
+ * is logged. In either case, @ret is set to the proper value to
+ * return to upstream/caller (indicating either GST_FLOW_ERROR or GST_FLOW_OK).
+ */
+#define GST_BASE_AUDIO_DECODER_ERROR(el, w, domain, code, text, debug, ret) \
+G_STMT_START {                                                              \
+  gchar *__txt = _gst_element_error_printf text;                            \
+  gchar *__dbg = _gst_element_error_printf debug;                           \
+  GstBaseAudioDecoder *dec = GST_BASE_AUDIO_DECODER (el);                   \
+  ret = _gst_base_audio_decoder_error (dec, w, GST_ ## domain ## _ERROR,    \
+      GST_ ## domain ## _ERROR_ ## code, __txt, __dbg, __FILE__,            \
+      GST_FUNCTION, __LINE__);                                              \
+} G_STMT_END
+
+/**
+ * GstBaseAudioDecoderContext:
+ * @state: a #GstAudioState describing input audio format
+ * @eos: no (immediate) subsequent data in stream
+ * @sync: stream parsing in sync
+ * @delay: number of frames pending decoding (typically at least 1 for current)
+ * @do_plc: whether subclass is prepared to handle (packet) loss concealment
+ * @min_latency: min latency of element
+ * @max_latency: max latency of element
+ * @lookahead: decoder lookahead (in units of input rate samples)
+ *
+ * Transparent #GstBaseAudioEncoderContext data structure.
+ */
+struct _GstBaseAudioDecoderContext {
+  /* input */
+  /* (output) audio format */
+  GstAudioState state;
+
+  /* parsing state */
+  gboolean eos;
+  gboolean sync;
+
+  /* misc */
+  gint delay;
+
+  /* output */
+  gboolean do_plc;
+  gboolean do_byte_time;
+  gint max_errors;
+  /* MT-protected (with LOCK) */
+  GstClockTime min_latency;
+  GstClockTime max_latency;
+};
+
+/**
+ * GstBaseAudioDecoder:
+ *
+ * The opaque #GstBaseAudioDecoder data structure.
+ */
+struct _GstBaseAudioDecoder
+{
+  GstElement element;
+
+  /*< protected >*/
+  /* source and sink pads */
+  GstPad         *sinkpad;
+  GstPad         *srcpad;
+
+  /* MT-protected (with STREAM_LOCK) */
+  GstSegment      segment;
+  GstBaseAudioDecoderContext *ctx;
+
+  /* properties */
+  GstClockTime    latency;
+  GstClockTime    tolerance;
+  gboolean        plc;
+
+  /*< private >*/
+  GstBaseAudioDecoderPrivate *priv;
+  gpointer       _gst_reserved[GST_PADDING_LARGE];
+};
+
+/**
+ * GstBaseAudioDecoderClass:
+ * @start:          Optional.
+ *                  Called when the element starts processing.
+ *                  Allows opening external resources.
+ * @stop:           Optional.
+ *                  Called when the element stops processing.
+ *                  Allows closing external resources.
+ * @set_format:     Notifies subclass of incoming data format (caps).
+ * @parse:          Optional.
+ *                  Allows chopping incoming data into manageable units (frames)
+ *                  for subsequent decoding.  This division is at subclass
+ *                  discretion and may or may not correspond to 1 (or more)
+ *                  frames as defined by audio format.
+ * @handle_frame:   Provides input data (or NULL to clear any remaining data)
+ *                  to subclass.  Input data ref management is performed by
+ *                  base class, subclass should not care or intervene.
+ * @flush:          Optional.
+ *                  Instructs subclass to clear any codec caches and discard
+ *                  any pending samples and not yet returned encoded data.
+ *                  @hard indicates whether a FLUSH is being processed,
+ *                  or otherwise a DISCONT (or conceptually similar).
+ * @event:          Optional.
+ *                  Event handler on the sink pad. This function should return
+ *                  TRUE if the event was handled and should be discarded
+ *                  (i.e. not unref'ed).
+ * @pre_push:       Optional.
+ *                  Called just prior to pushing (encoded data) buffer downstream.
+ *                  Subclass has full discretionary access to buffer,
+ *                  and a not OK flow return will abort downstream pushing.
+ *
+ * Subclasses can override any of the available virtual methods or not, as
+ * needed. At minimum @handle_frame (and likely @set_format) needs to be
+ * overridden.
+ */
+struct _GstBaseAudioDecoderClass
+{
+  GstElementClass parent_class;
+
+  /*< public >*/
+  /* virtual methods for subclasses */
+
+  gboolean      (*start)              (GstBaseAudioDecoder *dec);
+
+  gboolean      (*stop)               (GstBaseAudioDecoder *dec);
+
+  gboolean      (*set_format)         (GstBaseAudioDecoder *dec,
+                                       GstCaps *caps);
+
+  GstFlowReturn (*parse)              (GstBaseAudioDecoder *dec,
+                                       GstAdapter *adapter,
+                                       gint *offset, gint *length);
+
+  GstFlowReturn (*handle_frame)       (GstBaseAudioDecoder *dec,
+                                       GstBuffer *buffer);
+
+  void          (*flush)              (GstBaseAudioDecoder *dec, gboolean hard);
+
+  GstFlowReturn (*pre_push)           (GstBaseAudioDecoder *dec,
+                                       GstBuffer **buffer);
+
+  gboolean      (*event)              (GstBaseAudioDecoder *dec,
+                                       GstEvent *event);
+
+  /*< private >*/
+  gpointer       _gst_reserved[GST_PADDING_LARGE];
+};
+
+GstFlowReturn     gst_base_audio_decoder_finish_frame (GstBaseAudioDecoder * dec,
+                                                       GstBuffer * buf, gint frames);
+
+GType gst_base_audio_decoder_get_type (void);
+
+G_END_DECLS
+
+#endif
+

omx/gstbaseaudioencoder.h

@@ -0,0 +1,224 @@
+/* GStreamer
+ * Copyright (C) 2011 Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>.
+ * Copyright (C) 2011 Nokia Corporation. All rights reserved.
+ *   Contact: Stefan Kost <stefan.kost@nokia.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.
+ */
+
+#ifndef __GST_BASE_AUDIO_ENCODER_H__
+#define __GST_BASE_AUDIO_ENCODER_H__
+
+#ifndef GST_USE_UNSTABLE_API
+#warning "GstBaseAudioEncoder is unstable API and may change in future."
+#warning "You can define GST_USE_UNSTABLE_API to avoid this warning."
+#endif
+
+#include <gst/gst.h>
+#include <gst/audio/gstbaseaudioutils.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_BASE_AUDIO_ENCODER		   (gst_base_audio_encoder_get_type())
+#define GST_BASE_AUDIO_ENCODER(obj)		   (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_BASE_AUDIO_ENCODER,GstBaseAudioEncoder))
+#define GST_BASE_AUDIO_ENCODER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_BASE_AUDIO_ENCODER,GstBaseAudioEncoderClass))
+#define GST_BASE_AUDIO_ENCODER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),GST_TYPE_BASE_AUDIO_ENCODER,GstBaseAudioEncoderClass))
+#define GST_IS_BASE_AUDIO_ENCODER(obj)	   (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_BASE_AUDIO_ENCODER))
+#define GST_IS_BASE_AUDIO_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_BASE_AUDIO_ENCODER))
+#define GST_BASE_AUDIO_ENCODER_CAST(obj)	((GstBaseAudioEncoder *)(obj))
+
+/**
+ * GST_BASE_AUDIO_ENCODER_SINK_NAME:
+ *
+ * the name of the templates for the sink pad
+ */
+#define GST_BASE_AUDIO_ENCODER_SINK_NAME	"sink"
+/**
+ * GST_BASE_AUDIO_ENCODER_SRC_NAME:
+ *
+ * the name of the templates for the source pad
+ */
+#define GST_BASE_AUDIO_ENCODER_SRC_NAME	        "src"
+
+/**
+ * GST_BASE_AUDIO_ENCODER_SRC_PAD:
+ * @obj: base parse instance
+ *
+ * Gives the pointer to the source #GstPad object of the element.
+ *
+ * Since: 0.10.x
+ */
+#define GST_BASE_AUDIO_ENCODER_SRC_PAD(obj)	(GST_BASE_AUDIO_ENCODER_CAST (obj)->srcpad)
+
+/**
+ * GST_BASE_AUDIO_ENCODER_SINK_PAD:
+ * @obj: base parse instance
+ *
+ * Gives the pointer to the sink #GstPad object of the element.
+ *
+ * Since: 0.10.x
+ */
+#define GST_BASE_AUDIO_ENCODER_SINK_PAD(obj)	(GST_BASE_AUDIO_ENCODER_CAST (obj)->sinkpad)
+
+/**
+ * GST_BASE_AUDIO_ENCODER_SEGMENT:
+ * @obj: base parse instance
+ *
+ * Gives the segment of the element.
+ *
+ * Since: 0.10.x
+ */
+#define GST_BASE_AUDIO_ENCODER_SEGMENT(obj)     (GST_BASE_AUDIO_ENCODER_CAST (obj)->segment)
+
+
+typedef struct _GstBaseAudioEncoder GstBaseAudioEncoder;
+typedef struct _GstBaseAudioEncoderClass GstBaseAudioEncoderClass;
+
+typedef struct _GstBaseAudioEncoderPrivate GstBaseAudioEncoderPrivate;
+typedef struct _GstBaseAudioEncoderContext GstBaseAudioEncoderContext;
+
+/**
+ * GstBaseAudioEncoderContext:
+ * @state: a #GstAudioState describing input audio format
+ * @frame_samples: number of samples (per channel) subclass needs to be handed,
+ *   or will be handed all available if 0.
+ * @frame_max: max number of frames of size @frame_bytes accepted at once
+ *  (assumed minimally 1)
+ * @min_latency: min latency of element
+ * @max_latency: max latency of element
+ * @lookahead: encoder lookahead (in units of input rate samples)
+ *
+ * Transparent #GstBaseAudioEncoderContext data structure.
+ */
+struct _GstBaseAudioEncoderContext {
+  /* input */
+  GstAudioState state;
+
+  /* output */
+  gint  frame_samples;
+  gint  frame_max;
+  gint  lookahead;
+  /* MT-protected (with LOCK) */
+  GstClockTime min_latency;
+  GstClockTime max_latency;
+};
+
+/**
+ * GstBaseAudioEncoder:
+ * @element: the parent element.
+ *
+ * The opaque #GstBaseAudioEncoder data structure.
+ */
+struct _GstBaseAudioEncoder {
+  GstElement     element;
+
+  /*< protected >*/
+  /* source and sink pads */
+  GstPad         *sinkpad;
+  GstPad         *srcpad;
+
+  /* MT-protected (with STREAM_LOCK) */
+  GstSegment      segment;
+  GstBaseAudioEncoderContext *ctx;
+
+  /* properties */
+  gint64          tolerance;
+  gboolean        perfect_ts;
+  gboolean        hard_resync;
+  gboolean        granule;
+
+  /*< private >*/
+  GstBaseAudioEncoderPrivate *priv;
+  gpointer       _gst_reserved[GST_PADDING_LARGE];
+};
+
+/**
+ * GstBaseAudioEncoderClass:
+ * @start:          Optional.
+ *                  Called when the element starts processing.
+ *                  Allows opening external resources.
+ * @stop:           Optional.
+ *                  Called when the element stops processing.
+ *                  Allows closing external resources.
+ * @set_format:     Notifies subclass of incoming data format.
+ *                  GstBaseAudioEncoderContext fields have already been
+ *                  set according to provided caps.
+ * @handle_frame:   Provides input samples (or NULL to clear any remaining data)
+ *                  according to directions as provided by subclass in the
+ *                  #GstBaseAudioEncoderContext.  Input data ref management
+ *                  is performed by base class, subclass should not care or
+ *                  intervene.
+ * @flush:          Optional.
+ *                  Instructs subclass to clear any codec caches and discard
+ *                  any pending samples and not yet returned encoded data.
+ * @event:          Optional.
+ *                  Event handler on the sink pad. This function should return
+ *                  TRUE if the event was handled and should be discarded
+ *                  (i.e. not unref'ed).
+ * @pre_push:       Optional.
+ *                  Called just prior to pushing (encoded data) buffer downstream.
+ *                  Subclass has full discretionary access to buffer,
+ *                  and a not OK flow return will abort downstream pushing.
+ * @getcaps:        Optional.
+ *                  Allows for a custom sink getcaps implementation (e.g.
+ *                  for multichannel input specification).  If not implemented,
+ *                  default returns gst_base_audio_encoder_proxy_getcaps
+ *                  applied to sink template caps.
+ *
+ * Subclasses can override any of the available virtual methods or not, as
+ * needed. At minimum @set_format and @handle_frame needs to be overridden.
+ */
+struct _GstBaseAudioEncoderClass {
+  GstElementClass parent_class;
+
+  /*< public >*/
+  /* virtual methods for subclasses */
+
+  gboolean      (*start)              (GstBaseAudioEncoder *enc);
+
+  gboolean      (*stop)               (GstBaseAudioEncoder *enc);
+
+  gboolean      (*set_format)         (GstBaseAudioEncoder *enc,
+                                       GstAudioState *state);
+
+  GstFlowReturn (*handle_frame)       (GstBaseAudioEncoder *enc,
+                                       GstBuffer *buffer);
+
+  void          (*flush)              (GstBaseAudioEncoder *enc);
+
+  GstFlowReturn (*pre_push)           (GstBaseAudioEncoder *enc,
+                                       GstBuffer **buffer);
+
+  gboolean      (*event)              (GstBaseAudioEncoder *enc,
+                                       GstEvent *event);
+
+  GstCaps *     (*getcaps)            (GstBaseAudioEncoder *enc);
+
+  /*< private >*/
+  gpointer       _gst_reserved[GST_PADDING_LARGE];
+};
+
+GType           gst_base_audio_encoder_get_type         (void);
+
+GstFlowReturn   gst_base_audio_encoder_finish_frame (GstBaseAudioEncoder * enc,
+                                        GstBuffer *buffer, gint samples);
+
+GstCaps *       gst_base_audio_encoder_proxy_getcaps (GstBaseAudioEncoder * enc,
+                                                      GstCaps * caps);
+
+G_END_DECLS
+
+#endif /* __GST_BASE_AUDIO_ENCODER_H__ */

omx/gstbaseaudioutils.c

@@ -0,0 +1,315 @@
+/* GStreamer
+ * Copyright (C) 2011 Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>.
+ * Copyright (C) 2011 Nokia Corporation. All rights reserved.
+ *   Contact: Stefan Kost <stefan.kost@nokia.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.
+ */
+
+#include "gstbaseaudioutils.h"
+
+#include <gst/gst.h>
+#include <gst/audio/multichannel.h>
+
+
+#define CHECK_VALUE(var, val) \
+G_STMT_START { \
+  if (!res) \
+    goto fail; \
+  if (var != val) \
+    changed = TRUE; \
+  var = val; \
+} G_STMT_END
+
+/**
+ * gst_base_audio_parse_caps:
+ * @caps: a #GstCaps
+ * @state: a #GstAudioState
+ * @changed: whether @caps introduced a change in current @state
+ *
+ * Parses audio format as represented by @caps into a more concise form
+ * as represented by @state, while checking if for changes to currently
+ * defined audio format.
+ *
+ * Returns: TRUE if parsing succeeded, otherwise FALSE
+ */
+gboolean
+gst_base_audio_parse_caps (GstCaps * caps, GstAudioState * state,
+    gboolean * _changed)
+{
+  gboolean res = TRUE, changed = FALSE;
+  GstStructure *s;
+  gboolean vb;
+  gint vi;
+
+  g_return_val_if_fail (caps != NULL, FALSE);
+  g_return_val_if_fail (gst_caps_is_fixed (caps), FALSE);
+
+  s = gst_caps_get_structure (caps, 0);
+  if (gst_structure_has_name (s, "audio/x-raw-int"))
+    state->is_int = TRUE;
+  else if (gst_structure_has_name (s, "audio/x-raw-float"))
+    state->is_int = FALSE;
+  else
+    goto fail;
+
+  res = gst_structure_get_int (s, "rate", &vi);
+  CHECK_VALUE (state->rate, vi);
+  res &= gst_structure_get_int (s, "channels", &vi);
+  CHECK_VALUE (state->channels, vi);
+  res &= gst_structure_get_int (s, "width", &vi);
+  CHECK_VALUE (state->width, vi);
+  res &= (!state->is_int || gst_structure_get_int (s, "depth", &vi));
+  CHECK_VALUE (state->depth, vi);
+  res &= gst_structure_get_int (s, "endianness", &vi);
+  CHECK_VALUE (state->endian, vi);
+  res &= (!state->is_int || gst_structure_get_boolean (s, "signed", &vb));
+  CHECK_VALUE (state->sign, vb);
+
+  state->bpf = (state->width / 8) * state->channels;
+  GST_LOG ("bpf: %d", state->bpf);
+  if (!state->bpf)
+    goto fail;
+
+  g_free (state->channel_pos);
+  state->channel_pos = gst_audio_get_channel_positions (s);
+
+  if (_changed)
+    *_changed = changed;
+
+  return res;
+
+  /* ERRORS */
+fail:
+  {
+    /* there should not be caps out there that fail parsing ... */
+    GST_WARNING ("failed to parse caps %" GST_PTR_FORMAT, caps);
+    return res;
+  }
+}
+
+/**
+ * gst_base_audio_add_streamheader:
+ * @caps: a #GstCaps
+ * @buf: header buffers
+ *
+ * Adds given buffers to an array of buffers set as streamheader field
+ * on the given @caps.  List of buffer arguments must be NULL-terminated.
+ *
+ * Returns: input caps with a streamheader field added, or NULL if some error
+ */
+GstCaps *
+gst_base_audio_add_streamheader (GstCaps * caps, GstBuffer * buf, ...)
+{
+  GstStructure *structure = NULL;
+  va_list va;
+  GValue array = { 0 };
+  GValue value = { 0 };
+
+  g_return_val_if_fail (caps != NULL, NULL);
+  g_return_val_if_fail (gst_caps_is_fixed (caps), NULL);
+
+  caps = gst_caps_make_writable (caps);
+  structure = gst_caps_get_structure (caps, 0);
+
+  g_value_init (&array, GST_TYPE_ARRAY);
+
+  va_start (va, buf);
+  /* put buffers in a fixed list */
+  while (buf) {
+    g_assert (gst_buffer_is_metadata_writable (buf));
+
+    /* mark buffer */
+    GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
+
+    g_value_init (&value, GST_TYPE_BUFFER);
+    buf = gst_buffer_copy (buf);
+    GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
+    gst_value_set_buffer (&value, buf);
+    gst_buffer_unref (buf);
+    gst_value_array_append_value (&array, &value);
+    g_value_unset (&value);
+
+    buf = va_arg (va, GstBuffer *);
+  }
+
+  gst_structure_set_value (structure, "streamheader", &array);
+  g_value_unset (&array);
+
+  return caps;
+}
+
+/**
+ * gst_base_audio_encoded_audio_convert:
+ * @fmt: audio format of the encoded audio
+ * @bytes: number of encoded bytes
+ * @samples: number of encoded samples
+ * @src_format: source format
+ * @src_value: source value
+ * @dest_format: destination format
+ * @dest_value: destination format
+ *
+ * Helper function to convert @src_value in @src_format to @dest_value in
+ * @dest_format for encoded audio data.  Conversion is possible between
+ * BYTE and TIME format by using estimated bitrate based on
+ * @samples and @bytes (and @fmt).
+ */
+gboolean
+gst_base_audio_encoded_audio_convert (GstAudioState * fmt,
+    gint64 bytes, gint64 samples, GstFormat src_format,
+    gint64 src_value, GstFormat * dest_format, gint64 * dest_value)
+{
+  gboolean res = FALSE;
+
+  g_return_val_if_fail (dest_format != NULL, FALSE);
+  g_return_val_if_fail (dest_value != NULL, FALSE);
+
+  if (G_UNLIKELY (src_format == *dest_format || src_value == 0 ||
+          src_value == -1)) {
+    if (dest_value)
+      *dest_value = src_value;
+    return TRUE;
+  }
+
+  if (samples == 0 || bytes == 0 || fmt->rate == 0) {
+    GST_DEBUG ("not enough metadata yet to convert");
+    goto exit;
+  }
+
+  bytes *= fmt->rate;
+
+  switch (src_format) {
+    case GST_FORMAT_BYTES:
+      switch (*dest_format) {
+        case GST_FORMAT_TIME:
+          *dest_value = gst_util_uint64_scale (src_value,
+              GST_SECOND * samples, bytes);
+          res = TRUE;
+          break;
+        default:
+          res = FALSE;
+      }
+      break;
+    case GST_FORMAT_TIME:
+      switch (*dest_format) {
+        case GST_FORMAT_BYTES:
+          *dest_value = gst_util_uint64_scale (src_value, bytes,
+              samples * GST_SECOND);
+          res = TRUE;
+          break;
+        default:
+          res = FALSE;
+      }
+      break;
+    default:
+      res = FALSE;
+  }
+
+exit:
+  return res;
+}
+
+/**
+ * gst_base_audio_raw_audio_convert:
+ * @fmt: audio format of the encoded audio
+ * @src_format: source format
+ * @src_value: source value
+ * @dest_format: destination format
+ * @dest_value: destination format
+ *
+ * Helper function to convert @src_value in @src_format to @dest_value in
+ * @dest_format for encoded audio data.  Conversion is possible between
+ * BYTE, DEFAULT and TIME format based on audio characteristics provided
+ * by @fmt.
+ */
+gboolean
+gst_base_audio_raw_audio_convert (GstAudioState * fmt, GstFormat src_format,
+    gint64 src_value, GstFormat * dest_format, gint64 * dest_value)
+{
+  gboolean res = FALSE;
+  guint scale = 1;
+  gint bytes_per_sample, rate, byterate;
+
+  g_return_val_if_fail (dest_format != NULL, FALSE);
+  g_return_val_if_fail (dest_value != NULL, FALSE);
+
+  if (G_UNLIKELY (src_format == *dest_format || src_value == 0 ||
+          src_value == -1)) {
+    if (dest_value)
+      *dest_value = src_value;
+    return TRUE;
+  }
+
+  bytes_per_sample = fmt->bpf;
+  rate = fmt->rate;
+  byterate = bytes_per_sample * rate;
+
+  if (G_UNLIKELY (bytes_per_sample == 0 || rate == 0)) {
+    GST_DEBUG ("not enough metadata yet to convert");
+    goto exit;
+  }
+
+  switch (src_format) {
+    case GST_FORMAT_BYTES:
+      switch (*dest_format) {
+        case GST_FORMAT_DEFAULT:
+          *dest_value = src_value / bytes_per_sample;
+          res = TRUE;
+          break;
+        case GST_FORMAT_TIME:
+          *dest_value =
+              gst_util_uint64_scale_int (src_value, GST_SECOND, byterate);
+          res = TRUE;
+          break;
+        default:
+          res = FALSE;
+      }
+      break;
+    case GST_FORMAT_DEFAULT:
+      switch (*dest_format) {
+        case GST_FORMAT_BYTES:
+          *dest_value = src_value * bytes_per_sample;
+          res = TRUE;
+          break;
+        case GST_FORMAT_TIME:
+          *dest_value = gst_util_uint64_scale_int (src_value, GST_SECOND, rate);
+          res = TRUE;
+          break;
+        default:
+          res = FALSE;
+      }
+      break;
+    case GST_FORMAT_TIME:
+      switch (*dest_format) {
+        case GST_FORMAT_BYTES:
+          scale = bytes_per_sample;
+          /* fallthrough */
+        case GST_FORMAT_DEFAULT:
+          *dest_value = gst_util_uint64_scale_int (src_value,
+              scale * rate, GST_SECOND);
+          res = TRUE;
+          break;
+        default:
+          res = FALSE;
+      }
+      break;
+    default:
+      res = FALSE;
+  }
+
+exit:
+  return res;
+}

omx/gstbaseaudioutils.h

@@ -0,0 +1,74 @@
+/* GStreamer
+ * Copyright (C) 2011 Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>.
+ * Copyright (C) 2011 Nokia Corporation. All rights reserved.
+ *   Contact: Stefan Kost <stefan.kost@nokia.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.
+ */
+
+#ifndef _GST_BASE_AUDIO_UTILS_H_
+#define _GST_BASE_AUDIO_UTILS_H_
+
+#ifndef GST_USE_UNSTABLE_API
+#warning "Base audio utils provide unstable API and may change in future."
+#warning "You can define GST_USE_UNSTABLE_API to avoid this warning."
+#endif
+
+#include <gst/gst.h>
+#include <gst/audio/multichannel.h>
+
+G_BEGIN_DECLS
+
+/**
+ * GstAudioState:
+ * @is_int: whether sample data is int or float
+ * @rate: rate of sample data
+ * @channels: number of channels in sample data
+ * @width: width (in bits) of sample data
+ * @depth: used bits in sample data (if integer)
+ * @sign: sign of sample data (if integer)
+ * @endian: endianness of sample data
+ * @bpf: bytes per audio frame
+ */
+typedef struct _GstAudioState {
+  gboolean is_int;
+  gint  rate;
+  gint  channels;
+  gint  width;
+  gint  depth;
+  gboolean sign;
+  gint  endian;
+  GstAudioChannelPosition *channel_pos;
+
+  gint  bpf;
+} GstAudioState;
+
+gboolean gst_base_audio_parse_caps (GstCaps * caps,
+    GstAudioState * state, gboolean * changed);
+
+GstCaps *gst_base_audio_add_streamheader (GstCaps * caps, GstBuffer * buf, ...);
+
+gboolean gst_base_audio_encoded_audio_convert (GstAudioState * fmt,
+    gint64 bytes, gint64 samples, GstFormat src_format,
+    gint64 src_value, GstFormat * dest_format, gint64 * dest_value);
+
+gboolean gst_base_audio_raw_audio_convert (GstAudioState * fmt, GstFormat src_format,
+    gint64 src_value, GstFormat * dest_format, gint64 * dest_value);
+
+G_END_DECLS
+
+#endif
+