/* GStreamer

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

 *                    2000 Wim Taymans <wtay@chello.be>

 *                    2005 Wim Taymans <wim@fluendo.com>

 *                    2007 Andy Wingo <wingo at pobox.com>

 *                    2008 Sebastian Dröge <slomo@circular-chaos.rg>

 *

 * interleave.c: interleave samples, mostly based on adder.

 *

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

 */

/* TODO:

 *       - handle caps changes

 *       - handle more queries/events

 */

/**

 * SECTION:element-interleave

 * @see_also: deinterleave

 *

 * Merges separate mono inputs into one interleaved stream.

 * 

 * This element handles all raw floating point sample formats and all signed integer sample formats. The first

 * caps on one of the sinkpads will set the caps of the output so usually an audioconvert element should be

 * placed before every sinkpad of interleave.

 * 

 * It's possible to change the number of channels while the pipeline is running by adding or removing

 * some of the request pads but this will change the caps of the output buffers. Changing the input

 * caps is _not_ supported yet.

 * 

 * The channel number of every sinkpad in the out can be retrieved from the "channel" property of the pad.

 * 

 * <refsect2>

 * <title>Example launch line</title>

 * |[

 * gst-launch-1.0 filesrc location=file.mp3 ! decodebin ! audioconvert ! "audio/x-raw,channels=2" ! deinterleave name=d  interleave name=i ! audioconvert ! wavenc ! filesink location=test.wav    d.src_0 ! queue ! audioconvert ! i.sink_1    d.src_1 ! queue ! audioconvert ! i.sink_0

 * ]| Decodes and deinterleaves a Stereo MP3 file into separate channels and

 * then interleaves the channels again to a WAV file with the channels

 * exchanged.

 * |[

 * gst-launch-1.0 interleave name=i ! audioconvert ! wavenc ! filesink location=file.wav  filesrc location=file1.wav ! decodebin ! audioconvert ! "audio/x-raw,channels=1,channel-mask=(bitmask)0x1" ! queue ! i.sink_0   filesrc location=file2.wav ! decodebin ! audioconvert ! "audio/x-raw,channels=1,channel-mask=(bitmask)0x2" ! queue ! i.sink_1

 * ]| Interleaves two Mono WAV files to a single Stereo WAV file. Having

 * channel-masks defined in the sink pads ensures a sane mapping of the mono

 * streams into the stereo stream. NOTE: the proper way to map channels in

 * code is by using the channel-positions property of the interleave element.

 * </refsect2>

 */

/* FIXME 0.11: suppress warnings for deprecated API such as GValueArray

 * with newer GLib versions (>= 2.31.0) */

#define GLIB_DISABLE_DEPRECATION_WARNINGS

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include <gst/gst.h>

#include <string.h>

#include "interleave.h"

#include <gst/audio/audio.h>

#include <gst/audio/audio-enumtypes.h>

GST_DEBUG_CATEGORY_STATIC (gst_interleave_debug);

#define GST_CAT_DEFAULT gst_interleave_debug

static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink_%u",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS ("audio/x-raw, "

        "rate = (int) [ 1, MAX ], "

        "channels = (int) 1, "

        "format = (string) " GST_AUDIO_FORMATS_ALL ", "

        "layout = (string) {non-interleaved, interleaved}")

    );

static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("audio/x-raw, "

        "rate = (int) [ 1, MAX ], "

        "channels = (int) [ 1, MAX ], "

        "format = (string) " GST_AUDIO_FORMATS_ALL ", "

        "layout = (string) interleaved")

    );

#define MAKE_FUNC(type) \

static void interleave_##type (guint##type *out, guint##type *in, \

    guint stride, guint nframes) \

{ \

  gint i; \

  \

  for (i = 0; i < nframes; i++) { \

    *out = in[i]; \

    out += stride; \

  } \

}

MAKE_FUNC (8);

MAKE_FUNC (16);

MAKE_FUNC (32);

MAKE_FUNC (64);

static void

interleave_24 (guint8 * out, guint8 * in, guint stride, guint nframes)

{

  gint i;

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

    memcpy (out, in, 3);

    out += stride * 3;

    in += 3;

  }

}

typedef struct

{

  GstPad parent;

  guint channel;

} GstInterleavePad;

enum

{

  PROP_PAD_0,

  PROP_PAD_CHANNEL

};

static void gst_interleave_pad_class_init (GstPadClass * klass);

#define GST_TYPE_INTERLEAVE_PAD (gst_interleave_pad_get_type())

#define GST_INTERLEAVE_PAD(pad) (G_TYPE_CHECK_INSTANCE_CAST((pad),GST_TYPE_INTERLEAVE_PAD,GstInterleavePad))

#define GST_INTERLEAVE_PAD_CAST(pad) ((GstInterleavePad *) pad)

#define GST_IS_INTERLEAVE_PAD(pad) (G_TYPE_CHECK_INSTANCE_TYPE((pad),GST_TYPE_INTERLEAVE_PAD))

static GType

gst_interleave_pad_get_type (void)

{

  static GType type = 0;

  if (G_UNLIKELY (type == 0)) {

    type = g_type_register_static_simple (GST_TYPE_PAD,

        g_intern_static_string ("GstInterleavePad"), sizeof (GstPadClass),

        (GClassInitFunc) gst_interleave_pad_class_init,

        sizeof (GstInterleavePad), NULL, 0);

  }

  return type;

}

static void

gst_interleave_pad_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec)

{

  GstInterleavePad *self = GST_INTERLEAVE_PAD (object);

  switch (prop_id) {

    case PROP_PAD_CHANNEL:

      g_value_set_uint (value, self->channel);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_interleave_pad_class_init (GstPadClass * klass)

{

  GObjectClass *gobject_class = (GObjectClass *) klass;

  gobject_class->get_property = gst_interleave_pad_get_property;

  g_object_class_install_property (gobject_class,

      PROP_PAD_CHANNEL,

      g_param_spec_uint ("channel",

          "Channel number",

          "Number of the channel of this pad in the output", 0, G_MAXUINT, 0,

          G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

}

#define gst_interleave_parent_class parent_class

G_DEFINE_TYPE (GstInterleave, gst_interleave, GST_TYPE_ELEMENT);

enum

{

  PROP_0,

  PROP_CHANNEL_POSITIONS,

  PROP_CHANNEL_POSITIONS_FROM_INPUT

};

static void gst_interleave_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec);

static void gst_interleave_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec);

static GstPad *gst_interleave_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * name, const GstCaps * caps);

static void gst_interleave_release_pad (GstElement * element, GstPad * pad);

static GstStateChangeReturn gst_interleave_change_state (GstElement * element,

    GstStateChange transition);

static gboolean gst_interleave_src_query (GstPad * pad, GstObject * parent,

    GstQuery * query);

static gboolean gst_interleave_src_event (GstPad * pad, GstObject * parent,

    GstEvent * event);

static gboolean gst_interleave_sink_event (GstCollectPads * pads,

    GstCollectData * data, GstEvent * event, gpointer user_data);

static gboolean gst_interleave_sink_query (GstCollectPads * pads,

    GstCollectData * data, GstQuery * query, gpointer user_data);

static gboolean gst_interleave_sink_setcaps (GstInterleave * self,

    GstPad * pad, const GstCaps * caps, const GstAudioInfo * info);

static GstCaps *gst_interleave_sink_getcaps (GstPad * pad, GstInterleave * self,

    GstCaps * filter);

static GstFlowReturn gst_interleave_collected (GstCollectPads * pads,

    GstInterleave * self);

static void

gst_interleave_finalize (GObject * object)

{

  GstInterleave *self = GST_INTERLEAVE (object);

  if (self->collect) {

    gst_object_unref (self->collect);

    self->collect = NULL;

  }

  if (self->channel_positions

      && self->channel_positions != self->input_channel_positions) {

    g_value_array_free (self->channel_positions);

    self->channel_positions = NULL;

  }

  if (self->input_channel_positions) {

    g_value_array_free (self->input_channel_positions);

    self->input_channel_positions = NULL;

  }

  gst_caps_replace (&self->sinkcaps, NULL);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static gint

compare_positions (gconstpointer a, gconstpointer b, gpointer user_data)

{

  const gint i = *(const gint *) a;

  const gint j = *(const gint *) b;

  const gint *pos = (const gint *) user_data;

  if (pos[i] < pos[j])

    return -1;

  else if (pos[i] > pos[j])

    return 1;

  else

    return 0;

}

static gboolean

gst_interleave_channel_positions_to_mask (GValueArray * positions,

    gint default_ordering_map[64], guint64 * mask)

{

  gint i;

  guint channels;

  GstAudioChannelPosition *pos;

  gboolean ret;

  channels = positions->n_values;

  pos = g_new (GstAudioChannelPosition, channels);

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

    GValue *val;

    val = g_value_array_get_nth (positions, i);

    pos[i] = g_value_get_enum (val);

  }

  /* sort the default ordering map according to the position order */

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

    default_ordering_map[i] = i;

  }

  g_qsort_with_data (default_ordering_map, channels,

      sizeof (*default_ordering_map), compare_positions, pos);

  ret = gst_audio_channel_positions_to_mask (pos, channels, FALSE, mask);

  g_free (pos);

  return ret;

}

static void

gst_interleave_set_channel_positions (GstInterleave * self, GstStructure * s)

{

  if (self->channels <= 64 &&

      self->channel_positions != NULL &&

      self->channels == self->channel_positions->n_values) {

    if (!gst_interleave_channel_positions_to_mask (self->channel_positions,

            self->default_channels_ordering_map, &self->channel_mask)) {

      GST_WARNING_OBJECT (self, "Invalid channel positions, using NONE");

      self->channel_mask = 0;

    }

  } else {

    self->channel_mask = 0;

    if (self->channels <= 64) {

      GST_WARNING_OBJECT (self, "Using NONE channel positions");

    }

  }

  gst_structure_set (s, "channel-mask", GST_TYPE_BITMASK, self->channel_mask,

      NULL);

}

static void

gst_interleave_send_stream_start (GstInterleave * self)

{

  GST_OBJECT_LOCK (self);

  if (self->send_stream_start) {

    gchar s_id[32];

    self->send_stream_start = FALSE;

    GST_OBJECT_UNLOCK (self);

    /* stream-start (FIXME: create id based on input ids) */

    g_snprintf (s_id, sizeof (s_id), "interleave-%08x", g_random_int ());

    gst_pad_push_event (self->src, gst_event_new_stream_start (s_id));

  } else {

    GST_OBJECT_UNLOCK (self);

  }

}

static void

gst_interleave_class_init (GstInterleaveClass * klass)

{

  GstElementClass *gstelement_class;

  GObjectClass *gobject_class;

  gobject_class = G_OBJECT_CLASS (klass);

  gstelement_class = GST_ELEMENT_CLASS (klass);

  GST_DEBUG_CATEGORY_INIT (gst_interleave_debug, "interleave", 0,

      "interleave element");

  gst_element_class_set_static_metadata (gstelement_class, "Audio interleaver",

      "Filter/Converter/Audio",

      "Folds many mono channels into one interleaved audio stream",

      "Andy Wingo <wingo at pobox.com>, "

      "Sebastian Dröge <slomo@circular-chaos.org>");

  gst_element_class_add_static_pad_template (gstelement_class, &sink_template);

  gst_element_class_add_static_pad_template (gstelement_class, &src_template);

  /* Reference GstInterleavePad class to have the type registered from

   * a threadsafe context

   */

  g_type_class_ref (GST_TYPE_INTERLEAVE_PAD);

  gobject_class->finalize = gst_interleave_finalize;

  gobject_class->set_property = gst_interleave_set_property;

  gobject_class->get_property = gst_interleave_get_property;

  /**

   * GstInterleave:channel-positions

   * 

   * Channel positions: This property controls the channel positions

   * that are used on the src caps. The number of elements should be

   * the same as the number of sink pads and the array should contain

   * a valid list of channel positions. The n-th element of the array

   * is the position of the n-th sink pad.

   *

   * These channel positions will only be used if they're valid and the

   * number of elements is the same as the number of channels. If this

   * is not given a NONE layout will be used.

   *

   */

  g_object_class_install_property (gobject_class, PROP_CHANNEL_POSITIONS,

      g_param_spec_value_array ("channel-positions", "Channel positions",

          "Channel positions used on the output",

          g_param_spec_enum ("channel-position", "Channel position",

              "Channel position of the n-th input",

              GST_TYPE_AUDIO_CHANNEL_POSITION,

              GST_AUDIO_CHANNEL_POSITION_NONE,

              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS),

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstInterleave:channel-positions-from-input

   * 

   * Channel positions from input: If this property is set to %TRUE the channel

   * positions will be taken from the input caps if valid channel positions for

   * the output can be constructed from them. If this is set to %TRUE setting the

   * channel-positions property overwrites this property again.

   *

   */

  g_object_class_install_property (gobject_class,

      PROP_CHANNEL_POSITIONS_FROM_INPUT,

      g_param_spec_boolean ("channel-positions-from-input",

          "Channel positions from input",

          "Take channel positions from the input", TRUE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  gstelement_class->request_new_pad =

      GST_DEBUG_FUNCPTR (gst_interleave_request_new_pad);

  gstelement_class->release_pad =

      GST_DEBUG_FUNCPTR (gst_interleave_release_pad);

  gstelement_class->change_state =

      GST_DEBUG_FUNCPTR (gst_interleave_change_state);

}

static void

gst_interleave_init (GstInterleave * self)

{

  self->src = gst_pad_new_from_static_template (&src_template, "src");

  gst_pad_set_query_function (self->src,

      GST_DEBUG_FUNCPTR (gst_interleave_src_query));

  gst_pad_set_event_function (self->src,

      GST_DEBUG_FUNCPTR (gst_interleave_src_event));

  gst_element_add_pad (GST_ELEMENT (self), self->src);

  self->collect = gst_collect_pads_new ();

  gst_collect_pads_set_function (self->collect,

      (GstCollectPadsFunction) gst_interleave_collected, self);

  self->input_channel_positions = g_value_array_new (0);

  self->channel_positions_from_input = TRUE;

  self->channel_positions = self->input_channel_positions;

}

static void

gst_interleave_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstInterleave *self = GST_INTERLEAVE (object);

  switch (prop_id) {

    case PROP_CHANNEL_POSITIONS:

      if (self->channel_positions &&

          self->channel_positions != self->input_channel_positions)

        g_value_array_free (self->channel_positions);

      self->channel_positions = g_value_dup_boxed (value);

      self->channel_positions_from_input = FALSE;

      break;

    case PROP_CHANNEL_POSITIONS_FROM_INPUT:

      self->channel_positions_from_input = g_value_get_boolean (value);

      if (self->channel_positions_from_input) {

        if (self->channel_positions &&

            self->channel_positions != self->input_channel_positions)

          g_value_array_free (self->channel_positions);

        self->channel_positions = self->input_channel_positions;

      }

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_interleave_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstInterleave *self = GST_INTERLEAVE (object);

  switch (prop_id) {

    case PROP_CHANNEL_POSITIONS:

      g_value_set_boxed (value, self->channel_positions);

      break;

    case PROP_CHANNEL_POSITIONS_FROM_INPUT:

      g_value_set_boolean (value, self->channel_positions_from_input);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static GstPad *

gst_interleave_request_new_pad (GstElement * element, GstPadTemplate * templ,

    const gchar * req_name, const GstCaps * caps)

{

  GstInterleave *self = GST_INTERLEAVE (element);

  GstPad *new_pad;

  gchar *pad_name;

  gint channel, padnumber;

  GValue val = { 0, };

  if (templ->direction != GST_PAD_SINK)

    goto not_sink_pad;

  padnumber = g_atomic_int_add (&self->padcounter, 1);

  channel = g_atomic_int_add (&self->channels, 1);

  if (!self->channel_positions_from_input)

    channel = padnumber;

  pad_name = g_strdup_printf ("sink_%u", padnumber);

  new_pad = GST_PAD_CAST (g_object_new (GST_TYPE_INTERLEAVE_PAD,

          "name", pad_name, "direction", templ->direction,

          "template", templ, NULL));

  GST_INTERLEAVE_PAD_CAST (new_pad)->channel = channel;

  GST_DEBUG_OBJECT (self, "requested new pad %s", pad_name);

  g_free (pad_name);

  gst_pad_use_fixed_caps (new_pad);

  gst_collect_pads_add_pad (self->collect, new_pad, sizeof (GstCollectData),

      NULL, TRUE);

  gst_collect_pads_set_event_function (self->collect,

      (GstCollectPadsEventFunction)

      GST_DEBUG_FUNCPTR (gst_interleave_sink_event), self);

  gst_collect_pads_set_query_function (self->collect,

      (GstCollectPadsQueryFunction)

      GST_DEBUG_FUNCPTR (gst_interleave_sink_query), self);

  if (!gst_element_add_pad (element, new_pad))

    goto could_not_add;

  g_value_init (&val, GST_TYPE_AUDIO_CHANNEL_POSITION);

  g_value_set_enum (&val, GST_AUDIO_CHANNEL_POSITION_NONE);

  self->input_channel_positions =

      g_value_array_append (self->input_channel_positions, &val;;

  g_value_unset (&val;;

  /* Update the src caps if we already have them */

  if (self->sinkcaps) {

    GstCaps *srccaps;

    GstStructure *s;

    /* Take lock to make sure processing finishes first */

    GST_OBJECT_LOCK (self->collect);

    srccaps = gst_caps_copy (self->sinkcaps);

    s = gst_caps_get_structure (srccaps, 0);

    gst_structure_set (s, "channels", G_TYPE_INT, self->channels, NULL);

    gst_interleave_set_channel_positions (self, s);

    gst_interleave_send_stream_start (self);

    gst_pad_set_caps (self->src, srccaps);

    gst_caps_unref (srccaps);

    GST_OBJECT_UNLOCK (self->collect);

  }

  return new_pad;

  /* errors */

not_sink_pad:

  {

    g_warning ("interleave: requested new pad that is not a SINK pad\n");

    return NULL;

  }

could_not_add:

  {

    GST_DEBUG_OBJECT (self, "could not add pad %s", GST_PAD_NAME (new_pad));

    gst_collect_pads_remove_pad (self->collect, new_pad);

    gst_object_unref (new_pad);

    return NULL;

  }

}

static void

gst_interleave_release_pad (GstElement * element, GstPad * pad)

{

  GstInterleave *self = GST_INTERLEAVE (element);

  GList *l;

  GstAudioChannelPosition position;

  g_return_if_fail (GST_IS_INTERLEAVE_PAD (pad));

  /* Take lock to make sure we're not changing this when processing buffers */

  GST_OBJECT_LOCK (self->collect);

  g_atomic_int_add (&self->channels, -1);

  if (gst_pad_has_current_caps (pad))

    g_atomic_int_add (&self->configured_sinkpads_counter, -1);

  position = GST_INTERLEAVE_PAD_CAST (pad)->channel;

  g_value_array_remove (self->input_channel_positions, position);

  /* Update channel numbers */

  GST_OBJECT_LOCK (self);

  for (l = GST_ELEMENT_CAST (self)->sinkpads; l != NULL; l = l->next) {

    GstInterleavePad *ipad = GST_INTERLEAVE_PAD (l->data);

    if (GST_INTERLEAVE_PAD_CAST (pad)->channel < ipad->channel)

      ipad->channel--;

  }

  GST_OBJECT_UNLOCK (self);

  /* Update the src caps if we already have them */

  if (self->sinkcaps) {

    if (self->channels > 0) {

      GstCaps *srccaps;

      GstStructure *s;

      srccaps = gst_caps_copy (self->sinkcaps);

      s = gst_caps_get_structure (srccaps, 0);

      gst_structure_set (s, "channels", G_TYPE_INT, self->channels, NULL);

      gst_interleave_set_channel_positions (self, s);

      gst_interleave_send_stream_start (self);

      gst_pad_set_caps (self->src, srccaps);

      gst_caps_unref (srccaps);

    } else {

      gst_caps_replace (&self->sinkcaps, NULL);

    }

  }

  GST_OBJECT_UNLOCK (self->collect);

  gst_collect_pads_remove_pad (self->collect, pad);

  gst_element_remove_pad (element, pad);

}

static GstStateChangeReturn

gst_interleave_change_state (GstElement * element, GstStateChange transition)

{

  GstInterleave *self;

  GstStateChangeReturn ret;

  self = GST_INTERLEAVE (element);

  switch (transition) {

    case GST_STATE_CHANGE_NULL_TO_READY:

      break;

    case GST_STATE_CHANGE_READY_TO_PAUSED:

      self->timestamp = 0;

      self->offset = 0;

      gst_event_replace (&self->pending_segment, NULL);

      self->send_stream_start = TRUE;

      gst_collect_pads_start (self->collect);

      break;

    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:

      break;

    default:

      break;

  }

  /* Stop before calling the parent's state change function as

   * GstCollectPads might take locks and we would deadlock in that

   * case

   */

  if (transition == GST_STATE_CHANGE_PAUSED_TO_READY)

    gst_collect_pads_stop (self->collect);

  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);

  switch (transition) {

    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:

      break;

    case GST_STATE_CHANGE_PAUSED_TO_READY:

      gst_caps_replace (&self->sinkcaps, NULL);

      gst_event_replace (&self->pending_segment, NULL);

      break;

    case GST_STATE_CHANGE_READY_TO_NULL:

      break;

    default:

      break;

  }

  return ret;

}

static void

__remove_channels (GstCaps * caps)

{

  GstStructure *s;

  gint i, size;

  size = gst_caps_get_size (caps);

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

    s = gst_caps_get_structure (caps, i);

    gst_structure_remove_field (s, "channel-mask");

    gst_structure_remove_field (s, "channels");

  }

}

static void

__set_channels (GstCaps * caps, gint channels)

{

  GstStructure *s;

  gint i, size;

  size = gst_caps_get_size (caps);

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

    s = gst_caps_get_structure (caps, i);

    if (channels > 0)

      gst_structure_set (s, "channels", G_TYPE_INT, channels, NULL);

    else

      gst_structure_set (s, "channels", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL);

  }

}

/* we can only accept caps that we and downstream can handle. */

static GstCaps *

gst_interleave_sink_getcaps (GstPad * pad, GstInterleave * self,

    GstCaps * filter)

{

  GstCaps *result, *peercaps, *sinkcaps;

  GST_OBJECT_LOCK (self);

  /* If we already have caps on one of the sink pads return them */

  if (self->sinkcaps) {

    result = gst_caps_copy (self->sinkcaps);

  } else {

    /* get the downstream possible caps */

    peercaps = gst_pad_peer_query_caps (self->src, NULL);

    /* get the allowed caps on this sinkpad */

    sinkcaps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));

    __remove_channels (sinkcaps);

    if (peercaps) {

      peercaps = gst_caps_make_writable (peercaps);

      __remove_channels (peercaps);

      /* if the peer has caps, intersect */

      GST_DEBUG_OBJECT (pad, "intersecting peer and template caps");

      result = gst_caps_intersect (peercaps, sinkcaps);

      gst_caps_unref (peercaps);

      gst_caps_unref (sinkcaps);

    } else {

      /* the peer has no caps (or there is no peer), just use the allowed caps

       * of this sinkpad. */

      GST_DEBUG_OBJECT (pad, "no peer caps, using sinkcaps");

      result = sinkcaps;

    }

    __set_channels (result, 1);

  }

  GST_OBJECT_UNLOCK (self);

  if (filter != NULL) {

    GstCaps *caps = result;

    GST_LOG_OBJECT (pad, "intersecting filter caps %" GST_PTR_FORMAT " with "

        "preliminary result %" GST_PTR_FORMAT, filter, caps);

    result = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);

    gst_caps_unref (caps);

  }

  GST_DEBUG_OBJECT (pad, "Returning caps %" GST_PTR_FORMAT, result);

  return result;

}

static void

gst_interleave_set_process_function (GstInterleave * self)

{

  switch (self->width) {

    case 8:

      self->func = (GstInterleaveFunc) interleave_8;

      break;

    case 16:

      self->func = (GstInterleaveFunc) interleave_16;

      break;

    case 24:

      self->func = (GstInterleaveFunc) interleave_24;

      break;

    case 32:

      self->func = (GstInterleaveFunc) interleave_32;

      break;

    case 64:

      self->func = (GstInterleaveFunc) interleave_64;

      break;

    default:

      g_assert_not_reached ();

      break;

  }

}

static gboolean

gst_interleave_sink_setcaps (GstInterleave * self, GstPad * pad,

    const GstCaps * caps, const GstAudioInfo * info)

{

  g_return_val_if_fail (GST_IS_INTERLEAVE_PAD (pad), FALSE);

  /* TODO: handle caps changes */

  if (self->sinkcaps && !gst_caps_is_subset (caps, self->sinkcaps)) {

    goto cannot_change_caps;

  } else {

    GstCaps *srccaps;

    GstStructure *s;

    gboolean res;

    self->width = GST_AUDIO_INFO_WIDTH (info);

    self->rate = GST_AUDIO_INFO_RATE (info);

    gst_interleave_set_process_function (self);

    srccaps = gst_caps_copy (caps);

    s = gst_caps_get_structure (srccaps, 0);

    gst_structure_remove_field (s, "channel-mask");

    gst_structure_set (s, "channels", G_TYPE_INT, self->channels, "layout",

        G_TYPE_STRING, "interleaved", NULL);

    gst_interleave_set_channel_positions (self, s);

    gst_interleave_send_stream_start (self);

    res = gst_pad_set_caps (self->src, srccaps);

    gst_caps_unref (srccaps);

    if (!res)

      goto src_did_not_accept;

  }

  if (!self->sinkcaps) {

    GstCaps *sinkcaps = gst_caps_copy (caps);

    GstStructure *s = gst_caps_get_structure (sinkcaps, 0);

    gst_structure_remove_field (s, "channel-mask");

    GST_DEBUG_OBJECT (self, "setting sinkcaps %" GST_PTR_FORMAT, sinkcaps);

    gst_caps_replace (&self->sinkcaps, sinkcaps);

    gst_caps_unref (sinkcaps);

  }

  return TRUE;

cannot_change_caps:

  {

    GST_WARNING_OBJECT (self, "caps of %" GST_PTR_FORMAT " already set, can't "

        "change", self->sinkcaps);

    return FALSE;

  }

src_did_not_accept:

  {

    GST_WARNING_OBJECT (self, "src did not accept setcaps()");

    return FALSE;

  }

}

static gboolean

gst_interleave_sink_event (GstCollectPads * pads, GstCollectData * data,

    GstEvent * event, gpointer user_data)

{

  GstInterleave *self = GST_INTERLEAVE (user_data);

  gboolean ret = TRUE;

  GST_DEBUG ("Got %s event on pad %s:%s", GST_EVENT_TYPE_NAME (event),

      GST_DEBUG_PAD_NAME (data->pad));

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_FLUSH_STOP:

      GST_OBJECT_LOCK (self);

      gst_event_replace (&self->pending_segment, NULL);

      GST_OBJECT_UNLOCK (self);

      break;

    case GST_EVENT_SEGMENT:

    {

      GST_OBJECT_LOCK (self);

      gst_event_replace (&self->pending_segment, event);

      GST_OBJECT_UNLOCK (self);