ext/ladspa/gstladspautils.c

/* GStreamer LADSPA utils 
 * Copyright (C) 1999 Erik Walthinsen <omega@cse.ogi.edu>
 *               2001 Steve Baker <stevebaker_org@yahoo.co.uk>
 *               2003 Andy Wingo <wingo at pobox.com>
 *               2013 Juan Manuel Borges Caño <juanmabcmail@gmail.com>
 *               2013 Stefan Sauer <ensonic@users.sf.net>
 *
 * 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.
 */

/* 
 * This module is smartly shared between the source, transform and
 * sink elements. Handling any specific LADSPA <-> gstreamer interaction.
 *
 * FIXME:
 * Assigning channel orders could be tricky since LADSPA seems to not
 * specify order of channels in a really nice computer parseable way,
 * stereo is probably wrong, more than stereo is crazy. LADSPA has
 * no channel order. All that could be done is to parse the port names
 * for "(Left)/(Right)", "-L/-R" or ":l/:r" - these are the 3 patterns
 * seen most of the time.  By now, it just let's them pass in / pass out.
 * Some nice effort might be done to set channel-masks and/or channel
 * positions correctly, if this is needed and expected, users will tell.
 *
 * This affects mainly interleaving, right now, it just interleaves all
 * input and output ports. This is the right thing in 90% of the cases,
 * but will e.g. create a 4 channel out for a plugin that has 2 stereo
 * 'pairs'.
 *
 * Also, gstreamer supports not-interleaved audio, where you just memcpy
 * each channel after each other: c1...c1c2....c2 and so on. This is not
 * taken into account, but could be added to the _transform and caps easily
 * if users demands it.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "gstladspa.h"
#include "gstladspautils.h"
#include "gstladspafilter.h"
#include "gstladspasource.h"
#include "gstladspasink.h"

#include <math.h>

#ifdef HAVE_LRDF
#include <lrdf.h>
#endif

GST_DEBUG_CATEGORY_EXTERN (ladspa_debug);
#define GST_CAT_DEFAULT ladspa_debug

/* 
 * Interleaved buffer: (c1c2c1c2...)
 * De-interleaved buffer: (c1c1...c2c2...)
 */
static inline void
gst_ladspa_ladspa_deinterleave_data (GstLADSPA * ladspa, LADSPA_Data * outdata,
    guint samples, guint8 * indata)
{
  guint i, j;
  const guint audio_in = ladspa->klass->count.audio.in;

  for (i = 0; i < audio_in; i++)
    for (j = 0; j < samples; j++)
      outdata[i * samples + j] = ((LADSPA_Data *) indata)[j * audio_in + i];
}

/* 
 * Interleaved buffer: (c1c2c1c2...)
 * De-interleaved buffer: (c1c1...c2c2...)
 */
static inline void
gst_ladspa_interleave_ladspa_data (GstLADSPA * ladspa, guint8 * outdata,
    guint samples, LADSPA_Data * indata)
{
  guint i, j;
  const guint audio_out = ladspa->klass->count.audio.out;

  for (i = 0; i < audio_out; i++)
    for (j = 0; j < samples; j++)
      ((LADSPA_Data *) outdata)[j * audio_out + i] = indata[i * samples + j];
}

/*
 * Connect the audio in ports.
 */
static inline void
gst_ladspa_connect_audio_in (GstLADSPA * ladspa, guint samples,
    LADSPA_Data * data)
{
  guint i;

  for (i = 0; i < ladspa->klass->count.audio.in; i++) {
    ladspa->ports.audio.in[i] = data + (i * samples);
    ladspa->klass->descriptor->connect_port (ladspa->handle,
        ladspa->klass->map.audio.in[i], ladspa->ports.audio.in[i]);
  }
}

/*
 * Connect the audio out ports.
 */
static inline void
gst_ladspa_connect_audio_out (GstLADSPA * ladspa, guint samples,
    LADSPA_Data * data)
{
  guint i;

  for (i = 0; i < ladspa->klass->count.audio.out; i++) {
    ladspa->ports.audio.out[i] = data + (i * samples);
    ladspa->klass->descriptor->connect_port (ladspa->handle,
        ladspa->klass->map.audio.out[i], ladspa->ports.audio.out[i]);
  }
}

/*
 * Process a block of audio with the ladspa plugin.
 */
static inline void
gst_ladspa_run (GstLADSPA * ladspa, guint nframes)
{
  ladspa->klass->descriptor->run (ladspa->handle, nframes);
}

/*
 * The data entry/exit point.
 */
gboolean
gst_ladspa_transform (GstLADSPA * ladspa, guint8 * outdata, guint samples,
    guint8 * indata)
{
  LADSPA_Data *in, *out;

  in = g_new0 (LADSPA_Data, samples * ladspa->klass->count.audio.in);
  out = g_new0 (LADSPA_Data, samples * ladspa->klass->count.audio.out);

  gst_ladspa_ladspa_deinterleave_data (ladspa, in, samples, indata);

  gst_ladspa_connect_audio_in (ladspa, samples, in);
  gst_ladspa_connect_audio_out (ladspa, samples, out);

  gst_ladspa_run (ladspa, samples);

  gst_ladspa_interleave_ladspa_data (ladspa, outdata, samples, out);

  g_free (out);
  g_free (in);

  return TRUE;
}

static gboolean
gst_ladspa_activate (GstLADSPA * ladspa)
{
  g_return_val_if_fail (ladspa->handle != NULL, FALSE);
  g_return_val_if_fail (ladspa->activated == FALSE, FALSE);

  GST_DEBUG ("activating LADSPA plugin");

  if (ladspa->klass->descriptor->activate)
    ladspa->klass->descriptor->activate (ladspa->handle);

  ladspa->activated = TRUE;

  return TRUE;
}

static gboolean
gst_ladspa_deactivate (GstLADSPA * ladspa)
{
  g_return_val_if_fail (ladspa->handle != NULL, FALSE);
  g_return_val_if_fail (ladspa->activated == TRUE, FALSE);

  GST_DEBUG ("LADSPA deactivating plugin");

  if (ladspa->klass->descriptor->deactivate)
    ladspa->klass->descriptor->deactivate (ladspa->handle);

  ladspa->activated = FALSE;

  return TRUE;
}

static gboolean
gst_ladspa_open (GstLADSPA * ladspa, unsigned long rate)
{
  guint i;

  GST_DEBUG ("LADSPA instantiating plugin at %lu Hz", rate);

  if (!(ladspa->handle =
          ladspa->klass->descriptor->instantiate (ladspa->klass->descriptor,
              rate))) {
    GST_WARNING ("could not instantiate LADSPA plugin");
    return FALSE;
  }

  ladspa->rate = rate;

  /* connect the control ports */
  for (i = 0; i < ladspa->klass->count.control.in; i++)
    ladspa->klass->descriptor->connect_port (ladspa->handle,
        ladspa->klass->map.control.in[i], &(ladspa->ports.control.in[i]));
  for (i = 0; i < ladspa->klass->count.control.out; i++)
    ladspa->klass->descriptor->connect_port (ladspa->handle,
        ladspa->klass->map.control.out[i], &(ladspa->ports.control.out[i]));

  return TRUE;
}

static void
gst_ladspa_close (GstLADSPA * ladspa)
{
  g_return_if_fail (ladspa->handle != NULL);
  g_return_if_fail (ladspa->activated == FALSE);

  GST_DEBUG ("LADSPA deinstantiating plugin");

  if (ladspa->klass->descriptor->cleanup)
    ladspa->klass->descriptor->cleanup (ladspa->handle);

  ladspa->rate = 0;
  ladspa->handle = NULL;
}

/*
 * Safe open.
 */
gboolean
gst_ladspa_setup (GstLADSPA * ladspa, unsigned long rate)
{
  gboolean ret = TRUE;

  GST_DEBUG ("LADSPA setting up plugin");

  if (ladspa->handle && ladspa->rate != rate) {
    if (ladspa->activated)
      gst_ladspa_deactivate (ladspa);

    gst_ladspa_close (ladspa);
  }

  if (!ladspa->handle) {
    gst_ladspa_open (ladspa, rate);
    if (!(ret = gst_ladspa_activate (ladspa)))
      gst_ladspa_close (ladspa);
  }

  return ret;
}

/*
 * Safe close.
 */
gboolean
gst_ladspa_cleanup (GstLADSPA * ladspa)
{
  gboolean ret = TRUE;

  GST_DEBUG ("LADSPA cleaning up plugin");

  if (ladspa->handle) {
    if (ladspa->activated)
      ret = gst_ladspa_deactivate (ladspa);
    gst_ladspa_close (ladspa);
  }

  return ret;
}

static gchar *
gst_ladspa_object_class_get_param_name (GstLADSPAClass * ladspa_class,
    GObjectClass * object_class, unsigned long portnum)
{
  const LADSPA_Descriptor *desc = ladspa_class->descriptor;
  gchar *name, **namev, **v, *tmp;
  guint i;

  /* beauty in the mess */
  name = g_strdup ("");
  namev = g_strsplit_set (desc->PortNames[portnum], "[]()", 0);
  for (i = 0, v = namev; *v; i++, v++) {
    if (!(i % 2)) {
      tmp = name;
      name = g_strconcat (name, *v, NULL);
      g_free (tmp);
    }
  }
  g_strfreev (namev);
  g_strstrip (name);
  tmp = name;
  name = g_ascii_strdown (name, -1);
  g_free (tmp);

  /* this is the same thing that param_spec_* will do */
  g_strcanon (name, G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "-", '-');

  /* satisfy glib2 (argname[0] must be [A-Za-z]) */
  if (!((name[0] >= 'a' && name[0] <= 'z') || (name[0] >= 'A'
              && name[0] <= 'Z'))) {
    tmp = name;
    name = g_strconcat ("param-", name, NULL);
    g_free (tmp);
  }

  /* check for duplicate property names */
  if (g_object_class_find_property (G_OBJECT_CLASS (object_class), name)) {
    gint n = 1;
    gchar *nprop = g_strdup_printf ("%s-%d", name, n++);

    while (g_object_class_find_property (G_OBJECT_CLASS (object_class), nprop)) {
      g_free (nprop);
      nprop = g_strdup_printf ("%s-%d", name, n++);
    }
    g_free (name);
    name = nprop;
  }

  GST_DEBUG ("LADSPA built property name '%s' from port name '%s'", name,
      desc->PortNames[portnum]);

  return name;
}

static GParamSpec *
gst_ladspa_object_class_get_param_spec (GstLADSPAClass * ladspa_class,
    GObjectClass * object_class, unsigned long portnum)
{
  const LADSPA_Descriptor *desc = ladspa_class->descriptor;
  GParamSpec *ret;
  gchar *name;
  gint hintdesc, perms;
  gfloat lower, upper, def;

  name =
      gst_ladspa_object_class_get_param_name (ladspa_class, object_class,
      portnum);
  perms = G_PARAM_READABLE;
  if (LADSPA_IS_PORT_INPUT (desc->PortDescriptors[portnum]))
    perms |= G_PARAM_WRITABLE | G_PARAM_CONSTRUCT;
  if (LADSPA_IS_PORT_CONTROL (desc->PortDescriptors[portnum]))
    perms |= GST_PARAM_CONTROLLABLE;

  /* short name for hint descriptor */
  hintdesc = desc->PortRangeHints[portnum].HintDescriptor;

  if (LADSPA_IS_HINT_TOGGLED (hintdesc)) {
    ret =
        g_param_spec_boolean (name, name, desc->PortNames[portnum], FALSE,
        perms);
    g_free (name);
    return ret;
  }

  if (LADSPA_IS_HINT_BOUNDED_BELOW (hintdesc))
    lower = desc->PortRangeHints[portnum].LowerBound;
  else
    lower = -G_MAXFLOAT;

  if (LADSPA_IS_HINT_BOUNDED_ABOVE (hintdesc))
    upper = desc->PortRangeHints[portnum].UpperBound;
  else
    upper = G_MAXFLOAT;

  if (LADSPA_IS_HINT_SAMPLE_RATE (hintdesc)) {
    /* FIXME:! (*= ladspa->rate?, *= GST_AUDIO_DEF_RATE?) */
    lower *= 44100;
    upper *= 44100;
  }

  if (LADSPA_IS_HINT_INTEGER (hintdesc)) {
    lower = CLAMP (lower, G_MININT, G_MAXINT);
    upper = CLAMP (upper, G_MININT, G_MAXINT);
  }

  /* default to lower bound */
  def = lower;

#ifdef LADSPA_IS_HINT_HAS_DEFAULT
  if (LADSPA_IS_HINT_HAS_DEFAULT (hintdesc)) {
    if (LADSPA_IS_HINT_DEFAULT_0 (hintdesc))
      def = 0.0;
    else if (LADSPA_IS_HINT_DEFAULT_1 (hintdesc))
      def = 1.0;
    else if (LADSPA_IS_HINT_DEFAULT_100 (hintdesc))
      def = 100.0;
    else if (LADSPA_IS_HINT_DEFAULT_440 (hintdesc))
      def = 440.0;
    if (LADSPA_IS_HINT_DEFAULT_MINIMUM (hintdesc))
      def = lower;
    else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM (hintdesc))
      def = upper;
    else if (LADSPA_IS_HINT_LOGARITHMIC (hintdesc)) {
      if (LADSPA_IS_HINT_DEFAULT_LOW (hintdesc))
        def = exp (0.75 * log (lower) + 0.25 * log (upper));
      else if (LADSPA_IS_HINT_DEFAULT_MIDDLE (hintdesc))
        def = exp (0.5 * log (lower) + 0.5 * log (upper));
      else if (LADSPA_IS_HINT_DEFAULT_HIGH (hintdesc))
        def = exp (0.25 * log (lower) + 0.75 * log (upper));
    } else {
      if (LADSPA_IS_HINT_DEFAULT_LOW (hintdesc))
        def = 0.75 * lower + 0.25 * upper;
      else if (LADSPA_IS_HINT_DEFAULT_MIDDLE (hintdesc))
        def = 0.5 * lower + 0.5 * upper;
      else if (LADSPA_IS_HINT_DEFAULT_HIGH (hintdesc))
        def = 0.25 * lower + 0.75 * upper;
    }
  }
#endif /* LADSPA_IS_HINT_HAS_DEFAULT */

  if (lower > upper) {
    gfloat tmp;

    /* silently swap */
    tmp = lower;
    lower = upper;
    upper = tmp;
  }

  def = CLAMP (def, lower, upper);

  if (LADSPA_IS_HINT_INTEGER (hintdesc)) {
    ret =
        g_param_spec_int (name, name, desc->PortNames[portnum], lower, upper,
        def, perms);
  } else {
    ret =
        g_param_spec_float (name, name, desc->PortNames[portnum], lower, upper,
        def, perms);
  }

  g_free (name);

  return ret;
}

void
gst_ladspa_object_set_property (GstLADSPA * ladspa, GObject * object,
    guint prop_id, const GValue * value, GParamSpec * pspec)
{
  /* remember, properties have an offset */
  prop_id -= ladspa->klass->properties;

  /* only input ports */
  g_return_if_fail (prop_id < ladspa->klass->count.control.in);

  /* now see what type it is */
  switch (pspec->value_type) {
    case G_TYPE_BOOLEAN:
      ladspa->ports.control.in[prop_id] =
          g_value_get_boolean (value) ? 1.f : 0.f;
      break;
    case G_TYPE_INT:
      ladspa->ports.control.in[prop_id] = g_value_get_int (value);
      break;
    case G_TYPE_FLOAT:
      ladspa->ports.control.in[prop_id] = g_value_get_float (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  }
}

void
gst_ladspa_object_get_property (GstLADSPA * ladspa, GObject * object,
    guint prop_id, GValue * value, GParamSpec * pspec)
{
  LADSPA_Data *controls;

  /* remember, properties have an offset */
  prop_id -= ladspa->klass->properties;

  if (prop_id < ladspa->klass->count.control.in) {
    controls = ladspa->ports.control.in;
  } else if (prop_id <
      ladspa->klass->count.control.in + ladspa->klass->count.control.out) {
    controls = ladspa->ports.control.out;
    prop_id -= ladspa->klass->count.control.in;
  } else {
    g_return_if_reached ();
  }

  /* now see what type it is */
  switch (pspec->value_type) {
    case G_TYPE_BOOLEAN:
      g_value_set_boolean (value, controls[prop_id] > 0.5);
      break;
    case G_TYPE_INT:
      g_value_set_int (value, CLAMP (controls[prop_id], G_MININT, G_MAXINT));
      break;
    case G_TYPE_FLOAT:
      g_value_set_float (value, controls[prop_id]);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  }
}

void
gst_ladspa_object_class_install_properties (GstLADSPAClass * ladspa_class,
    GObjectClass * object_class, guint offset)
{
  GParamSpec *p;
  gint i, ix;

  ladspa_class->properties = offset;

  /* properties have an offset */
  ix = ladspa_class->properties;

  /* register properties */

  for (i = 0; i < ladspa_class->count.control.in; i++, ix++) {
    p = gst_ladspa_object_class_get_param_spec (ladspa_class, object_class,
        ladspa_class->map.control.in[i]);
    g_object_class_install_property (object_class, ix, p);
  }
  for (i = 0; i < ladspa_class->count.control.out; i++, ix++) {
    p = gst_ladspa_object_class_get_param_spec (ladspa_class, object_class,
        ladspa_class->map.control.out[i]);
    g_object_class_install_property (object_class, ix, p);
  }
}

void
gst_ladspa_element_class_set_metadata (GstLADSPAClass * ladspa_class,
    GstElementClass * elem_class, const gchar * ladspa_class_tags)
{
  const LADSPA_Descriptor *desc = ladspa_class->descriptor;
  gchar *longname, *author, *extra_ladspa_class_tags = NULL, *tmp;
#ifdef HAVE_LRDF
  gchar *uri;
#endif

  longname = g_locale_to_utf8 (desc->Name, -1, NULL, NULL, NULL);
  if (!longname)
    longname = g_strdup ("no LADSPA description available");

  /* FIXME: no plugin author field different from element author field */
  tmp = g_locale_to_utf8 (desc->Maker, -1, NULL, NULL, NULL);
  if (!tmp)
    tmp = g_strdup ("no LADSPA author available");
  author =
      g_strjoin (", ", tmp,
      "Juan Manuel Borges Caño <juanmabcmail@gmail.com>",
      "Andy Wingo <wingo at pobox.com>",
      "Steve Baker <stevebaker_org@yahoo.co.uk>",
      "Erik Walthinsen <omega@cse.ogi.edu>",
      "Stefan Sauer <ensonic@users.sf.net>",
      "Wim Taymans <wim@fluendo.com>", NULL);
  g_free (tmp);

#ifdef HAVE_LRDF
  /* libldrf support, we want to get extra klass information here */
  uri = g_strdup_printf (LADSPA_BASE "%ld", desc->UniqueID);
  if (uri) {
    lrdf_statement query = { 0, };
    lrdf_uris *uris;
    gchar *str, *base_type = NULL;

    GST_DEBUG ("LADSPA uri (id=%lu) : %s", desc->UniqueID, uri);

    /* we can take this directly from 'desc', keep this example for future
       attributes. 

       if ((str = lrdf_get_setting_metadata (uri, "title"))) {
       GST_DEBUG ("LADSPA title : %s", str);
       }
       if ((str = lrdf_get_setting_metadata (uri, "creator"))) {
       GST_DEBUG ("LADSPA creator : %s", str);
       }
     */

    /* get the rdf:type for this plugin */
    query.subject = uri;
    query.predicate = (char *) RDF_BASE "type";
    query.object = (char *) "?";
    query.next = NULL;
    uris = lrdf_match_multi (&query);
    if (uris) {
      if (uris->count == 1) {
        base_type = g_strdup (uris->items[0]);
        GST_DEBUG ("LADSPA base_type :  %s", base_type);
      }
      lrdf_free_uris (uris);
    }

    /* query taxonomy */
    if (base_type) {
      uris = lrdf_get_all_superclasses (base_type);
      if (uris) {
        guint32 j;

        for (j = 0; j < uris->count; j++) {
          if ((str = lrdf_get_label (uris->items[j]))) {
            GST_DEBUG ("LADSPA parent_type_label : %s", str);
            if (extra_ladspa_class_tags) {
              gchar *old_tags = extra_ladspa_class_tags;
              extra_ladspa_class_tags =
                  g_strconcat (extra_ladspa_class_tags, "/", str, NULL);
              g_free (old_tags);
            } else {
              extra_ladspa_class_tags = g_strconcat ("/", str, NULL);
            }
          }
        }
        lrdf_free_uris (uris);
      }
      g_free (base_type);
    }

    /* we can use this for the presets

       uris = lrdf_get_setting_uris (desc->UniqueID);
       if (uris) {
       guint32 j;

       for (j = 0; j < uris->count; j++) {
       GST_INFO ("setting_uri : %s", uris->items[j]);
       if ((str = lrdf_get_label (uris->items[j]))) {
       GST_INFO ("setting_label : %s", str);
       }
       }
       lrdf_free_uris (uris);
       }

     */
  }
  g_free (uri);

  if (extra_ladspa_class_tags) {
    char *s = g_strconcat (ladspa_class_tags, extra_ladspa_class_tags, NULL);
    g_free (extra_ladspa_class_tags);
    extra_ladspa_class_tags = s;
  }
#endif

  GST_INFO ("tags : %s", ladspa_class_tags);
  gst_element_class_set_metadata (elem_class, longname,
      extra_ladspa_class_tags ? extra_ladspa_class_tags : ladspa_class_tags,
      longname, author);

  g_free (extra_ladspa_class_tags);
  g_free (author);
  g_free (longname);
}

void
gst_ladspa_filter_type_class_add_pad_templates (GstLADSPAClass *
    ladspa_class, GstAudioFilterClass * audio_class)
{
  GstCaps *srccaps, *sinkcaps;

  srccaps = gst_caps_new_simple ("audio/x-raw",
      "format", G_TYPE_STRING, GST_AUDIO_NE (F32),
      "channels", G_TYPE_INT, ladspa_class->count.audio.out,
      "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT,
      "layout", G_TYPE_STRING, "interleaved", NULL);

  sinkcaps = gst_caps_new_simple ("audio/x-raw",
      "format", G_TYPE_STRING, GST_AUDIO_NE (F32),
      "channels", G_TYPE_INT, ladspa_class->count.audio.in,
      "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT,
      "layout", G_TYPE_STRING, "interleaved", NULL);

  gst_my_audio_filter_class_add_pad_templates (audio_class, srccaps, sinkcaps);

  gst_caps_unref (sinkcaps);
  gst_caps_unref (srccaps);
}

void
gst_ladspa_source_type_class_add_pad_template (GstLADSPAClass *
    ladspa_class, GstBaseSrcClass * base_class)
{
  GstCaps *srccaps;

  srccaps = gst_caps_new_simple ("audio/x-raw",
      "format", G_TYPE_STRING, GST_AUDIO_NE (F32),
      "channels", G_TYPE_INT, ladspa_class->count.audio.out,
      "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT,
      "layout", G_TYPE_STRING, "interleaved", NULL);

  gst_my_base_source_class_add_pad_template (base_class, srccaps);

  gst_caps_unref (srccaps);
}

void
gst_ladspa_sink_type_class_add_pad_template (GstLADSPAClass * ladspa_class,
    GstBaseSinkClass * base_class)
{
  GstCaps *sinkcaps;

  sinkcaps = gst_caps_new_simple ("audio/x-raw",
      "format", G_TYPE_STRING, GST_AUDIO_NE (F32),
      "channels", G_TYPE_INT, ladspa_class->count.audio.in,
      "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT,
      "layout", G_TYPE_STRING, "interleaved", NULL);

  gst_my_base_sink_class_add_pad_template (base_class, sinkcaps);

  gst_caps_unref (sinkcaps);
}

void
gst_ladspa_init (GstLADSPA * ladspa, GstLADSPAClass * ladspa_class)
{
  GST_DEBUG ("LADSPA initializing component");

  ladspa->klass = ladspa_class;

  ladspa->handle = NULL;
  ladspa->activated = FALSE;
  ladspa->rate = 0;

  ladspa->ports.audio.in =
      g_new0 (LADSPA_Data *, ladspa->klass->count.audio.in);
  ladspa->ports.audio.out =
      g_new0 (LADSPA_Data *, ladspa->klass->count.audio.out);

  ladspa->ports.control.in =
      g_new0 (LADSPA_Data, ladspa->klass->count.control.in);
  ladspa->ports.control.out =
      g_new0 (LADSPA_Data, ladspa->klass->count.control.out);
}

void
gst_ladspa_finalize (GstLADSPA * ladspa)
{
  GST_DEBUG ("LADSPA finalizing component");

  g_free (ladspa->ports.control.out);
  ladspa->ports.control.out = NULL;
  g_free (ladspa->ports.control.in);
  ladspa->ports.control.in = NULL;

  g_free (ladspa->ports.audio.out);
  ladspa->ports.audio.out = NULL;
  g_free (ladspa->ports.audio.in);
  ladspa->ports.audio.in = NULL;
}

void
gst_ladspa_class_init (GstLADSPAClass * ladspa_class, GType type)
{
  guint mapper, ix;
  guint audio_in = 0, audio_out = 0, control_in = 0, control_out = 0;
  const GValue *value =
      gst_structure_get_value (ladspa_meta_all, g_type_name (type));
  GstStructure *ladspa_meta = g_value_get_boxed (value);
  const gchar *file_name;
  LADSPA_Descriptor_Function descriptor_function;

  GST_DEBUG ("LADSPA initializing class");

  file_name = gst_structure_get_string (ladspa_meta, "plugin-filename");
  ladspa_class->plugin =
      g_module_open (file_name, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
  g_module_symbol (ladspa_class->plugin, "ladspa_descriptor",
      (gpointer *) & descriptor_function);
  gst_structure_get_uint (ladspa_meta, "element-ix", &ix);

  ladspa_class->descriptor = descriptor_function (ix);
  gst_structure_get_uint (ladspa_meta, "audio-in",
      &ladspa_class->count.audio.in);
  gst_structure_get_uint (ladspa_meta, "audio-out",
      &ladspa_class->count.audio.out);
  gst_structure_get_uint (ladspa_meta, "control-in",
      &ladspa_class->count.control.in);
  gst_structure_get_uint (ladspa_meta, "control-out",
      &ladspa_class->count.control.out);
  ladspa_class->properties = 1;

  ladspa_class->map.audio.in =
      g_new0 (unsigned long, ladspa_class->count.audio.in);
  ladspa_class->map.audio.out =
      g_new0 (unsigned long, ladspa_class->count.audio.out);

  ladspa_class->map.control.in =
      g_new0 (unsigned long, ladspa_class->count.control.in);
  ladspa_class->map.control.out =
      g_new0 (unsigned long, ladspa_class->count.control.out);

  for (mapper = 0; mapper < ladspa_class->descriptor->PortCount; mapper++) {
    LADSPA_PortDescriptor p = ladspa_class->descriptor->PortDescriptors[mapper];

    if (LADSPA_IS_PORT_AUDIO (p)) {
      if (LADSPA_IS_PORT_INPUT (p))
        ladspa_class->map.audio.in[audio_in++] = mapper;
      else
        ladspa_class->map.audio.out[audio_out++] = mapper;
    } else if (LADSPA_IS_PORT_CONTROL (p)) {
      if (LADSPA_IS_PORT_INPUT (p))
        ladspa_class->map.control.in[control_in++] = mapper;
      else
        ladspa_class->map.control.out[control_out++] = mapper;
    }
  }

  g_assert (control_out == ladspa_class->count.control.out);
  g_assert (control_in == ladspa_class->count.control.in);

  g_assert (audio_out == ladspa_class->count.audio.out);
  g_assert (audio_in == ladspa_class->count.audio.in);
}

void
gst_ladspa_class_finalize (GstLADSPAClass * ladspa_class)
{
  GST_DEBUG ("LADSPA finalizing class");

  g_free (ladspa_class->map.control.out);
  ladspa_class->map.control.out = NULL;
  g_free (ladspa_class->map.control.in);
  ladspa_class->map.control.in = NULL;

  g_free (ladspa_class->map.audio.out);
  ladspa_class->map.audio.out = NULL;
  g_free (ladspa_class->map.audio.in);
  ladspa_class->map.audio.in = NULL;

  g_module_close (ladspa_class->plugin);
  ladspa_class->plugin = NULL;
}

/* 
 * Create the type & register the element.
 */
void
ladspa_register_element (GstPlugin * plugin, GType parent_type,
    const GTypeInfo * info, GstStructure * ladspa_meta)
{
  const gchar *type_name =
      gst_structure_get_string (ladspa_meta, "element-type-name");

  gst_element_register (plugin, type_name, GST_RANK_NONE,
      g_type_register_static (parent_type, type_name, info, 0));
}