--- /dev/null
+/*
+ * jack-ladspa-host
+ *
+ * Copyright (C) Robert Ham 2002, 2003 (node@users.sourceforge.net)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ladspa.h>
+#include <dlfcn.h>
+#include <ctype.h>
+
+#include <glib.h>
+
+#include "plugin.h"
+#include "jack_rack.h"
+#include "process.h"
+#include "ui.h"
+
+#define CONTROL_FIFO_SIZE 128
+
+
+
+/* swap over the jack ports in two plugins */
+static void
+plugin_swap_aux_ports (plugin_t * plugin, plugin_t * other)
+{
+ guint copy;
+ jack_port_t ** aux_ports_tmp;
+
+ for (copy = 0; copy < plugin->copies; copy++)
+ {
+ aux_ports_tmp = other->holders[copy].aux_ports;
+ other->holders[copy].aux_ports = plugin->holders[copy].aux_ports;
+ plugin->holders[copy].aux_ports = aux_ports_tmp;
+ }
+}
+
+/** connect up the ladspa instance's input buffers to the previous
+ plugin's audio memory. make sure to check that plugin->prev
+ exists. */
+void
+plugin_connect_input_ports (plugin_t * plugin, LADSPA_Data ** inputs)
+{
+ gint copy;
+ unsigned long channel;
+ unsigned long rack_channel;
+
+ if (!plugin || !inputs)
+ return;
+
+ rack_channel = 0;
+ for (copy = 0; copy < plugin->copies; copy++)
+ {
+ for (channel = 0; channel < plugin->desc->channels; channel++)
+ {
+ plugin->descriptor->
+ connect_port (plugin->holders[copy].instance,
+ plugin->desc->audio_input_port_indicies[channel],
+ inputs[rack_channel]);
+ rack_channel++;
+ }
+ }
+
+ plugin->audio_input_memory = inputs;
+}
+
+/** connect up a plugin's output ports to its own audio_output_memory output memory */
+void
+plugin_connect_output_ports (plugin_t * plugin)
+{
+ gint copy;
+ unsigned long channel;
+ unsigned long rack_channel = 0;
+
+ if (!plugin)
+ return;
+
+
+ for (copy = 0; copy < plugin->copies; copy++)
+ {
+ for (channel = 0; channel < plugin->desc->channels; channel++)
+ {
+ plugin->descriptor->
+ connect_port (plugin->holders[copy].instance,
+ plugin->desc->audio_output_port_indicies[channel],
+ plugin->audio_output_memory[rack_channel]);
+ rack_channel++;
+ }
+ }
+}
+
+void
+process_add_plugin (process_info_t * procinfo, plugin_t * plugin)
+{
+
+ /* sort out list pointers */
+ plugin->next = NULL;
+ plugin->prev = procinfo->chain_end;
+
+ if (procinfo->chain_end)
+ procinfo->chain_end->next = plugin;
+ else
+ procinfo->chain = plugin;
+
+ procinfo->chain_end = plugin;
+
+}
+
+
+/** remove a plugin from the chain */
+plugin_t *
+process_remove_plugin (process_info_t * procinfo, plugin_t *plugin)
+{
+ /* sort out chain pointers */
+ if (plugin->prev)
+ plugin->prev->next = plugin->next;
+ else
+ procinfo->chain = plugin->next;
+
+ if (plugin->next)
+ plugin->next->prev = plugin->prev;
+ else
+ procinfo->chain_end = plugin->prev;
+
+ /* sort out the aux ports */
+ if (plugin->desc->aux_channels > 0)
+ {
+ plugin_t * other;
+
+ for (other = plugin->next; other; other = other->next)
+ if (other->desc->id == plugin->desc->id)
+ plugin_swap_aux_ports (plugin, other);
+ }
+
+ return plugin;
+}
+
+/** enable/disable a plugin */
+void
+process_ablise_plugin (process_info_t * procinfo, plugin_t *plugin, gboolean enable)
+{
+ plugin->enabled = enable;
+}
+
+/** enable/disable a plugin */
+void
+process_ablise_plugin_wet_dry (process_info_t * procinfo, plugin_t *plugin, gboolean enable)
+{
+ plugin->wet_dry_enabled = enable;
+}
+
+/** move a plugin up or down one place in the chain */
+void
+process_move_plugin (process_info_t * procinfo, plugin_t *plugin, gint up)
+{
+ /* other plugins in the chain */
+ plugin_t *pp = NULL, *p, *n, *nn = NULL;
+
+ /* note that we should never recieve an illogical move request
+ ie, there will always be at least 1 plugin before for an up
+ request or 1 plugin after for a down request */
+
+ /* these are pointers to the plugins surrounding the specified one:
+ { pp, p, plugin, n, nn } which makes things much clearer than
+ tptr, tptr2 etc */
+ p = plugin->prev;
+ if (p) pp = p->prev;
+ n = plugin->next;
+ if (n) nn = n->next;
+
+ if (up)
+ {
+ if (!p)
+ return;
+
+ if (pp)
+ pp->next = plugin;
+ else
+ procinfo->chain = plugin;
+
+ p->next = n;
+ p->prev = plugin;
+
+ plugin->prev = pp;
+ plugin->next = p;
+
+ if (n)
+ n->prev = p;
+ else
+ procinfo->chain_end = p;
+
+ }
+ else
+ {
+ if (!n)
+ return;
+
+ if (p)
+ p->next = n;
+ else
+ procinfo->chain = n;
+
+ n->prev = p;
+ n->next = plugin;
+
+ plugin->prev = n;
+ plugin->next = nn;
+
+ if (nn)
+ nn->prev = plugin;
+ else
+ procinfo->chain_end = plugin;
+ }
+
+ if (plugin->desc->aux_channels > 0)
+ {
+ plugin_t * other;
+ other = up ? plugin->next : plugin->prev;
+
+ /* swap around the jack ports */
+ if (other->desc->id == plugin->desc->id)
+ plugin_swap_aux_ports (plugin, other);
+ }
+}
+
+/** exchange an existing plugin for a newly created one */
+plugin_t *
+process_change_plugin (process_info_t * procinfo,
+ plugin_t *plugin, plugin_t * new_plugin)
+{
+ new_plugin->next = plugin->next;
+ new_plugin->prev = plugin->prev;
+
+ if (plugin->prev)
+ plugin->prev->next = new_plugin;
+ else
+ procinfo->chain = new_plugin;
+
+ if (plugin->next)
+ plugin->next->prev = new_plugin;
+ else
+ procinfo->chain_end = new_plugin;
+
+ /* sort out the aux ports */
+ if (plugin->desc->aux_channels > 0)
+ {
+ plugin_t * other;
+
+ for (other = plugin->next; other; other = other->next)
+ if (other->desc->id == plugin->desc->id)
+ plugin_swap_aux_ports (plugin, other);
+ }
+
+ return plugin;
+}
+
+
+/******************************************
+ ************* non RT stuff ***************
+ ******************************************/
+
+
+static int
+plugin_open_plugin (plugin_desc_t * desc,
+ void ** dl_handle_ptr,
+ const LADSPA_Descriptor ** descriptor_ptr)
+{
+ void * dl_handle;
+ const char * dlerr;
+ LADSPA_Descriptor_Function get_descriptor;
+
+ /* open the object file */
+ dl_handle = dlopen (desc->object_file, RTLD_NOW|RTLD_GLOBAL);
+ if (!dl_handle)
+ {
+ fprintf (stderr, "%s: error opening shared object file '%s': %s\n",
+ __FUNCTION__, desc->object_file, dlerror());
+ return 1;
+ }
+
+
+ /* get the get_descriptor function */
+ dlerror (); /* clear the error report */
+
+ get_descriptor = (LADSPA_Descriptor_Function)
+ dlsym (dl_handle, "ladspa_descriptor");
+
+ dlerr = dlerror();
+ if (dlerr)
+ {
+ fprintf (stderr, "%s: error finding descriptor symbol in object file '%s': %s\n",
+ __FUNCTION__, desc->object_file, dlerr);
+ dlclose (dl_handle);
+ return 1;
+ }
+
+ *descriptor_ptr = get_descriptor (desc->index);
+ *dl_handle_ptr = dl_handle;
+
+ return 0;
+}
+
+static int
+plugin_instantiate (const LADSPA_Descriptor * descriptor,
+ unsigned long plugin_index,
+ gint copies,
+ LADSPA_Handle * instances)
+{
+ gint i;
+
+ for (i = 0; i < copies; i++)
+ {
+ instances[i] = descriptor->instantiate (descriptor, sample_rate);
+
+ if (!instances[i])
+ {
+ unsigned long d;
+
+ for (d = 0; d < i; d++)
+ descriptor->cleanup (instances[d]);
+
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+static void
+plugin_create_aux_ports (plugin_t * plugin, guint copy, jack_rack_t * jack_rack)
+{
+ plugin_desc_t * desc;
+// plugin_slot_t * slot;
+ unsigned long aux_channel = 1;
+ unsigned long plugin_index = 1;
+ unsigned long i;
+ char port_name[64];
+ char * plugin_name;
+ char * ptr;
+// GList * list;
+ ladspa_holder_t * holder;
+
+ desc = plugin->desc;
+ holder = plugin->holders + copy;
+
+ holder->aux_ports = g_malloc (sizeof (jack_port_t *) * desc->aux_channels);
+
+ /* make the plugin name jack worthy */
+ ptr = plugin_name = g_strndup (plugin->desc->name, 7);
+ while (*ptr != '\0')
+ {
+ if (*ptr == ' ')
+ *ptr = '_';
+ else
+ *ptr = tolower (*ptr);
+
+ ptr++;
+ }
+
+/*
+ for (list = jack_rack->slots; list; list = g_list_next (list))
+ {
+ slot = (plugin_slot_t *) list->data;
+
+ if (slot->plugin->desc->id == plugin->desc->id)
+ plugin_index++;
+ }
+*/
+
+ for (i = 0; i < desc->aux_channels; i++, aux_channel++)
+ {
+ sprintf (port_name, "%s_%ld-%d_%c%ld",
+ plugin_name,
+ plugin_index,
+ copy + 1,
+ desc->aux_are_input ? 'i' : 'o',
+ aux_channel);
+
+ holder->aux_ports[i] =
+ jack_port_register (jack_rack->ui->procinfo->jack_client,
+ port_name,
+ JACK_DEFAULT_AUDIO_TYPE,
+ desc->aux_are_input ? JackPortIsInput : JackPortIsOutput,
+ 0);
+
+ if (!holder->aux_ports[i])
+ {
+ fprintf (stderr, "Could not register jack port '%s'; aborting\n", port_name);
+ abort ();
+ }
+ }
+
+ g_free (plugin_name);
+}
+
+static LADSPA_Data unused_control_port_output;
+
+static void
+plugin_init_holder (plugin_t * plugin,
+ guint copy,
+ LADSPA_Handle instance,
+ jack_rack_t * jack_rack)
+{
+ unsigned long i;
+ plugin_desc_t * desc;
+ ladspa_holder_t * holder;
+
+ desc = plugin->desc;
+ holder = plugin->holders + copy;
+
+ holder->instance = instance;
+
+ if (desc->control_port_count > 0)
+ {
+ holder->ui_control_fifos = g_malloc (sizeof (lff_t) * desc->control_port_count);
+ holder->control_memory = g_malloc (sizeof (LADSPA_Data) * desc->control_port_count);
+ }
+ else
+ {
+ holder->ui_control_fifos = NULL;
+ holder->control_memory = NULL;
+ }
+
+ for (i = 0; i < desc->control_port_count; i++)
+ {
+ lff_init (holder->ui_control_fifos + i, CONTROL_FIFO_SIZE, sizeof (LADSPA_Data));
+ holder->control_memory[i] =
+ plugin_desc_get_default_control_value (desc, desc->control_port_indicies[i], sample_rate);
+
+ plugin->descriptor->
+ connect_port (instance, desc->control_port_indicies[i], holder->control_memory + i);
+ }
+
+ for (i = 0; i < desc->port_count; i++)
+ {
+ if (!LADSPA_IS_PORT_CONTROL (desc->port_descriptors[i]))
+ continue;
+
+ if (LADSPA_IS_PORT_OUTPUT (desc->port_descriptors[i]))
+ plugin->descriptor-> connect_port (instance, i, &unused_control_port_output);
+ }
+
+ if (plugin->desc->aux_channels > 0)
+ plugin_create_aux_ports (plugin, copy, jack_rack);
+
+ if (plugin->descriptor->activate)
+ plugin->descriptor->activate (instance);
+}
+
+
+plugin_t *
+plugin_new (plugin_desc_t * desc, jack_rack_t * jack_rack)
+{
+ void * dl_handle;
+ const LADSPA_Descriptor * descriptor;
+ LADSPA_Handle * instances;
+ gint copies;
+ unsigned long i;
+ int err;
+ plugin_t * plugin;
+
+ /* open the plugin */
+ err = plugin_open_plugin (desc, &dl_handle, &descriptor);
+ if (err)
+ return NULL;
+
+ /* create the instances */
+ copies = plugin_desc_get_copies (desc, jack_rack->channels);
+ instances = g_malloc (sizeof (LADSPA_Handle) * copies);
+
+ err = plugin_instantiate (descriptor, desc->index, copies, instances);
+ if (err)
+ {
+ g_free (instances);
+ dlclose (dl_handle);
+ return NULL;
+ }
+
+
+ plugin = g_malloc (sizeof (plugin_t));
+
+ plugin->descriptor = descriptor;
+ plugin->dl_handle = dl_handle;
+ plugin->desc = desc;
+ plugin->copies = copies;
+ plugin->enabled = FALSE;
+ plugin->next = NULL;
+ plugin->prev = NULL;
+ plugin->wet_dry_enabled = FALSE;
+
+ /* create audio memory and wet/dry stuff */
+ plugin->audio_output_memory = g_malloc (sizeof (LADSPA_Data *) * jack_rack->channels);
+ plugin->wet_dry_fifos = g_malloc (sizeof (lff_t) * jack_rack->channels);
+ plugin->wet_dry_values = g_malloc (sizeof (LADSPA_Data) * jack_rack->channels);
+
+ for (i = 0; i < jack_rack->channels; i++)
+ {
+ plugin->audio_output_memory[i] = g_malloc (sizeof (LADSPA_Data) * buffer_size);
+ lff_init (plugin->wet_dry_fifos + i, CONTROL_FIFO_SIZE, sizeof (LADSPA_Data));
+ plugin->wet_dry_values[i] = 1.0;
+ }
+
+ /* create holders and fill them out */
+ plugin->holders = g_malloc (sizeof (ladspa_holder_t) * copies);
+ for (i = 0; i < copies; i++)
+ plugin_init_holder (plugin, i, instances[i], jack_rack);
+
+ return plugin;
+}
+
+
+void
+plugin_destroy (plugin_t * plugin, ui_t *ui)
+{
+ unsigned long i, j;
+ int err;
+
+ /* destroy holders */
+ for (i = 0; i < plugin->copies; i++)
+ {
+ if (plugin->descriptor->deactivate)
+ plugin->descriptor->deactivate (plugin->holders[i].instance);
+
+/* if (plugin->descriptor->cleanup)
+ plugin->descriptor->cleanup (plugin->holders[i].instance); */
+
+ if (plugin->desc->control_port_count > 0)
+ {
+ for (j = 0; j < plugin->desc->control_port_count; j++)
+ {
+ lff_free (plugin->holders[i].ui_control_fifos + j);
+ }
+ g_free (plugin->holders[i].ui_control_fifos);
+ g_free (plugin->holders[i].control_memory);
+ }
+
+ /* aux ports */
+ if (plugin->desc->aux_channels > 0)
+ {
+ for (j = 0; j < plugin->desc->aux_channels; j++)
+ {
+ err = jack_port_unregister (ui->procinfo->jack_client,
+ plugin->holders[i].aux_ports[j]);
+
+ if (err)
+ fprintf (stderr, "%s: could not unregister jack port\n", __FUNCTION__);
+ }
+
+ g_free (plugin->holders[i].aux_ports);
+ }
+ }
+
+ g_free (plugin->holders);
+
+ for (i = 0; i < ui->jack_rack->channels; i++)
+ {
+ g_free (plugin->audio_output_memory[i]);
+ lff_free (plugin->wet_dry_fifos + i);
+ }
+
+ g_free (plugin->audio_output_memory);
+ g_free (plugin->wet_dry_fifos);
+ g_free (plugin->wet_dry_values);
+
+ err = dlclose (plugin->dl_handle);
+ if (err)
+ {
+ fprintf (stderr, "%s: error closing shared object '%s': %s\n",
+ __FUNCTION__, plugin->desc->object_file, dlerror ());
+ }
+
+ g_free (plugin);
+}
+
+
+/* EOF */
projects / melted / blobdiff