Merge lp:~timo-jyrinki/ubuntu/trusty/lmms/1.0.0_packaging into lp:ubuntu/trusty/lmms

[Timo Jyrinki]

[ Israel Dahl (God Loves You) ]
  * fix-crash-on-close: (Filipe Coelho)
  * debian/rules: tiny version (Rodney Dawes)
  * debian/compat: 9
  * debian/menu: name * LMMS
  * debian/control: removed obsolete builddeps, added fltk libs... suggest
    fluid-soundfont-gm
  * Completely redesigned default theme and UI style
  * New splash screen and logo
  * New plugins:
    - DynamicsProcessor
    - sfxr
    - OpulenZ, an FM synth for LMMS
    - Waveshaper
    - Dual Filter
    - vocoder LADSPA plugin
  * AudioFileProcessor: added stutter playback mode
  * Added time display widget
  * Added support for vector-based automations with various interpolation
    methods
  * Added config option to enable waveform display by default
  * Added more controls to Peak Controller
  * Added standard paths to file open/save dialog
  * LFO controller: added support for custom waveforms
  * New file dialogs allowing for project versioning
  * Added pitch range support for instruments
  * Vestige: Path to VST plugins stored as relative, if opened from
    default VST plugin path
  * Song, SongEditor, BB-Editor, Piano-Roll: correction of play button problems
  * Display key presses in Piano Roll
  * Save solo states for tracks
  * Fixed envelope sustain response
  * Add support for upgrading presets
  * Added optional drawing of note names in Piano Roll
  * Improved overall performance by switching of FX processing if input
    is silent - you might need to tweak the FX decay knobs
  * Use Kicker as default instrument in B+B-Editor
  * Added option for unlinking all controls to context menu of controls
  * Fixed various build issues related to ZynAddSubFX, VST support etc.
  * Atomically write project files via overwrite-by-rename to prevent
    data loss upon disk failures
  * Timeline: allow right click + shift to move left loop point
  * Fixed various MIDI-related issues
  * Default MIDI velocity to 63 for volume=100%
  * CLANG compatibility
  * Hide contents of envelope/LFO tab and display info about
    single-streamed instruments instead
  * Knob code improvement: make the acceleration curve smoother
    and less "sudden" (exponential response curve for smoothing operation)
  * File dialog: Common places added to left pane
  * New mime-type icons
  * Native Amplifier plugin
  * Added support for loading 32-bit samples
  * Fixed oversampling and other problems in export

  [ Timo Jyrinki ]
  * Rework to be according to (LP: #1291675)
  * Sync sources to match the bzr snapshot tarball.
  * Refresh fix-crash-on-close.patch to apply.
  * Apply and remove upstream_fixes patch, already included in the upstream
    snapshot.
  * Fix-broken-command-line-rendering.-Should-always-che.patch:
    - Add from git as suggested
  * AutomatableModel-always-fit-value-from-linked-model.patch:
    - Replace the old patch with a format-patch version from git, but
      unapplied as already included in the bzr snapshot
  * Drop lib64-builddir.patch, seems obsolete
  * debian/lmms.lintian-overrides:
    - Override pkg-has-shlibs-control-file-but-no-actual-shared-libs as
      the libraries are private plugins. Also ignore the
      useless-call-to-ldconfig:s.
  * Restore debian/lmms.xpm from the png to clean a lintian error
  * Clean changelog of lintian warnings
  * Remove unneeded postrm/postinst scripts with 'update-menu'

Continued work from lp:~israeldahl/ubuntu/trusty/lmms/lmms_1.0.0

[Timo Jyrinki (timo-jyrinki)]

Testable with:
sudo apt-add-repository ppa:timo-jyrinki/ppa
sudo apt-get update
sudo apt-get install lmms-common lmms

See bug #1291675 for the approved FFe, test reports and other info.

[Timo Jyrinki (timo-jyrinki)]

A positive test report also using this new build with my changes was received.

The negative part is that there are still two lintian errors:
E: lmms: menu-icon-not-in-xpm-format usr/share/pixmaps/lmms.png
E: lmms: pkg-has-shlibs-control-file-but-no-actual-shared-libs

=== added file '.gitattributes'
--- .gitattributes	1970-01-01 00:00:00 +0000
+++ .gitattributes	2014-04-11 06:58:04 +0000
@@ -0,0 +1,2 @@
+.gitattributes export-ignore
+.gitignore export-ignore

=== added file '.gitignore'
--- .gitignore	1970-01-01 00:00:00 +0000
+++ .gitignore	2014-04-11 06:58:04 +0000
@@ -0,0 +1,5 @@
+/build
+/target
+.*.sw?
+*~
+/CMakeLists.txt.user

=== added file '.mailmap'
--- .mailmap	1970-01-01 00:00:00 +0000
+++ .mailmap	2014-04-11 06:58:04 +0000
@@ -0,0 +1,11 @@
+Tobias Doerffel <[e-mail]>
+Paul Giblock <[e-mail]> <[e-mail]>
+Paul Giblock <[e-mail]> <[e-mail]>
+Andrew Kelley <[e-mail]> <[e-mail]>
+Andrew Kelley <[e-mail]> <[e-mail]>
+Janne Sinisalo <[e-mail]> <janne@janne-desktop.(none)>
+Raine M. Ekman <[e-mail]> <raine@raine.(none)>
+Raine M. Ekman <[e-mail]> <[e-mail]>
+Lukas W <[e-mail]> <[e-mail]>
+Vesa <[e-mail]> <vesa@isokone.(none)>
+Jonathan Aquilina <[e-mail]>

=== added file '.pc/applied-patches'
--- .pc/applied-patches	1970-01-01 00:00:00 +0000
+++ .pc/applied-patches	2014-04-11 06:58:04 +0000
@@ -0,0 +1,2 @@
+upstream-fixes
+fix-crash-on-close.patch

=== removed file '.pc/applied-patches'
--- .pc/applied-patches	2013-03-06 13:01:25 +0000
+++ .pc/applied-patches	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-lib64-builddir.patch

=== added directory '.pc/fix-crash-on-close.patch'
=== added file '.pc/fix-crash-on-close.patch/.timestamp'
=== added directory '.pc/fix-crash-on-close.patch/plugins'
=== added directory '.pc/fix-crash-on-close.patch/plugins/LadspaEffect'
=== added directory '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/caps'
=== added file '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/caps/interface.cc'
--- .pc/fix-crash-on-close.patch/plugins/LadspaEffect/caps/interface.cc	1970-01-01 00:00:00 +0000
+++ .pc/fix-crash-on-close.patch/plugins/LadspaEffect/caps/interface.cc	2014-04-11 06:58:04 +0000
@@ -0,0 +1,145 @@
+/*
+  interface.cc
+
+	Copyright 2004-11 Tim Goetze <[e-mail]>
+	
+	http://quitte.de/dsp/
+
+	LADSPA descriptor factory, host interface.
+
+*/
+/*
+	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., 59 Temple Place - Suite 330, Boston, MA
+	02111-1307, USA or point your web browser to http://www.gnu.org.
+*/
+/*
+	LADSPA ID ranges 1761 - 1800 and 2581 - 2660 
+	(2541 - 2580 donated to [e-mail])
+*/
+
+#include <sys/time.h>
+
+#include "basics.h"
+
+#include "Cabinet.h"
+#include "Chorus.h"
+#include "Phaser.h"
+#include "Sin.h"
+#include "Lorenz.h"
+#include "Roessler.h"
+#include "Reverb.h"
+#include "Compress.h"
+#include "Click.h"
+#include "Eq.h"
+#include "Clip.h"
+#include "White.h"
+#include "SweepVF.h"
+#include "VCO.h"
+#include "Amp.h"
+#include "HRTF.h"
+#include "Pan.h"
+#include "Scape.h"
+#include "ToneStack.h" 
+
+#include "Descriptor.h"
+
+#define N 39 
+static DescriptorStub * descriptors [N];
+
+/*static inline void
+seed()
+{
+	static struct timeval tv;
+  gettimeofday (&tv, 0);
+
+	srand (tv.tv_sec ^ tv.tv_usec);
+}*/
+
+extern "C" {
+
+__attribute__ ((constructor)) 
+void _init()
+{
+	DescriptorStub ** d = descriptors;
+
+	*d++ = new Descriptor<Eq>();
+	*d++ = new Descriptor<Eq2x2>();
+	*d++ = new Descriptor<Compress>();
+	*d++ = new Descriptor<Pan>();
+	*d++ = new Descriptor<Narrower>();
+
+	*d++ = new Descriptor<PreampIII>();
+	*d++ = new Descriptor<PreampIV>();
+	*d++ = new Descriptor<ToneStack>();  
+	*d++ = new Descriptor<ToneStackLT>();    
+	*d++ = new Descriptor<AmpIII>();
+	*d++ = new Descriptor<AmpIV>();
+	*d++ = new Descriptor<AmpV>();
+	*d++ = new Descriptor<AmpVTS>();     
+	*d++ = new Descriptor<CabinetI>();
+	*d++ = new Descriptor<CabinetII>();
+	*d++ = new Descriptor<Clip>();
+
+	*d++ = new Descriptor<ChorusI>();
+	*d++ = new Descriptor<StereoChorusI>();
+	*d++ = new Descriptor<ChorusII>();
+	*d++ = new Descriptor<StereoChorusII>();
+	*d++ = new Descriptor<PhaserI>();
+	*d++ = new Descriptor<PhaserII>();
+	*d++ = new Descriptor<SweepVFI>();
+	*d++ = new Descriptor<SweepVFII>();
+	*d++ = new Descriptor<AutoWah>();
+	*d++ = new Descriptor<Scape>();
+
+	*d++ = new Descriptor<VCOs>();
+	*d++ = new Descriptor<VCOd>();
+	*d++ = new Descriptor<CEO>();
+	*d++ = new Descriptor<Sin>();
+	*d++ = new Descriptor<White>();
+	*d++ = new Descriptor<Lorenz>();
+	*d++ = new Descriptor<Roessler>();
+
+	*d++ = new Descriptor<JVRev>();
+	*d++ = new Descriptor<Plate>();
+	*d++ = new Descriptor<Plate2x2>();
+
+	*d++ = new Descriptor<Click>();
+	*d++ = new Descriptor<Dirac>();
+	*d++ = new Descriptor<HRTF>();
+
+	/* make sure N is correct */
+	assert (d - descriptors == N);
+
+	//seed();
+}
+
+__attribute__ ((destructor)) 
+void _fini()
+{
+	for (ulong i = 0; i < N; ++i)
+		delete descriptors[i];
+}
+
+/* /////////////////////////////////////////////////////////////////////// */
+
+const LADSPA_Descriptor *
+ladspa_descriptor (unsigned long i)
+{
+	if (i < N)
+		return descriptors[i];
+	return 0;
+}
+
+}; /* extern "C" */

=== added directory '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap'
=== added file '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_autopan.c'
--- .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_autopan.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_autopan.c	2014-04-11 06:58:04 +0000
@@ -0,0 +1,361 @@
+/*                                                     -*- linux-c -*-
+    Copyright (C) 2004 Tom Szilagyi
+    
+    Patches were received from:
+        Alexander Koenig <[e-mail]>
+
+    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.
+
+    $Id: tap_autopan.c,v 1.6 2004/02/21 17:33:36 tszilagyi Exp $
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include <ladspa.h>
+#include "tap_utils.h"
+
+/* The Unique ID of the plugin: */
+
+#define ID_STEREO         2146
+
+/* The port numbers for the plugin: */
+
+#define CONTROL_FREQ    0
+#define CONTROL_DEPTH   1
+#define CONTROL_GAIN    2
+#define INPUT_L         3
+#define INPUT_R         4
+#define OUTPUT_L        5
+#define OUTPUT_R        6
+
+
+/* Total number of ports */
+
+#define PORTCOUNT_STEREO   7
+
+
+/* cosine table for fast computations */
+LADSPA_Data cos_table[1024];
+
+
+/* The structure used to hold port connection information and state */
+
+typedef struct {
+	LADSPA_Data * freq;
+	LADSPA_Data * depth;
+	LADSPA_Data * gain;
+	LADSPA_Data * input_L;
+	LADSPA_Data * input_R;
+	LADSPA_Data * output_L;
+	LADSPA_Data * output_R;
+	unsigned long SampleRate;
+	LADSPA_Data Phase;
+	LADSPA_Data run_adding_gain;
+} AutoPan;
+
+
+
+/* Construct a new plugin instance. */
+LADSPA_Handle 
+instantiate_AutoPan(const LADSPA_Descriptor * Descriptor,
+		    unsigned long             SampleRate) {
+	
+	LADSPA_Handle * ptr;
+	
+	if ((ptr = malloc(sizeof(AutoPan))) != NULL) {
+		((AutoPan *)ptr)->SampleRate = SampleRate;
+		((AutoPan *)ptr)->run_adding_gain = 1.0;
+		return ptr;
+	}
+	
+	return NULL;
+}
+
+void
+activate_AutoPan(LADSPA_Handle Instance) {
+
+	AutoPan * ptr;
+
+	ptr = (AutoPan *)Instance;
+	ptr->Phase = 0.0f;
+}
+
+
+
+/* Connect a port to a data location. */
+void 
+connect_port_AutoPan(LADSPA_Handle Instance,
+		     unsigned long Port,
+		     LADSPA_Data * DataLocation) {
+	
+	AutoPan * ptr;
+	
+	ptr = (AutoPan *)Instance;
+	switch (Port) {
+	case CONTROL_FREQ:
+		ptr->freq = DataLocation;
+		break;
+	case CONTROL_DEPTH:
+		ptr->depth = DataLocation;
+		break;
+	case CONTROL_GAIN:
+		ptr->gain = DataLocation;
+		break;
+	case INPUT_L:
+		ptr->input_L = DataLocation;
+		break;
+	case INPUT_R:
+		ptr->input_R = DataLocation;
+		break;
+	case OUTPUT_L:
+		ptr->output_L = DataLocation;
+		break;
+	case OUTPUT_R:
+		ptr->output_R = DataLocation;
+		break;
+	}
+}
+
+
+
+void 
+run_AutoPan(LADSPA_Handle Instance,
+	    unsigned long SampleCount) {
+  
+	AutoPan * ptr = (AutoPan *)Instance;
+
+	LADSPA_Data * input_L = ptr->input_L;
+	LADSPA_Data * input_R = ptr->input_R;
+	LADSPA_Data * output_L = ptr->output_L;
+	LADSPA_Data * output_R = ptr->output_R;
+	LADSPA_Data freq = LIMIT(*(ptr->freq),0.0f,20.0f);
+	LADSPA_Data depth = LIMIT(*(ptr->depth),0.0f,100.0f);
+	LADSPA_Data gain = db2lin(LIMIT(*(ptr->gain),-70.0f,20.0f));
+	unsigned long sample_index;
+	LADSPA_Data phase_L = 0;
+	LADSPA_Data phase_R = 0;
+	
+	for (sample_index = 0; sample_index < SampleCount; sample_index++) {
+		phase_L = 1024.0f * freq * sample_index / ptr->SampleRate + ptr->Phase;
+		while (phase_L >= 1024.0f)
+		        phase_L -= 1024.0f;  
+ 		phase_R = phase_L + 512.0f;
+		while (phase_R >= 1024.0f)
+		        phase_R -= 1024.0f;  
+
+		*(output_L++) = *(input_L++) * gain *
+			(1 - 0.5*depth/100 + 0.5 * depth/100 * cos_table[(unsigned long) phase_L]);
+		*(output_R++) = *(input_R++) * gain *
+			(1 - 0.5*depth/100 + 0.5 * depth/100 * cos_table[(unsigned long) phase_R]);
+	}
+	ptr->Phase = phase_L;
+	while (ptr->Phase >= 1024.0f)
+		ptr->Phase -= 1024.0f;
+}
+
+
+
+void
+set_run_adding_gain_AutoPan(LADSPA_Handle Instance, LADSPA_Data gain) {
+
+	AutoPan * ptr;
+
+	ptr = (AutoPan *)Instance;
+
+	ptr->run_adding_gain = gain;
+}
+
+
+
+void 
+run_adding_AutoPan(LADSPA_Handle Instance,
+		   unsigned long SampleCount) {
+  
+	AutoPan * ptr = (AutoPan *)Instance;
+
+	LADSPA_Data * input_L = ptr->input_L;
+	LADSPA_Data * input_R = ptr->input_R;
+	LADSPA_Data * output_L = ptr->output_L;
+	LADSPA_Data * output_R = ptr->output_R;
+	LADSPA_Data freq = LIMIT(*(ptr->freq),0.0f,20.0f);
+	LADSPA_Data depth = LIMIT(*(ptr->depth),0.0f,100.0f);
+	LADSPA_Data gain = db2lin(LIMIT(*(ptr->gain),-70.0f,20.0f));
+	unsigned long sample_index;
+	LADSPA_Data phase_L = 0;
+	LADSPA_Data phase_R = 0;
+	
+	for (sample_index = 0; sample_index < SampleCount; sample_index++) {
+		phase_L = 1024.0f * freq * sample_index / ptr->SampleRate + ptr->Phase;
+		while (phase_L >= 1024.0f)
+		        phase_L -= 1024.0f;  
+ 		phase_R = phase_L + 512.0f;
+		while (phase_R >= 1024.0f)
+		        phase_R -= 1024.0f;  
+
+		*(output_L++) += *(input_L++) * gain * ptr->run_adding_gain *
+			(1 - 0.5*depth/100 + 0.5 * depth/100 * cos_table[(unsigned long) phase_L]);
+		*(output_R++) += *(input_R++) * gain * ptr->run_adding_gain *
+			(1 - 0.5*depth/100 + 0.5 * depth/100 * cos_table[(unsigned long) phase_R]);
+	}
+	ptr->Phase = phase_L;
+	while (ptr->Phase >= 1024.0f)
+		ptr->Phase -= 1024.0f;
+}
+
+
+
+
+/* Throw away an AutoPan effect instance. */
+void 
+cleanup_AutoPan(LADSPA_Handle Instance) {
+	free(Instance);
+}
+
+
+
+LADSPA_Descriptor * mono_descriptor = NULL;
+
+
+
+/* __attribute__((constructor)) _init() is called automatically when the plugin library is first
+   loaded. */
+void 
+__attribute__((constructor)) _init() {
+	
+	int i;
+	char ** port_names;
+	LADSPA_PortDescriptor * port_descriptors;
+	LADSPA_PortRangeHint * port_range_hints;
+	
+	if ((mono_descriptor = 
+	     (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor))) == NULL)
+		exit(1);
+	
+	for (i = 0; i < 1024; i++)
+		cos_table[i] = cosf(i * M_PI / 512.0f);
+
+
+	mono_descriptor->UniqueID = ID_STEREO;
+	mono_descriptor->Label = strdup("tap_autopan");
+	mono_descriptor->Properties = LADSPA_PROPERTY_HARD_RT_CAPABLE;
+	mono_descriptor->Name = strdup("TAP AutoPanner");
+	mono_descriptor->Maker = strdup("Tom Szilagyi");
+	mono_descriptor->Copyright = strdup("GPL");
+	mono_descriptor->PortCount = PORTCOUNT_STEREO;
+
+	if ((port_descriptors =
+	     (LADSPA_PortDescriptor *)calloc(PORTCOUNT_STEREO, sizeof(LADSPA_PortDescriptor))) == NULL)
+		exit(1);
+
+	mono_descriptor->PortDescriptors = (const LADSPA_PortDescriptor *)port_descriptors;
+	port_descriptors[CONTROL_FREQ] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[CONTROL_DEPTH] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[CONTROL_GAIN] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[INPUT_L] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[INPUT_R] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT_L] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT_R] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+
+	if ((port_names = 
+	     (char **)calloc(PORTCOUNT_STEREO, sizeof(char *))) == NULL)
+		exit(1);
+
+	mono_descriptor->PortNames = (const char **)port_names;
+	port_names[CONTROL_FREQ] = strdup("Frequency [Hz]");
+	port_names[CONTROL_DEPTH] = strdup("Depth [%]");
+	port_names[CONTROL_GAIN] = strdup("Gain [dB]");
+	port_names[INPUT_L] = strdup("Input L");
+	port_names[INPUT_R] = strdup("Input R");
+	port_names[OUTPUT_L] = strdup("Output L");
+	port_names[OUTPUT_R] = strdup("Output R");
+
+	if ((port_range_hints = 
+	     ((LADSPA_PortRangeHint *)calloc(PORTCOUNT_STEREO, sizeof(LADSPA_PortRangeHint)))) == NULL)
+		exit(1);
+
+	mono_descriptor->PortRangeHints	= (const LADSPA_PortRangeHint *)port_range_hints;
+	port_range_hints[CONTROL_FREQ].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[CONTROL_DEPTH].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[CONTROL_GAIN].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[CONTROL_FREQ].LowerBound = 0;
+	port_range_hints[CONTROL_FREQ].UpperBound = 20;
+	port_range_hints[CONTROL_DEPTH].LowerBound = 0;
+	port_range_hints[CONTROL_DEPTH].UpperBound = 100;
+	port_range_hints[CONTROL_GAIN].LowerBound = -70;
+	port_range_hints[CONTROL_GAIN].UpperBound = 20;
+	port_range_hints[INPUT_L].HintDescriptor = 0;
+	port_range_hints[INPUT_R].HintDescriptor = 0;
+	port_range_hints[OUTPUT_L].HintDescriptor = 0;
+	port_range_hints[OUTPUT_R].HintDescriptor = 0;
+	mono_descriptor->instantiate = instantiate_AutoPan;
+	mono_descriptor->connect_port = connect_port_AutoPan;
+	mono_descriptor->activate = activate_AutoPan;
+	mono_descriptor->run = run_AutoPan;
+	mono_descriptor->run_adding = run_adding_AutoPan;
+	mono_descriptor->set_run_adding_gain = set_run_adding_gain_AutoPan;
+	mono_descriptor->deactivate = NULL;
+	mono_descriptor->cleanup = cleanup_AutoPan;
+}
+
+
+void
+delete_descriptor(LADSPA_Descriptor * descriptor) {
+	unsigned long index;
+	if (descriptor) {
+		free((char *)descriptor->Label);
+		free((char *)descriptor->Name);
+		free((char *)descriptor->Maker);
+		free((char *)descriptor->Copyright);
+		free((LADSPA_PortDescriptor *)descriptor->PortDescriptors);
+		for (index = 0; index < descriptor->PortCount; index++)
+			free((char *)(descriptor->PortNames[index]));
+		free((char **)descriptor->PortNames);
+		free((LADSPA_PortRangeHint *)descriptor->PortRangeHints);
+		free(descriptor);
+	}
+}
+
+
+/* __attribute__((destructor)) _fini() is called automatically when the library is unloaded. */
+void
+__attribute__((destructor)) _fini() {
+	delete_descriptor(mono_descriptor);
+}
+
+
+/* Return a descriptor of the requested plugin type. */
+const LADSPA_Descriptor * 
+ladspa_descriptor(unsigned long Index) {
+
+	switch (Index) {
+	case 0:
+		return mono_descriptor;
+	default:
+		return NULL;
+	}
+}

=== added file '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_chorusflanger.c'
--- .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_chorusflanger.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_chorusflanger.c	2014-04-11 06:58:04 +0000
@@ -0,0 +1,595 @@
+/*                                                     -*- linux-c -*-
+    Copyright (C) 2004 Tom Szilagyi
+    
+    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.
+
+    $Id: tap_chorusflanger.c,v 1.3 2004/08/17 09:15:21 tszilagyi Exp $
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+
+#include <ladspa.h>
+#include "tap_utils.h"
+
+
+/* The Unique ID of the plugin: */
+
+#define ID_STEREO       2159
+
+/* The port numbers for the plugin: */
+
+#define FREQ            0
+#define PHASE           1
+#define DEPTH           2
+#define DELAY           3
+#define CONTOUR         4
+#define DRYLEVEL        5
+#define WETLEVEL        6
+#define INPUT_L         7
+#define INPUT_R         8
+#define OUTPUT_L        9
+#define OUTPUT_R       10
+
+/* Total number of ports */
+#define PORTCOUNT_STEREO 11
+
+
+/*
+ * Largest buffer lengths needed (at 192 kHz).
+ * These are summed up to determine the size of *one* buffer per channel.
+ */
+#define DEPTH_BUFLEN 450
+#define DELAY_BUFLEN 19200
+
+/* Max. frequency setting */
+#define MAX_FREQ 5.0f
+
+/* bandwidth of highpass filters (in octaves) */
+#define HP_BW 1
+
+/* cosine table for fast computations */
+#define COS_TABLE_SIZE 1024
+LADSPA_Data cos_table[COS_TABLE_SIZE];
+
+
+/* The structure used to hold port connection information and state */
+typedef struct {
+	LADSPA_Data * freq;
+	LADSPA_Data * phase;
+	LADSPA_Data * depth;
+	LADSPA_Data * delay;
+	LADSPA_Data * contour;
+	LADSPA_Data * drylevel;
+	LADSPA_Data * wetlevel;
+	LADSPA_Data * input_L;
+	LADSPA_Data * input_R;
+	LADSPA_Data * output_L;
+	LADSPA_Data * output_R;
+
+	LADSPA_Data * ring_L;
+	unsigned long buflen_L;
+	unsigned long pos_L;
+	LADSPA_Data * ring_R;
+	unsigned long buflen_R;
+	unsigned long pos_R;
+
+	biquad highpass_L;
+	biquad highpass_R;
+
+	float cm_phase;
+	float dm_phase;
+
+	unsigned long sample_rate;
+	LADSPA_Data run_adding_gain;
+} ChorusFlanger;
+
+
+/* Construct a new plugin instance. */
+LADSPA_Handle 
+instantiate_ChorusFlanger(const LADSPA_Descriptor * Descriptor,
+			  unsigned long             sample_rate) {
+  
+        LADSPA_Handle * ptr;
+	
+	if ((ptr = malloc(sizeof(ChorusFlanger))) != NULL) {
+		((ChorusFlanger *)ptr)->sample_rate = sample_rate;
+		((ChorusFlanger *)ptr)->run_adding_gain = 1.0f;
+
+
+		if ((((ChorusFlanger *)ptr)->ring_L =
+		     calloc((DEPTH_BUFLEN + DELAY_BUFLEN) * sample_rate / 192000,
+			    sizeof(LADSPA_Data))) == NULL)
+			return NULL;
+		((ChorusFlanger *)ptr)->buflen_L = (DEPTH_BUFLEN + DELAY_BUFLEN) * sample_rate / 192000;
+		((ChorusFlanger *)ptr)->pos_L = 0;
+
+		if ((((ChorusFlanger *)ptr)->ring_R =
+		     calloc((DEPTH_BUFLEN + DELAY_BUFLEN) * sample_rate / 192000,
+			    sizeof(LADSPA_Data))) == NULL)
+			return NULL;
+		((ChorusFlanger *)ptr)->buflen_R = (DEPTH_BUFLEN + DELAY_BUFLEN) * sample_rate / 192000;
+		((ChorusFlanger *)ptr)->pos_R = 0;
+
+
+		((ChorusFlanger *)ptr)->cm_phase = 0.0f;
+		((ChorusFlanger *)ptr)->dm_phase = 0.0f;
+
+		return ptr;
+	}
+       	return NULL;
+}
+
+
+void
+activate_ChorusFlanger(LADSPA_Handle Instance) {
+
+	ChorusFlanger * ptr = (ChorusFlanger *)Instance;
+	unsigned long i;
+
+	for (i = 0; i < (DEPTH_BUFLEN + DELAY_BUFLEN) * ptr->sample_rate / 192000; i++) {
+		ptr->ring_L[i] = 0.0f;
+		ptr->ring_R[i] = 0.0f;
+	}
+
+	biquad_init(&ptr->highpass_L);
+	biquad_init(&ptr->highpass_R);
+}
+
+
+
+
+/* Connect a port to a data location. */
+void 
+connect_port_ChorusFlanger(LADSPA_Handle Instance,
+			   unsigned long Port,
+			   LADSPA_Data * data) {
+	
+	ChorusFlanger * ptr = (ChorusFlanger *)Instance;
+
+	switch (Port) {
+	case FREQ:
+		ptr->freq = data;
+		break;
+	case PHASE:
+		ptr->phase = data;
+		break;
+	case DEPTH:
+		ptr->depth = data;
+		break;
+	case DELAY:
+		ptr->delay = data;
+		break;
+	case CONTOUR:
+		ptr->contour = data;
+		break;
+	case DRYLEVEL:
+		ptr->drylevel = data;
+		break;
+	case WETLEVEL:
+		ptr->wetlevel = data;
+		break;
+	case INPUT_L:
+		ptr->input_L = data;
+		break;
+	case INPUT_R:
+		ptr->input_R = data;
+		break;
+	case OUTPUT_L:
+		ptr->output_L = data;
+		break;
+	case OUTPUT_R:
+		ptr->output_R = data;
+		break;
+	}
+}
+
+
+void 
+run_ChorusFlanger(LADSPA_Handle Instance,
+		  unsigned long SampleCount) {
+  
+	ChorusFlanger * ptr = (ChorusFlanger *)Instance;
+
+	LADSPA_Data freq = LIMIT(*(ptr->freq), 0.0f, MAX_FREQ);
+	LADSPA_Data phase = LIMIT(*(ptr->phase), 0.0f, 180.0f) / 180.0f;
+	LADSPA_Data depth = 100.0f * ptr->sample_rate / 44100.0f
+		* LIMIT(*(ptr->depth),0.0f,100.0f) / 100.0f;
+	LADSPA_Data delay = LIMIT(*(ptr->delay),0.0f,100.0f);
+	LADSPA_Data contour = LIMIT(*(ptr->contour), 20.0f, 20000.0f);
+	LADSPA_Data drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f));
+	LADSPA_Data wetlevel = db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f));
+	LADSPA_Data * input_L = ptr->input_L;
+	LADSPA_Data * input_R = ptr->input_R;
+	LADSPA_Data * output_L = ptr->output_L;
+	LADSPA_Data * output_R = ptr->output_R;
+
+	unsigned long sample_index;
+	unsigned long sample_count = SampleCount;
+
+	LADSPA_Data in_L = 0.0f;
+	LADSPA_Data in_R = 0.0f;
+	LADSPA_Data d_L = 0.0f;
+	LADSPA_Data d_R = 0.0f;
+	LADSPA_Data f_L = 0.0f;
+	LADSPA_Data f_R = 0.0f;
+	LADSPA_Data out_L = 0.0f;
+	LADSPA_Data out_R = 0.0f;
+
+	float phase_L = 0.0f;
+	float phase_R = 0.0f;
+	float fpos_L = 0.0f;
+	float fpos_R = 0.0f;
+	float n_L = 0.0f;
+	float n_R = 0.0f;
+	float rem_L = 0.0f;
+	float rem_R = 0.0f;
+	float s_a_L, s_a_R, s_b_L, s_b_R;
+
+	float d_pos = 0.0f;
+
+	if (delay < 1.0f)
+		delay = 1.0f;
+	delay = 100.0f - delay;
+
+	hp_set_params(&ptr->highpass_L, contour, HP_BW, ptr->sample_rate);
+	hp_set_params(&ptr->highpass_R, contour, HP_BW, ptr->sample_rate);
+
+	for (sample_index = 0; sample_index < sample_count; sample_index++) {
+
+		in_L = *(input_L++);
+		in_R = *(input_R++);
+
+		push_buffer(in_L, ptr->ring_L, ptr->buflen_L, &(ptr->pos_L));
+		push_buffer(in_R, ptr->ring_R, ptr->buflen_R, &(ptr->pos_R));
+		
+		ptr->cm_phase += freq / ptr->sample_rate * COS_TABLE_SIZE;
+		
+		while (ptr->cm_phase >= COS_TABLE_SIZE)
+			ptr->cm_phase -= COS_TABLE_SIZE;
+		
+		ptr->dm_phase = phase * COS_TABLE_SIZE / 2.0f;
+		
+		phase_L = ptr->cm_phase;
+		phase_R = ptr->cm_phase + ptr->dm_phase;
+		while (phase_R >= COS_TABLE_SIZE)
+			phase_R -= COS_TABLE_SIZE;
+		
+		d_pos = delay * ptr->sample_rate / 1000.0f;
+		fpos_L = d_pos + depth * (0.5f + 0.5f * cos_table[(unsigned long)phase_L]);
+		fpos_R = d_pos + depth * (0.5f + 0.5f * cos_table[(unsigned long)phase_R]);
+		
+		n_L = floorf(fpos_L);
+		n_R = floorf(fpos_R);
+		rem_L = fpos_L - n_L;
+		rem_R = fpos_R - n_R;
+		
+		s_a_L = read_buffer(ptr->ring_L, ptr->buflen_L,
+				    ptr->pos_L, (unsigned long) n_L);
+		s_b_L = read_buffer(ptr->ring_L, ptr->buflen_L,
+				    ptr->pos_L, (unsigned long) n_L + 1);
+		
+		s_a_R = read_buffer(ptr->ring_R, ptr->buflen_R,
+				    ptr->pos_R, (unsigned long) n_R);
+		s_b_R = read_buffer(ptr->ring_R, ptr->buflen_R,
+				    ptr->pos_R, (unsigned long) n_R + 1);
+		
+		d_L = ((1 - rem_L) * s_a_L + rem_L * s_b_L);
+		d_R = ((1 - rem_R) * s_a_R + rem_R * s_b_R);
+
+		f_L = biquad_run(&ptr->highpass_L, d_L);
+		f_R = biquad_run(&ptr->highpass_R, d_R);
+
+		out_L = drylevel * in_L + wetlevel * f_L;
+		out_R = drylevel * in_R + wetlevel * f_R;
+
+		*(output_L++) = out_L;
+		*(output_R++) = out_R;
+	}
+}
+
+
+void
+set_run_adding_gain_ChorusFlanger(LADSPA_Handle Instance, LADSPA_Data gain) {
+
+	ChorusFlanger * ptr = (ChorusFlanger *)Instance;
+
+	ptr->run_adding_gain = gain;
+}
+
+
+
+void 
+run_adding_ChorusFlanger(LADSPA_Handle Instance,
+                         unsigned long SampleCount) {
+  
+	ChorusFlanger * ptr = (ChorusFlanger *)Instance;
+
+	LADSPA_Data freq = LIMIT(*(ptr->freq), 0.0f, MAX_FREQ);
+	LADSPA_Data phase = LIMIT(*(ptr->phase), 0.0f, 180.0f) / 180.0f;
+	LADSPA_Data depth = 100.0f * ptr->sample_rate / 44100.0f
+		* LIMIT(*(ptr->depth),0.0f,100.0f) / 100.0f;
+	LADSPA_Data delay = LIMIT(*(ptr->delay),0.0f,100.0f);
+	LADSPA_Data contour = LIMIT(*(ptr->contour), 20.0f, 20000.0f);
+	LADSPA_Data drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f));
+	LADSPA_Data wetlevel = db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f));
+	LADSPA_Data * input_L = ptr->input_L;
+	LADSPA_Data * input_R = ptr->input_R;
+	LADSPA_Data * output_L = ptr->output_L;
+	LADSPA_Data * output_R = ptr->output_R;
+
+	unsigned long sample_index;
+	unsigned long sample_count = SampleCount;
+
+	LADSPA_Data in_L = 0.0f;
+	LADSPA_Data in_R = 0.0f;
+	LADSPA_Data d_L = 0.0f;
+	LADSPA_Data d_R = 0.0f;
+	LADSPA_Data f_L = 0.0f;
+	LADSPA_Data f_R = 0.0f;
+	LADSPA_Data out_L = 0.0f;
+	LADSPA_Data out_R = 0.0f;
+
+	float phase_L = 0.0f;
+	float phase_R = 0.0f;
+	float fpos_L = 0.0f;
+	float fpos_R = 0.0f;
+	float n_L = 0.0f;
+	float n_R = 0.0f;
+	float rem_L = 0.0f;
+	float rem_R = 0.0f;
+	float s_a_L, s_a_R, s_b_L, s_b_R;
+
+	float d_pos = 0.0f;
+
+	if (delay < 1.0f)
+		delay = 1.0f;
+	delay = 100.0f - delay;
+
+	hp_set_params(&ptr->highpass_L, contour, HP_BW, ptr->sample_rate);
+	hp_set_params(&ptr->highpass_R, contour, HP_BW, ptr->sample_rate);
+
+	for (sample_index = 0; sample_index < sample_count; sample_index++) {
+
+		in_L = *(input_L++);
+		in_R = *(input_R++);
+
+		push_buffer(in_L, ptr->ring_L, ptr->buflen_L, &(ptr->pos_L));
+		push_buffer(in_R, ptr->ring_R, ptr->buflen_R, &(ptr->pos_R));
+		
+		ptr->cm_phase += freq / ptr->sample_rate * COS_TABLE_SIZE;
+		
+		while (ptr->cm_phase >= COS_TABLE_SIZE)
+			ptr->cm_phase -= COS_TABLE_SIZE;
+		
+		ptr->dm_phase = phase * COS_TABLE_SIZE / 2.0f;
+		
+		phase_L = ptr->cm_phase;
+		phase_R = ptr->cm_phase + ptr->dm_phase;
+		while (phase_R >= COS_TABLE_SIZE)
+			phase_R -= COS_TABLE_SIZE;
+		
+		d_pos = delay * ptr->sample_rate / 1000.0f;
+		fpos_L = d_pos + depth * (0.5f + 0.5f * cos_table[(unsigned long)phase_L]);
+		fpos_R = d_pos + depth * (0.5f + 0.5f * cos_table[(unsigned long)phase_R]);
+		
+		n_L = floorf(fpos_L);
+		n_R = floorf(fpos_R);
+		rem_L = fpos_L - n_L;
+		rem_R = fpos_R - n_R;
+		
+		s_a_L = read_buffer(ptr->ring_L, ptr->buflen_L,
+				    ptr->pos_L, (unsigned long) n_L);
+		s_b_L = read_buffer(ptr->ring_L, ptr->buflen_L,
+				    ptr->pos_L, (unsigned long) n_L + 1);
+		
+		s_a_R = read_buffer(ptr->ring_R, ptr->buflen_R,
+				    ptr->pos_R, (unsigned long) n_R);
+		s_b_R = read_buffer(ptr->ring_R, ptr->buflen_R,
+				    ptr->pos_R, (unsigned long) n_R + 1);
+		
+		d_L = ((1 - rem_L) * s_a_L + rem_L * s_b_L);
+		d_R = ((1 - rem_R) * s_a_R + rem_R * s_b_R);
+
+		f_L = biquad_run(&ptr->highpass_L, d_L);
+		f_R = biquad_run(&ptr->highpass_R, d_R);
+
+		out_L = drylevel * in_L + wetlevel * f_L;
+		out_R = drylevel * in_R + wetlevel * f_R;
+
+		*(output_L++) += ptr->run_adding_gain * out_L;
+		*(output_R++) += ptr->run_adding_gain * out_R;
+	}
+}
+
+
+
+/* Throw away a ChorusFlanger effect instance. */
+void 
+cleanup_ChorusFlanger(LADSPA_Handle Instance) {
+
+  	ChorusFlanger * ptr = (ChorusFlanger *)Instance;
+	free(ptr->ring_L);
+	free(ptr->ring_R);
+	free(Instance);
+}
+
+
+
+LADSPA_Descriptor * stereo_descriptor = NULL;
+
+
+
+/* __attribute__((constructor)) _init() is called automatically when the plugin library is first
+   loaded. */
+void 
+__attribute__((constructor)) _init() {
+	
+	char ** port_names;
+	LADSPA_PortDescriptor * port_descriptors;
+	LADSPA_PortRangeHint * port_range_hints;
+        int i;
+	
+	if ((stereo_descriptor = 
+	     (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor))) == NULL)
+		exit(1);
+
+        for (i = 0; i < COS_TABLE_SIZE; i++)
+                cos_table[i] = cosf(i * 2.0f * M_PI / COS_TABLE_SIZE);
+
+	stereo_descriptor->UniqueID = ID_STEREO;
+	stereo_descriptor->Label = strdup("tap_chorusflanger");
+	stereo_descriptor->Properties = LADSPA_PROPERTY_HARD_RT_CAPABLE;
+	stereo_descriptor->Name = strdup("TAP Chorus/Flanger");
+	stereo_descriptor->Maker = strdup("Tom Szilagyi");
+	stereo_descriptor->Copyright = strdup("GPL");
+	stereo_descriptor->PortCount = PORTCOUNT_STEREO;
+
+	if ((port_descriptors =
+	     (LADSPA_PortDescriptor *)calloc(PORTCOUNT_STEREO, sizeof(LADSPA_PortDescriptor))) == NULL)
+		exit(1);
+
+	stereo_descriptor->PortDescriptors = (const LADSPA_PortDescriptor *)port_descriptors;
+	port_descriptors[FREQ] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[PHASE] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[DEPTH] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[DELAY] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[CONTOUR] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[DRYLEVEL] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[WETLEVEL] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[INPUT_L] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[INPUT_R] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT_L] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT_R] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+
+	if ((port_names = 
+	     (char **)calloc(PORTCOUNT_STEREO, sizeof(char *))) == NULL)
+		exit(1);
+
+	stereo_descriptor->PortNames = (const char **)port_names;
+	port_names[FREQ] = strdup("Frequency [Hz]");
+	port_names[PHASE] = strdup("L/R Phase Shift [deg]");
+	port_names[DEPTH] = strdup("Depth [%]");
+	port_names[DELAY] = strdup("Delay [ms]");
+	port_names[CONTOUR] = strdup("Contour [Hz]");
+	port_names[DRYLEVEL] = strdup("Dry Level [dB]");
+	port_names[WETLEVEL] = strdup("Wet Level [dB]");
+	port_names[INPUT_L] = strdup("Input_L");
+	port_names[INPUT_R] = strdup("Input_R");
+	port_names[OUTPUT_L] = strdup("Output_L");
+	port_names[OUTPUT_R] = strdup("Output_R");
+
+	if ((port_range_hints = 
+	     ((LADSPA_PortRangeHint *)calloc(PORTCOUNT_STEREO, sizeof(LADSPA_PortRangeHint)))) == NULL)
+		exit(1);
+
+	stereo_descriptor->PortRangeHints = (const LADSPA_PortRangeHint *)port_range_hints;
+	port_range_hints[FREQ].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_LOW);
+	port_range_hints[PHASE].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_MIDDLE);
+	port_range_hints[DEPTH].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_HIGH);
+	port_range_hints[DELAY].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_LOW);
+	port_range_hints[CONTOUR].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_100);
+	port_range_hints[DRYLEVEL].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[WETLEVEL].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[FREQ].LowerBound = 0.0f;
+	port_range_hints[FREQ].UpperBound = MAX_FREQ;
+	port_range_hints[PHASE].LowerBound = 0.0f;
+	port_range_hints[PHASE].UpperBound = 180.0f;
+	port_range_hints[DEPTH].LowerBound = 0.0f;
+	port_range_hints[DEPTH].UpperBound = 100.0f;
+	port_range_hints[DELAY].LowerBound = 0.0f;
+	port_range_hints[DELAY].UpperBound = 100.0f;
+	port_range_hints[CONTOUR].LowerBound = 20.0f;
+	port_range_hints[CONTOUR].UpperBound = 20000.0f;
+	port_range_hints[DRYLEVEL].LowerBound = -90.0f;
+	port_range_hints[DRYLEVEL].UpperBound = +20.0f;
+	port_range_hints[WETLEVEL].LowerBound = -90.0f;
+	port_range_hints[WETLEVEL].UpperBound = +20.0f;
+	port_range_hints[INPUT_L].HintDescriptor = 0;
+	port_range_hints[INPUT_R].HintDescriptor = 0;
+	port_range_hints[OUTPUT_L].HintDescriptor = 0;
+	port_range_hints[OUTPUT_R].HintDescriptor = 0;
+	stereo_descriptor->instantiate = instantiate_ChorusFlanger;
+	stereo_descriptor->connect_port = connect_port_ChorusFlanger;
+	stereo_descriptor->activate = activate_ChorusFlanger;
+	stereo_descriptor->run = run_ChorusFlanger;
+	stereo_descriptor->run_adding = run_adding_ChorusFlanger;
+	stereo_descriptor->set_run_adding_gain = set_run_adding_gain_ChorusFlanger;
+	stereo_descriptor->deactivate = NULL;
+	stereo_descriptor->cleanup = cleanup_ChorusFlanger;
+}
+
+
+void
+delete_descriptor(LADSPA_Descriptor * descriptor) {
+	unsigned long index;
+	if (descriptor) {
+		free((char *)descriptor->Label);
+		free((char *)descriptor->Name);
+		free((char *)descriptor->Maker);
+		free((char *)descriptor->Copyright);
+		free((LADSPA_PortDescriptor *)descriptor->PortDescriptors);
+		for (index = 0; index < descriptor->PortCount; index++)
+			free((char *)(descriptor->PortNames[index]));
+		free((char **)descriptor->PortNames);
+		free((LADSPA_PortRangeHint *)descriptor->PortRangeHints);
+		free(descriptor);
+	}
+}
+
+
+/* __attribute__((destructor)) _fini() is called automatically when the library is unloaded. */
+void
+__attribute__((destructor)) _fini() {
+	delete_descriptor(stereo_descriptor);
+}
+
+
+/* Return a descriptor of the requested plugin type. */
+const LADSPA_Descriptor * 
+ladspa_descriptor(unsigned long Index) {
+
+	switch (Index) {
+	case 0:
+		return stereo_descriptor;
+	default:
+		return NULL;
+	}
+}

=== added file '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_deesser.c'
--- .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_deesser.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_deesser.c	2014-04-11 06:58:04 +0000
@@ -0,0 +1,491 @@
+/*                                                     -*- linux-c -*-
+    Copyright (C) 2004 Tom Szilagyi
+    
+    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.
+
+    $Id: tap_deesser.c,v 1.7 2004/05/01 16:15:06 tszilagyi Exp $
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include <ladspa.h>
+#include "tap_utils.h"
+
+/* The Unique ID of the plugin: */
+
+#define ID_MONO         2147
+
+/* The port numbers for the plugin: */
+
+#define THRESHOLD       0
+#define FREQ            1
+#define SIDECHAIN       2
+#define MONITOR         3
+#define ATTENUAT        4
+#define INPUT           5
+#define OUTPUT          6
+
+
+/* Total number of ports */
+
+#define PORTCOUNT_MONO   7
+
+
+/* Bandwidth of sidechain lowpass/highpass filters */
+#define SIDECH_BW       0.3f
+
+/* Used to hold 10 ms gain data, enough for sample rates up to 192 kHz */
+#define RINGBUF_SIZE    2000
+
+
+
+/* 4 digits precision from 1.000 to 9.999 */
+LADSPA_Data log10_table[9000];
+
+
+/* The structure used to hold port connection information and state */
+
+typedef struct {
+	LADSPA_Data * threshold;
+	LADSPA_Data * audiomode;
+	LADSPA_Data * freq;
+	LADSPA_Data * sidechain;
+	LADSPA_Data * monitor;
+	LADSPA_Data * attenuat;
+	LADSPA_Data * input;
+	LADSPA_Data * output;
+
+	biquad sidech_lo_filter;
+	biquad sidech_hi_filter;
+	LADSPA_Data * ringbuffer;
+	unsigned long buflen;
+	unsigned long pos;
+	LADSPA_Data sum;
+	LADSPA_Data old_freq;
+
+	unsigned long sample_rate;
+	LADSPA_Data run_adding_gain;
+} DeEsser;
+
+
+/* fast linear to decibel conversion using log10_table[] */
+LADSPA_Data fast_lin2db(LADSPA_Data lin) {
+
+        unsigned long k;
+        int exp = 0;
+        LADSPA_Data mant = ABS(lin);
+
+	/* sanity checks */
+	if (mant == 0.0f)
+		return(-1.0f/0.0f); /* -inf */
+	if (mant == 1.0f/0.0f) /* +inf */
+		return(mant);
+
+        while (mant < 1.0f) {
+                mant *= 10;
+                exp --;
+        }
+        while (mant >= 10.0f) {
+                mant /= 10;
+                exp ++;
+        }
+
+        k = (mant - 0.999999f) * 1000.0f;
+        return 20.0f * (log10_table[k] + exp);
+}
+
+
+
+/* Construct a new plugin instance. */
+LADSPA_Handle 
+instantiate_DeEsser(const LADSPA_Descriptor * Descriptor,
+		    unsigned long             SampleRate) {
+	
+	LADSPA_Handle * ptr;
+	
+	if ((ptr = malloc(sizeof(DeEsser))) != NULL) {
+		((DeEsser *)ptr)->sample_rate = SampleRate;
+		((DeEsser *)ptr)->run_adding_gain = 1.0f;
+
+		/* init filters */
+		biquad_init(&((DeEsser *)ptr)->sidech_lo_filter);
+		biquad_init(&((DeEsser *)ptr)->sidech_hi_filter);
+		
+		/* alloc mem for ringbuffer */
+		if ((((DeEsser *)ptr)->ringbuffer = 
+		     calloc(RINGBUF_SIZE, sizeof(LADSPA_Data))) == NULL)
+			return NULL;
+
+                /* 10 ms attenuation data is stored */
+		((DeEsser *)ptr)->buflen = ((DeEsser *)ptr)->sample_rate / 100; 
+
+		((DeEsser *)ptr)->pos = 0;
+		((DeEsser *)ptr)->sum = 0.0f;
+		((DeEsser *)ptr)->old_freq = 0;
+
+		return ptr;
+	}
+	return NULL;
+}
+
+
+void
+activate_DeEsser(LADSPA_Handle Instance) {
+
+	DeEsser * ptr = (DeEsser *)Instance;
+	unsigned long i;
+
+	for (i = 0; i < RINGBUF_SIZE; i++)
+		ptr->ringbuffer[i] = 0.0f;
+}
+
+
+
+
+/* Connect a port to a data location. */
+void 
+connect_port_DeEsser(LADSPA_Handle Instance,
+		     unsigned long Port,
+		     LADSPA_Data * DataLocation) {
+	
+	DeEsser * ptr;
+	
+	ptr = (DeEsser *)Instance;
+	switch (Port) {
+	case THRESHOLD:
+		ptr->threshold = DataLocation;
+		break;
+	case FREQ:
+		ptr->freq = DataLocation;
+		break;
+	case SIDECHAIN:
+		ptr->sidechain = DataLocation;
+		break;
+	case MONITOR:
+		ptr->monitor = DataLocation;
+		break;
+	case ATTENUAT:
+		ptr->attenuat = DataLocation;
+		*(ptr->attenuat) = 0.0f;
+		break;
+	case INPUT:
+		ptr->input = DataLocation;
+		break;
+	case OUTPUT:
+		ptr->output = DataLocation;
+		break;
+	}
+}
+
+
+
+void 
+run_DeEsser(LADSPA_Handle Instance,
+	    unsigned long SampleCount) {
+  
+	DeEsser * ptr = (DeEsser *)Instance;
+
+	LADSPA_Data * input = ptr->input;
+	LADSPA_Data * output = ptr->output;
+	LADSPA_Data threshold = LIMIT(*(ptr->threshold),-50.0f,10.0f);
+	LADSPA_Data freq = LIMIT(*(ptr->freq),2000.0f,16000.0f);
+	LADSPA_Data sidechain = LIMIT(*(ptr->sidechain),0.0f,1.0f);
+	LADSPA_Data monitor = LIMIT(*(ptr->monitor),0.0f,1.0f);
+	unsigned long sample_index;
+
+	LADSPA_Data in = 0;
+	LADSPA_Data out = 0;
+	LADSPA_Data sidech = 0;
+	LADSPA_Data ampl_db = 0.0f;
+	LADSPA_Data attn = 0.0f;
+	LADSPA_Data max_attn = 0.0f;
+
+
+	if (ptr->old_freq != freq) {
+		lp_set_params(&ptr->sidech_lo_filter, freq, SIDECH_BW, ptr->sample_rate);
+		hp_set_params(&ptr->sidech_hi_filter, freq, SIDECH_BW, ptr->sample_rate);
+		ptr->old_freq = freq;
+	}
+
+	for (sample_index = 0; sample_index < SampleCount; sample_index++) {
+
+		in = *(input++);
+
+		/* process sidechain filters */
+		sidech = biquad_run(&ptr->sidech_hi_filter, in);
+		if (sidechain > 0.1f)
+			sidech = biquad_run(&ptr->sidech_lo_filter, sidech);
+
+		ampl_db = fast_lin2db(sidech);
+		if (ampl_db <= threshold)
+			attn = 0.0f;
+		else
+			attn = -0.5f * (ampl_db - threshold);
+
+		ptr->sum += attn;
+		ptr->sum -= push_buffer(attn, ptr->ringbuffer, ptr->buflen, &ptr->pos);
+
+		if (-1.0f * ptr->sum > max_attn)
+			max_attn = -0.01f * ptr->sum;
+
+		in *= db2lin(ptr->sum / 100.0f);
+
+
+		/* output selector */
+		if (monitor > 0.1f)
+			out = sidech;
+		else
+			out = in;
+
+		*(output++) = out;
+		*(ptr->attenuat) = LIMIT(max_attn,0,10);
+	}
+}
+
+
+void
+set_run_adding_gain_DeEsser(LADSPA_Handle Instance, LADSPA_Data gain) {
+
+	DeEsser * ptr = (DeEsser *)Instance;
+
+	ptr->run_adding_gain = gain;
+}
+
+
+
+void 
+run_adding_DeEsser(LADSPA_Handle Instance,
+		   unsigned long SampleCount) {
+  
+	DeEsser * ptr = (DeEsser *)Instance;
+
+	LADSPA_Data * input = ptr->input;
+	LADSPA_Data * output = ptr->output;
+	LADSPA_Data threshold = LIMIT(*(ptr->threshold),-50.0f,10.0f);
+	LADSPA_Data freq = LIMIT(*(ptr->freq),2000.0f,16000.0f);
+	LADSPA_Data sidechain = LIMIT(*(ptr->sidechain),0.0f,1.0f);
+	LADSPA_Data monitor = LIMIT(*(ptr->monitor),0.0f,1.0f);
+	unsigned long sample_index;
+
+	LADSPA_Data in = 0;
+	LADSPA_Data out = 0;
+	LADSPA_Data sidech = 0;
+	LADSPA_Data ampl_db = 0.0f;
+	LADSPA_Data attn = 0.0f;
+	LADSPA_Data max_attn = 0.0f;
+
+
+	if (ptr->old_freq != freq) {
+		lp_set_params(&ptr->sidech_lo_filter, freq, SIDECH_BW, ptr->sample_rate);
+		hp_set_params(&ptr->sidech_hi_filter, freq, SIDECH_BW, ptr->sample_rate);
+		ptr->old_freq = freq;
+	}
+
+	for (sample_index = 0; sample_index < SampleCount; sample_index++) {
+
+		in = *(input++);
+
+		/* process sidechain filters */
+		sidech = biquad_run(&ptr->sidech_hi_filter, in);
+		if (sidechain > 0.1f)
+			sidech = biquad_run(&ptr->sidech_lo_filter, sidech);
+
+		ampl_db = 20.0f * log10f(sidech);
+		if (ampl_db <= threshold)
+			attn = 0.0f;
+		else
+			attn = -0.5f * (ampl_db - threshold);
+
+		ptr->sum += attn;
+		ptr->sum -= push_buffer(attn, ptr->ringbuffer, ptr->buflen, &ptr->pos);
+
+		if (-1.0f * ptr->sum > max_attn)
+			max_attn = -0.01f * ptr->sum;
+
+		in *= db2lin(ptr->sum / 100.0f);
+
+
+		/* output selector */
+		if (monitor > 0.1f)
+			out = sidech;
+		else
+			out = in;
+
+		*(output++) += ptr->run_adding_gain * out;
+		*(ptr->attenuat) = LIMIT(max_attn,0,10);
+	}
+}
+
+
+
+/* Throw away a DeEsser effect instance. */
+void 
+cleanup_DeEsser(LADSPA_Handle Instance) {
+
+	DeEsser * ptr = (DeEsser *)Instance;
+	free(ptr->ringbuffer);
+	free(Instance);
+}
+
+
+
+LADSPA_Descriptor * mono_descriptor = NULL;
+
+
+
+/* __attribute__((constructor)) _init() is called automatically when the plugin library is first
+   loaded. */
+void 
+__attribute__((constructor)) _init() {
+	
+	int i;
+	char ** port_names;
+	LADSPA_PortDescriptor * port_descriptors;
+	LADSPA_PortRangeHint * port_range_hints;
+	
+	if ((mono_descriptor = 
+	     (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor))) == NULL)
+		exit(1);
+	
+
+	/* compute the log10 table */
+        for (i = 0; i < 9000; i++)
+                log10_table[i] = log10f(1.0f + i / 1000.0f);
+
+
+	mono_descriptor->UniqueID = ID_MONO;
+	mono_descriptor->Label = strdup("tap_deesser");
+	mono_descriptor->Properties = 0;
+	mono_descriptor->Name = strdup("TAP DeEsser");
+	mono_descriptor->Maker = strdup("Tom Szilagyi");
+	mono_descriptor->Copyright = strdup("GPL");
+	mono_descriptor->PortCount = PORTCOUNT_MONO;
+
+	if ((port_descriptors =
+	     (LADSPA_PortDescriptor *)calloc(PORTCOUNT_MONO, sizeof(LADSPA_PortDescriptor))) == NULL)
+		exit(1);
+
+	mono_descriptor->PortDescriptors = (const LADSPA_PortDescriptor *)port_descriptors;
+	port_descriptors[THRESHOLD] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[FREQ] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[SIDECHAIN] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[MONITOR] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[ATTENUAT] = LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[INPUT] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+
+	if ((port_names = 
+	     (char **)calloc(PORTCOUNT_MONO, sizeof(char *))) == NULL)
+		exit(1);
+
+	mono_descriptor->PortNames = (const char **)port_names;
+	port_names[THRESHOLD] = strdup("Threshold Level [dB]");
+	port_names[FREQ] = strdup("Frequency [Hz]");
+	port_names[SIDECHAIN] = strdup("Sidechain Filter");
+	port_names[MONITOR] = strdup("Monitor");
+	port_names[ATTENUAT] = strdup("Attenuation [dB]");
+	port_names[INPUT] = strdup("Input");
+	port_names[OUTPUT] = strdup("Output");
+
+	if ((port_range_hints = 
+	     ((LADSPA_PortRangeHint *)calloc(PORTCOUNT_MONO, sizeof(LADSPA_PortRangeHint)))) == NULL)
+		exit(1);
+
+	mono_descriptor->PortRangeHints	= (const LADSPA_PortRangeHint *)port_range_hints;
+	port_range_hints[THRESHOLD].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[FREQ].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_LOW);
+	port_range_hints[SIDECHAIN].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_INTEGER |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[MONITOR].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_INTEGER |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[ATTENUAT].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[THRESHOLD].LowerBound = -50;
+	port_range_hints[THRESHOLD].UpperBound = 10;
+	port_range_hints[FREQ].LowerBound = 2000;
+	port_range_hints[FREQ].UpperBound = 16000;
+	port_range_hints[SIDECHAIN].LowerBound = 0.0f;
+	port_range_hints[SIDECHAIN].UpperBound = 1.01f;
+	port_range_hints[MONITOR].LowerBound = 0.0f;
+	port_range_hints[MONITOR].UpperBound = 1.01f;
+	port_range_hints[ATTENUAT].LowerBound = 0.0f;
+	port_range_hints[ATTENUAT].UpperBound = 10.0f;
+	port_range_hints[INPUT].HintDescriptor = 0;
+	port_range_hints[OUTPUT].HintDescriptor = 0;
+	mono_descriptor->instantiate = instantiate_DeEsser;
+	mono_descriptor->connect_port = connect_port_DeEsser;
+	mono_descriptor->activate = activate_DeEsser;
+	mono_descriptor->run = run_DeEsser;
+	mono_descriptor->run_adding = run_adding_DeEsser;
+	mono_descriptor->set_run_adding_gain = set_run_adding_gain_DeEsser;
+	mono_descriptor->deactivate = NULL;
+	mono_descriptor->cleanup = cleanup_DeEsser;
+}
+
+
+void
+delete_descriptor(LADSPA_Descriptor * descriptor) {
+	unsigned long index;
+	if (descriptor) {
+		free((char *)descriptor->Label);
+		free((char *)descriptor->Name);
+		free((char *)descriptor->Maker);
+		free((char *)descriptor->Copyright);
+		free((LADSPA_PortDescriptor *)descriptor->PortDescriptors);
+		for (index = 0; index < descriptor->PortCount; index++)
+			free((char *)(descriptor->PortNames[index]));
+		free((char **)descriptor->PortNames);
+		free((LADSPA_PortRangeHint *)descriptor->PortRangeHints);
+		free(descriptor);
+	}
+}
+
+
+/* __attribute__((destructor)) _fini() is called automatically when the library is unloaded. */
+void
+__attribute__((destructor)) _fini() {
+	delete_descriptor(mono_descriptor);
+}
+
+
+/* Return a descriptor of the requested plugin type. */
+const LADSPA_Descriptor * 
+ladspa_descriptor(unsigned long Index) {
+
+	switch (Index) {
+	case 0:
+		return mono_descriptor;
+	default:
+		return NULL;
+	}
+}

=== added file '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_doubler.c'
--- .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_doubler.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_doubler.c	2014-04-11 06:58:04 +0000
@@ -0,0 +1,737 @@
+/*                                                     -*- linux-c -*-
+    Copyright (C) 2004 Tom Szilagyi
+    
+    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.
+
+    $Id: tap_doubler.c,v 1.4 2004/08/13 18:34:31 tszilagyi Exp $
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+
+#include <ladspa.h>
+#include "tap_utils.h"
+
+
+/* The Unique ID of the plugin: */
+
+#define ID_STEREO       2156
+
+/* The port numbers for the plugin: */
+
+#define TIME            0
+#define PITCH           1
+#define DRYLEVEL        2
+#define DRYPOSL         3
+#define DRYPOSR         4
+#define WETLEVEL        5
+#define WETPOSL         6
+#define WETPOSR         7
+#define INPUT_L         8
+#define INPUT_R         9
+#define OUTPUT_L       10
+#define OUTPUT_R       11
+
+/* Total number of ports */
+
+
+#define PORTCOUNT_STEREO 12
+
+
+/* Number of pink noise samples to be generated at once */
+#define NOISE_LEN 1024
+
+/*
+ * Largest buffer length needed (at 192 kHz).
+ */
+#define BUFLEN 11520
+
+
+
+/* The structure used to hold port connection information and state */
+
+typedef struct {
+	LADSPA_Data * time;
+	LADSPA_Data * pitch;
+	LADSPA_Data * drylevel;
+	LADSPA_Data * dryposl;
+	LADSPA_Data * dryposr;
+	LADSPA_Data * wetlevel;
+	LADSPA_Data * wetposl;
+	LADSPA_Data * wetposr;
+	LADSPA_Data * input_L;
+	LADSPA_Data * input_R;
+	LADSPA_Data * output_L;
+	LADSPA_Data * output_R;
+
+	LADSPA_Data old_time;
+	LADSPA_Data old_pitch;
+
+	LADSPA_Data * ring_L;
+	unsigned long buflen_L;
+	unsigned long pos_L;
+
+	LADSPA_Data * ring_R;
+	unsigned long buflen_R;
+	unsigned long pos_R;
+
+	LADSPA_Data * ring_pnoise;
+	unsigned long buflen_pnoise;
+	unsigned long pos_pnoise;
+
+	LADSPA_Data * ring_dnoise;
+	unsigned long buflen_dnoise;
+	unsigned long pos_dnoise;
+
+	float delay;
+	float d_delay;
+	float p_delay;
+	unsigned long n_delay;
+
+	float pitchmod;
+	float d_pitch;
+	float p_pitch;
+	unsigned long n_pitch;
+
+	unsigned long p_stretch;
+	unsigned long d_stretch;
+
+	unsigned long sample_rate;
+	LADSPA_Data run_adding_gain;
+} Doubler;
+
+
+/* generate fractal pattern using Midpoint Displacement Method
+ * v: buffer of floats to output fractal pattern to
+ * N: length of v, MUST be integer power of 2 (ie 128, 256, ...)
+ * H: Hurst constant, between 0 and 0.9999 (fractal dimension)
+ */
+void
+fractal(LADSPA_Data * v, int N, float H) {
+
+        int l = N;
+        int k;
+        float r = 1.0f;
+        int c;
+
+        v[0] = 0;
+        while (l > 1) {
+                k = N / l;
+                for (c = 0; c < k; c++) {
+                        v[c*l + l/2] = (v[c*l] + v[((c+1) * l) % N]) / 2.0f +
+                                2.0f * r * (rand() - (float)RAND_MAX/2.0f) / (float)RAND_MAX;
+                        v[c*l + l/2] = LIMIT(v[c*l + l/2], -1.0f, 1.0f);
+                }
+                l /= 2;
+                r /= powf(2, H);
+        }
+}
+
+
+
+/* Construct a new plugin instance. */
+LADSPA_Handle 
+instantiate_Doubler(const LADSPA_Descriptor * Descriptor,
+		    unsigned long             sample_rate) {
+  
+        LADSPA_Handle * ptr;
+	
+	if ((ptr = malloc(sizeof(Doubler))) != NULL) {
+		((Doubler *)ptr)->sample_rate = sample_rate;
+		((Doubler *)ptr)->run_adding_gain = 1.0f;
+
+		if ((((Doubler *)ptr)->ring_L = 
+		     calloc(BUFLEN * sample_rate / 192000, sizeof(LADSPA_Data))) == NULL)
+			return NULL;
+		((Doubler *)ptr)->buflen_L = BUFLEN * sample_rate / 192000;
+		((Doubler *)ptr)->pos_L = 0;
+
+		if ((((Doubler *)ptr)->ring_R = 
+		     calloc(BUFLEN * sample_rate / 192000, sizeof(LADSPA_Data))) == NULL)
+			return NULL;
+		((Doubler *)ptr)->buflen_R = BUFLEN * sample_rate / 192000;
+		((Doubler *)ptr)->pos_R = 0;
+
+		if ((((Doubler *)ptr)->ring_pnoise = 
+		     calloc(NOISE_LEN, sizeof(LADSPA_Data))) == NULL)
+			return NULL;
+		((Doubler *)ptr)->buflen_pnoise = NOISE_LEN;
+		((Doubler *)ptr)->pos_pnoise = 0;
+
+		if ((((Doubler *)ptr)->ring_dnoise = 
+		     calloc(NOISE_LEN, sizeof(LADSPA_Data))) == NULL)
+			return NULL;
+		((Doubler *)ptr)->buflen_dnoise = NOISE_LEN;
+		((Doubler *)ptr)->pos_dnoise = 0;
+
+		((Doubler *)ptr)->d_stretch = sample_rate / 10;
+		((Doubler *)ptr)->p_stretch = sample_rate / 1000;
+
+		((Doubler *)ptr)->delay = 0.0f;
+		((Doubler *)ptr)->d_delay = 0.0f;
+		((Doubler *)ptr)->p_delay = 0.0f;
+		((Doubler *)ptr)->n_delay = ((Doubler *)ptr)->d_stretch;
+
+		((Doubler *)ptr)->pitchmod = 0.0f;
+		((Doubler *)ptr)->d_pitch = 0.0f;
+		((Doubler *)ptr)->p_pitch = 0.0f;
+		((Doubler *)ptr)->n_pitch = ((Doubler *)ptr)->p_stretch;
+
+		return ptr;
+	}
+       	return NULL;
+}
+
+
+void
+activate_Doubler(LADSPA_Handle Instance) {
+
+	Doubler * ptr = (Doubler *)Instance;
+	unsigned long i;
+
+	for (i = 0; i < BUFLEN * ptr->sample_rate / 192000; i++) {
+		ptr->ring_L[i] = 0.0f;
+		ptr->ring_R[i] = 0.0f;
+	}
+
+	ptr->old_time = -1.0f;
+	ptr->old_pitch = -1.0f;
+}
+
+
+
+
+/* Connect a port to a data location. */
+void 
+connect_port_Doubler(LADSPA_Handle Instance,
+		     unsigned long Port,
+		     LADSPA_Data * data) {
+	
+	Doubler * ptr = (Doubler *)Instance;
+
+	switch (Port) {
+	case TIME:
+		ptr->time = data;
+		break;
+	case PITCH:
+		ptr->pitch = data;
+		break;
+	case DRYLEVEL:
+		ptr->drylevel = data;
+		break;
+	case DRYPOSL:
+		ptr->dryposl = data;
+		break;
+	case DRYPOSR:
+		ptr->dryposr = data;
+		break;
+	case WETLEVEL:
+		ptr->wetlevel = data;
+		break;
+	case WETPOSL:
+		ptr->wetposl = data;
+		break;
+	case WETPOSR:
+		ptr->wetposr = data;
+		break;
+	case INPUT_L:
+		ptr->input_L = data;
+		break;
+	case INPUT_R:
+		ptr->input_R = data;
+		break;
+	case OUTPUT_L:
+		ptr->output_L = data;
+		break;
+	case OUTPUT_R:
+		ptr->output_R = data;
+		break;
+	}
+}
+
+
+
+void 
+run_Doubler(LADSPA_Handle Instance,
+	    unsigned long SampleCount) {
+  
+	Doubler * ptr = (Doubler *)Instance;
+
+	LADSPA_Data pitch = LIMIT(*(ptr->pitch),0.0f,1.0f) + 0.75f;
+	LADSPA_Data depth = LIMIT(((1.0f - LIMIT(*(ptr->pitch),0.0f,1.0f)) * 1.75f + 0.25f) *
+				  ptr->sample_rate / 6000.0f / M_PI,
+				  0, ptr->buflen_L / 2);
+	LADSPA_Data time = LIMIT(*(ptr->time), 0.0f, 1.0f) + 0.5f;
+	LADSPA_Data drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f));
+	LADSPA_Data wetlevel = db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f));
+	LADSPA_Data dryposl = 1.0f - LIMIT(*(ptr->dryposl), 0.0f, 1.0f);
+	LADSPA_Data dryposr = LIMIT(*(ptr->dryposr), 0.0f, 1.0f);
+	LADSPA_Data wetposl = 1.0f - LIMIT(*(ptr->wetposl), 0.0f, 1.0f);
+	LADSPA_Data wetposr = LIMIT(*(ptr->wetposr), 0.0f, 1.0f);
+	LADSPA_Data * input_L = ptr->input_L;
+	LADSPA_Data * input_R = ptr->input_R;
+	LADSPA_Data * output_L = ptr->output_L;
+	LADSPA_Data * output_R = ptr->output_R;
+
+	unsigned long sample_index;
+	unsigned long sample_count = SampleCount;
+
+	LADSPA_Data in_L = 0.0f;
+	LADSPA_Data in_R = 0.0f;
+	LADSPA_Data out_L = 0.0f;
+	LADSPA_Data out_R = 0.0f;
+
+	LADSPA_Data fpos = 0.0f;
+	LADSPA_Data n = 0.0f;
+	LADSPA_Data rem = 0.0f;
+	LADSPA_Data s_a_L, s_a_R, s_b_L, s_b_R;
+	LADSPA_Data prev_p_pitch = 0.0f;
+	LADSPA_Data prev_p_delay = 0.0f;
+	LADSPA_Data delay;
+
+	LADSPA_Data drystream_L = 0.0f;
+	LADSPA_Data drystream_R = 0.0f;
+	LADSPA_Data wetstream_L = 0.0f;
+	LADSPA_Data wetstream_R = 0.0f;
+
+	if (ptr->old_pitch != pitch) {
+		ptr->pitchmod = ptr->p_pitch;
+		prev_p_pitch = ptr->p_pitch;
+		fractal(ptr->ring_pnoise, NOISE_LEN, pitch);
+		ptr->pos_pnoise = 0;
+		ptr->p_pitch = push_buffer(0.0f, ptr->ring_pnoise,
+					   ptr->buflen_pnoise, &(ptr->pos_pnoise));
+		ptr->d_pitch = (ptr->p_pitch - prev_p_pitch) / (float)(ptr->p_stretch);
+		ptr->n_pitch = 0;
+
+		ptr->old_pitch = pitch;
+	}
+
+	if (ptr->old_time != time) {
+		ptr->delay = ptr->p_delay;
+		prev_p_delay = ptr->p_delay;
+		fractal(ptr->ring_dnoise, NOISE_LEN, time);
+		ptr->pos_dnoise = 0;
+		ptr->p_delay = push_buffer(0.0f, ptr->ring_dnoise,
+					   ptr->buflen_dnoise, &(ptr->pos_dnoise));
+		ptr->d_delay = (ptr->p_delay - prev_p_delay) / (float)(ptr->d_stretch);
+		ptr->n_delay = 0;
+
+		ptr->old_time = time;
+	}
+
+
+	for (sample_index = 0; sample_index < sample_count; sample_index++) {
+
+		in_L = *(input_L++);
+		in_R = *(input_R++);
+
+		push_buffer(in_L, ptr->ring_L, ptr->buflen_L, &(ptr->pos_L));
+		push_buffer(in_R, ptr->ring_R, ptr->buflen_R, &(ptr->pos_R));
+
+		if (ptr->n_pitch < ptr->p_stretch) {
+			ptr->pitchmod += ptr->d_pitch;
+			ptr->n_pitch++;
+		} else {
+			ptr->pitchmod = ptr->p_pitch;
+			prev_p_pitch = ptr->p_pitch;
+			if (!ptr->pos_pnoise) {
+				fractal(ptr->ring_pnoise, NOISE_LEN, pitch);
+			}
+			ptr->p_pitch = push_buffer(0.0f, ptr->ring_pnoise,
+						   ptr->buflen_pnoise, &(ptr->pos_pnoise));
+			ptr->d_pitch = (ptr->p_pitch - prev_p_pitch) / (float)(ptr->p_stretch);
+			ptr->n_pitch = 0;
+		}
+
+		if (ptr->n_delay < ptr->d_stretch) {
+			ptr->delay += ptr->d_delay;
+			ptr->n_delay++;
+		} else {
+			ptr->delay = ptr->p_delay;
+			prev_p_delay = ptr->p_delay;
+			if (!ptr->pos_dnoise) {
+				fractal(ptr->ring_dnoise, NOISE_LEN, time);
+			}
+			ptr->p_delay = push_buffer(0.0f, ptr->ring_dnoise,
+						   ptr->buflen_dnoise, &(ptr->pos_dnoise));
+			ptr->d_delay = (ptr->p_delay - prev_p_delay) / (float)(ptr->d_stretch);
+			ptr->n_delay = 0;
+		}
+
+		delay = (12.5f * ptr->delay + 37.5f) * ptr->sample_rate / 1000.0f;
+		fpos = ptr->buflen_L - depth * (1.0f - ptr->pitchmod) - delay - 1.0f;
+		n = floorf(fpos);
+		rem = fpos - n;
+
+		s_a_L = read_buffer(ptr->ring_L, ptr->buflen_L,
+				    ptr->pos_L, (unsigned long) n);
+		s_b_L = read_buffer(ptr->ring_L, ptr->buflen_L,
+				    ptr->pos_L, (unsigned long) n + 1);
+
+		s_a_R = read_buffer(ptr->ring_R, ptr->buflen_R,
+				    ptr->pos_R, (unsigned long) n);
+		s_b_R = read_buffer(ptr->ring_R, ptr->buflen_R,
+				    ptr->pos_R, (unsigned long) n + 1);
+
+		drystream_L = drylevel * in_L;
+		drystream_R = drylevel * in_R;
+		wetstream_L = wetlevel * ((1 - rem) * s_a_L + rem * s_b_L);
+		wetstream_R = wetlevel * ((1 - rem) * s_a_R + rem * s_b_R);
+
+		out_L = dryposl * drystream_L + (1.0f - dryposr) * drystream_R +
+			wetposl * wetstream_L + (1.0f - wetposr) * wetstream_R;
+		out_R = (1.0f - dryposl) * drystream_L + dryposr * drystream_R +
+			(1.0f - wetposl) * wetstream_L + wetposr * wetstream_R;
+
+		*(output_L++) = out_L;
+		*(output_R++) = out_R;
+	}
+}
+
+
+void
+set_run_adding_gain_Doubler(LADSPA_Handle Instance, LADSPA_Data gain) {
+
+	Doubler * ptr = (Doubler *)Instance;
+
+	ptr->run_adding_gain = gain;
+}
+
+
+
+void 
+run_adding_Doubler(LADSPA_Handle Instance,
+		   unsigned long SampleCount) {
+  
+	Doubler * ptr = (Doubler *)Instance;
+
+	LADSPA_Data pitch = LIMIT(*(ptr->pitch),0.0f,1.0f) + 0.75f;
+	LADSPA_Data depth = LIMIT(((1.0f - LIMIT(*(ptr->pitch),0.0f,1.0f)) * 1.75f + 0.25f) *
+				  ptr->sample_rate / 6000.0f / M_PI,
+				  0, ptr->buflen_L / 2);
+	LADSPA_Data time = LIMIT(*(ptr->time), 0.0f, 1.0f) + 0.5f;
+	LADSPA_Data drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f));
+	LADSPA_Data wetlevel = db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f));
+	LADSPA_Data dryposl = 1.0f - LIMIT(*(ptr->dryposl), 0.0f, 1.0f);
+	LADSPA_Data dryposr = LIMIT(*(ptr->dryposr), 0.0f, 1.0f);
+	LADSPA_Data wetposl = 1.0f - LIMIT(*(ptr->wetposl), 0.0f, 1.0f);
+	LADSPA_Data wetposr = LIMIT(*(ptr->wetposr), 0.0f, 1.0f);
+	LADSPA_Data * input_L = ptr->input_L;
+	LADSPA_Data * input_R = ptr->input_R;
+	LADSPA_Data * output_L = ptr->output_L;
+	LADSPA_Data * output_R = ptr->output_R;
+
+	unsigned long sample_index;
+	unsigned long sample_count = SampleCount;
+
+	LADSPA_Data in_L = 0.0f;
+	LADSPA_Data in_R = 0.0f;
+	LADSPA_Data out_L = 0.0f;
+	LADSPA_Data out_R = 0.0f;
+
+	LADSPA_Data fpos = 0.0f;
+	LADSPA_Data n = 0.0f;
+	LADSPA_Data rem = 0.0f;
+	LADSPA_Data s_a_L, s_a_R, s_b_L, s_b_R;
+	LADSPA_Data prev_p_pitch = 0.0f;
+	LADSPA_Data prev_p_delay = 0.0f;
+	LADSPA_Data delay;
+
+	LADSPA_Data drystream_L = 0.0f;
+	LADSPA_Data drystream_R = 0.0f;
+	LADSPA_Data wetstream_L = 0.0f;
+	LADSPA_Data wetstream_R = 0.0f;
+
+	if (ptr->old_pitch != pitch) {
+		ptr->pitchmod = ptr->p_pitch;
+		prev_p_pitch = ptr->p_pitch;
+		fractal(ptr->ring_pnoise, NOISE_LEN, pitch);
+		ptr->pos_pnoise = 0;
+		ptr->p_pitch = push_buffer(0.0f, ptr->ring_pnoise,
+					   ptr->buflen_pnoise, &(ptr->pos_pnoise));
+		ptr->d_pitch = (ptr->p_pitch - prev_p_pitch) / (float)(ptr->p_stretch);
+		ptr->n_pitch = 0;
+
+		ptr->old_pitch = pitch;
+	}
+
+	if (ptr->old_time != time) {
+		ptr->delay = ptr->p_delay;
+		prev_p_delay = ptr->p_delay;
+		fractal(ptr->ring_dnoise, NOISE_LEN, time);
+		ptr->pos_dnoise = 0;
+		ptr->p_delay = push_buffer(0.0f, ptr->ring_dnoise,
+					   ptr->buflen_dnoise, &(ptr->pos_dnoise));
+		ptr->d_delay = (ptr->p_delay - prev_p_delay) / (float)(ptr->d_stretch);
+		ptr->n_delay = 0;
+
+		ptr->old_time = time;
+	}
+
+
+	for (sample_index = 0; sample_index < sample_count; sample_index++) {
+
+		in_L = *(input_L++);
+		in_R = *(input_R++);
+
+		push_buffer(in_L, ptr->ring_L, ptr->buflen_L, &(ptr->pos_L));
+		push_buffer(in_R, ptr->ring_R, ptr->buflen_R, &(ptr->pos_R));
+
+		if (ptr->n_pitch < ptr->p_stretch) {
+			ptr->pitchmod += ptr->d_pitch;
+			ptr->n_pitch++;
+		} else {
+			ptr->pitchmod = ptr->p_pitch;
+			prev_p_pitch = ptr->p_pitch;
+			if (!ptr->pos_pnoise) {
+				fractal(ptr->ring_pnoise, NOISE_LEN, pitch);
+			}
+			ptr->p_pitch = push_buffer(0.0f, ptr->ring_pnoise,
+						   ptr->buflen_pnoise, &(ptr->pos_pnoise));
+			ptr->d_pitch = (ptr->p_pitch - prev_p_pitch) / (float)(ptr->p_stretch);
+			ptr->n_pitch = 0;
+		}
+
+		if (ptr->n_delay < ptr->d_stretch) {
+			ptr->delay += ptr->d_delay;
+			ptr->n_delay++;
+		} else {
+			ptr->delay = ptr->p_delay;
+			prev_p_delay = ptr->p_delay;
+			if (!ptr->pos_dnoise) {
+				fractal(ptr->ring_dnoise, NOISE_LEN, time);
+			}
+			ptr->p_delay = push_buffer(0.0f, ptr->ring_dnoise,
+						   ptr->buflen_dnoise, &(ptr->pos_dnoise));
+			ptr->d_delay = (ptr->p_delay - prev_p_delay) / (float)(ptr->d_stretch);
+			ptr->n_delay = 0;
+		}
+
+		delay = (12.5f * ptr->delay + 37.5f) * ptr->sample_rate / 1000.0f;
+		fpos = ptr->buflen_L - depth * (1.0f - ptr->pitchmod) - delay - 1.0f;
+		n = floorf(fpos);
+		rem = fpos - n;
+
+		s_a_L = read_buffer(ptr->ring_L, ptr->buflen_L,
+				    ptr->pos_L, (unsigned long) n);
+		s_b_L = read_buffer(ptr->ring_L, ptr->buflen_L,
+				    ptr->pos_L, (unsigned long) n + 1);
+
+		s_a_R = read_buffer(ptr->ring_R, ptr->buflen_R,
+				    ptr->pos_R, (unsigned long) n);
+		s_b_R = read_buffer(ptr->ring_R, ptr->buflen_R,
+				    ptr->pos_R, (unsigned long) n + 1);
+
+		drystream_L = drylevel * in_L;
+		drystream_R = drylevel * in_R;
+		wetstream_L = wetlevel * ((1 - rem) * s_a_L + rem * s_b_L);
+		wetstream_R = wetlevel * ((1 - rem) * s_a_R + rem * s_b_R);
+
+		out_L = dryposl * drystream_L + (1.0f - dryposr) * drystream_R +
+			wetposl * wetstream_L + (1.0f - wetposr) * wetstream_R;
+		out_R = (1.0f - dryposl) * drystream_L + dryposr * drystream_R +
+			(1.0f - wetposl) * wetstream_L + wetposr * wetstream_R;
+
+		*(output_L++) += ptr->run_adding_gain * out_L;
+		*(output_R++) += ptr->run_adding_gain * out_R;
+	}
+}
+
+
+
+/* Throw away a Doubler effect instance. */
+void 
+cleanup_Doubler(LADSPA_Handle Instance) {
+
+  	Doubler * ptr = (Doubler *)Instance;
+	free(ptr->ring_L);
+	free(ptr->ring_R);
+	free(ptr->ring_pnoise);
+	free(ptr->ring_dnoise);
+	free(Instance);
+}
+
+
+
+LADSPA_Descriptor * stereo_descriptor = NULL;
+
+
+
+/* __attribute__((constructor)) _init() is called automatically when the plugin library is first
+   loaded. */
+void 
+__attribute__((constructor)) _init() {
+	
+	char ** port_names;
+	LADSPA_PortDescriptor * port_descriptors;
+	LADSPA_PortRangeHint * port_range_hints;
+	
+	if ((stereo_descriptor = 
+	     (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor))) == NULL)
+		exit(1);
+
+	stereo_descriptor->UniqueID = ID_STEREO;
+	stereo_descriptor->Label = strdup("tap_doubler");
+	stereo_descriptor->Properties = 0;
+	stereo_descriptor->Name = strdup("TAP Fractal Doubler");
+	stereo_descriptor->Maker = strdup("Tom Szilagyi");
+	stereo_descriptor->Copyright = strdup("GPL");
+	stereo_descriptor->PortCount = PORTCOUNT_STEREO;
+
+	if ((port_descriptors =
+	     (LADSPA_PortDescriptor *)calloc(PORTCOUNT_STEREO, sizeof(LADSPA_PortDescriptor))) == NULL)
+		exit(1);
+
+	stereo_descriptor->PortDescriptors = (const LADSPA_PortDescriptor *)port_descriptors;
+	port_descriptors[TIME] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[PITCH] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[DRYLEVEL] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[DRYPOSL] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[DRYPOSR] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[WETLEVEL] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[WETPOSL] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[WETPOSR] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[INPUT_L] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[INPUT_R] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT_L] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT_R] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+
+	if ((port_names = 
+	     (char **)calloc(PORTCOUNT_STEREO, sizeof(char *))) == NULL)
+		exit(1);
+
+	stereo_descriptor->PortNames = (const char **)port_names;
+	port_names[TIME] = strdup("Time Tracking");
+	port_names[PITCH] = strdup("Pitch Tracking");
+	port_names[DRYLEVEL] = strdup("Dry Level [dB]");
+	port_names[DRYPOSL] = strdup("Dry Left Position");
+	port_names[DRYPOSR] = strdup("Dry Right Position");
+	port_names[WETLEVEL] = strdup("Wet Level [dB]");
+	port_names[WETPOSL] = strdup("Wet Left Position");
+	port_names[WETPOSR] = strdup("Wet Right Position");
+	port_names[INPUT_L] = strdup("Input_L");
+	port_names[INPUT_R] = strdup("Input_R");
+	port_names[OUTPUT_L] = strdup("Output_L");
+	port_names[OUTPUT_R] = strdup("Output_R");
+
+	if ((port_range_hints = 
+	     ((LADSPA_PortRangeHint *)calloc(PORTCOUNT_STEREO, sizeof(LADSPA_PortRangeHint)))) == NULL)
+		exit(1);
+
+	stereo_descriptor->PortRangeHints = (const LADSPA_PortRangeHint *)port_range_hints;
+	port_range_hints[TIME].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_MIDDLE);
+	port_range_hints[PITCH].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_MIDDLE);
+	port_range_hints[DRYLEVEL].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[DRYPOSL].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_MINIMUM);
+	port_range_hints[DRYPOSR].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_MAXIMUM);
+	port_range_hints[WETLEVEL].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[WETPOSL].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_MINIMUM);
+	port_range_hints[WETPOSR].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_MAXIMUM);
+	port_range_hints[TIME].LowerBound = 0.0f;
+	port_range_hints[TIME].UpperBound = 1.0f;
+	port_range_hints[PITCH].LowerBound = 0.0f;
+	port_range_hints[PITCH].UpperBound = 1.0f;
+	port_range_hints[DRYLEVEL].LowerBound = -90.0f;
+	port_range_hints[DRYLEVEL].UpperBound = +20.0f;
+	port_range_hints[DRYPOSL].LowerBound = 0.0f;
+	port_range_hints[DRYPOSL].UpperBound = 1.0f;
+	port_range_hints[DRYPOSR].LowerBound = 0.0f;
+	port_range_hints[DRYPOSR].UpperBound = 1.0f;
+	port_range_hints[WETLEVEL].LowerBound = -90.0f;
+	port_range_hints[WETLEVEL].UpperBound = +20.0f;
+	port_range_hints[WETPOSL].LowerBound = 0.0f;
+	port_range_hints[WETPOSL].UpperBound = 1.0f;
+	port_range_hints[WETPOSR].LowerBound = 0.0f;
+	port_range_hints[WETPOSR].UpperBound = 1.0f;
+	port_range_hints[INPUT_L].HintDescriptor = 0;
+	port_range_hints[INPUT_R].HintDescriptor = 0;
+	port_range_hints[OUTPUT_L].HintDescriptor = 0;
+	port_range_hints[OUTPUT_R].HintDescriptor = 0;
+	stereo_descriptor->instantiate = instantiate_Doubler;
+	stereo_descriptor->connect_port = connect_port_Doubler;
+	stereo_descriptor->activate = activate_Doubler;
+	stereo_descriptor->run = run_Doubler;
+	stereo_descriptor->run_adding = run_adding_Doubler;
+	stereo_descriptor->set_run_adding_gain = set_run_adding_gain_Doubler;
+	stereo_descriptor->deactivate = NULL;
+	stereo_descriptor->cleanup = cleanup_Doubler;
+}
+
+
+void
+delete_descriptor(LADSPA_Descriptor * descriptor) {
+	unsigned long index;
+	if (descriptor) {
+		free((char *)descriptor->Label);
+		free((char *)descriptor->Name);
+		free((char *)descriptor->Maker);
+		free((char *)descriptor->Copyright);
+		free((LADSPA_PortDescriptor *)descriptor->PortDescriptors);
+		for (index = 0; index < descriptor->PortCount; index++)
+			free((char *)(descriptor->PortNames[index]));
+		free((char **)descriptor->PortNames);
+		free((LADSPA_PortRangeHint *)descriptor->PortRangeHints);
+		free(descriptor);
+	}
+}
+
+
+/* __attribute__((destructor)) _fini() is called automatically when the library is unloaded. */
+void
+__attribute__((destructor)) _fini() {
+	delete_descriptor(stereo_descriptor);
+}
+
+
+/* Return a descriptor of the requested plugin type. */
+const LADSPA_Descriptor * 
+ladspa_descriptor(unsigned long Index) {
+
+	switch (Index) {
+	case 0:
+		return stereo_descriptor;
+	default:
+		return NULL;
+	}
+}

=== added file '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_dynamics_m.c'
--- .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_dynamics_m.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_dynamics_m.c	2014-04-11 06:58:04 +0000
@@ -0,0 +1,666 @@
+/*                                                     -*- linux-c -*-
+    Copyright (C) 2004 Tom Szilagyi
+    
+    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.
+
+    $Id: tap_dynamics_m.c,v 1.2 2004/06/15 14:50:55 tszilagyi Exp $
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <math.h>
+
+#include <ladspa.h>
+#include "tap_utils.h"
+
+
+/* ***** VERY IMPORTANT! *****
+ *
+ * If you enable this, the plugin will use float arithmetics in DSP
+ * calculations.  This usually yields lower average CPU usage, but
+ * occasionaly may result in high CPU peaks which cause trouble to you
+ * and your JACK server.  The default is to use fixpoint arithmetics
+ * (with the following #define commented out).  But (depending on the
+ * processor on which you run the code) you may find floating point
+ * mode usable.
+ */
+/*#define DYN_CALC_FLOAT*/
+
+
+typedef signed int sample;
+
+/* coefficient for float to sample (signed int) conversion */
+#define F2S 2147483
+
+
+#ifdef DYN_CALC_FLOAT
+typedef LADSPA_Data dyn_t;
+typedef float rms_t;
+#else
+typedef sample dyn_t;
+typedef int64_t rms_t;
+#endif
+
+
+
+/* The Unique ID of the plugin: */
+
+#define ID_MONO         2152
+
+/* The port numbers for the plugin: */
+
+#define ATTACK          0
+#define RELEASE         1
+#define OFFSGAIN        2
+#define MUGAIN          3
+#define RMSENV          4
+#define MODGAIN         5
+#define MODE            6
+#define INPUT           7
+#define OUTPUT          8
+
+
+/* Total number of ports */
+
+#define PORTCOUNT_MONO   9
+
+
+#define TABSIZE 256
+#define RMSSIZE 64
+
+
+typedef struct {
+	rms_t        buffer[RMSSIZE];
+        unsigned int pos;
+        rms_t        sum;
+} rms_env;
+
+
+/* max. number of breakpoints on in/out dB graph */
+#define MAX_POINTS 20
+
+typedef struct {
+	LADSPA_Data x;
+	LADSPA_Data y;
+} GRAPH_POINT;
+
+typedef struct {
+	unsigned long num_points;
+	GRAPH_POINT points[MAX_POINTS];
+} DYNAMICS_DATA;
+
+#include "tap_dynamics_presets.h"
+
+
+/* The structure used to hold port connection information and state */
+
+typedef struct {
+	LADSPA_Data * attack;
+	LADSPA_Data * release;
+	LADSPA_Data * offsgain;
+	LADSPA_Data * mugain;
+	LADSPA_Data * rmsenv;
+	LADSPA_Data * modgain;
+	LADSPA_Data * mode;
+	LADSPA_Data * input;
+	LADSPA_Data * output;
+	unsigned long sample_rate;
+
+	float * as;
+	unsigned long count;
+	dyn_t amp;
+	dyn_t env;
+	float gain;
+	float gain_out;
+	rms_env * rms;
+	rms_t sum;
+
+	DYNAMICS_DATA graph;
+
+	LADSPA_Data run_adding_gain;
+} Dynamics;
+
+
+
+/* RMS envelope stuff, grabbed without a second thought from Steve Harris's swh-plugins, util/rms.c */
+/* Adapted, though, to be able to use fixed-point arithmetics as well. */
+
+rms_env *
+rms_env_new(void) {
+
+        rms_env * new = (rms_env *)calloc(1, sizeof(rms_env));
+
+        return new;
+}
+
+void
+rms_env_reset(rms_env *r) {
+
+        unsigned int i;
+
+        for (i = 0; i < RMSSIZE; i++) {
+                r->buffer[i] = 0.0f;
+        }
+        r->pos = 0;
+        r->sum = 0.0f;
+}
+
+inline static
+dyn_t
+rms_env_process(rms_env *r, const rms_t x) {
+
+        r->sum -= r->buffer[r->pos];
+        r->sum += x;
+        r->buffer[r->pos] = x;
+        r->pos = (r->pos + 1) & (RMSSIZE - 1);
+
+#ifdef DYN_CALC_FLOAT
+        return sqrt(r->sum / (float)RMSSIZE);
+#else
+        return sqrt(r->sum / RMSSIZE);
+#endif
+}
+
+
+
+inline
+LADSPA_Data
+get_table_gain(int mode, LADSPA_Data level) {
+
+	LADSPA_Data x1 = -80.0f;
+	LADSPA_Data y1 = -80.0f;
+	LADSPA_Data x2 = 0.0f;
+	LADSPA_Data y2 = 0.0f;
+	unsigned int i = 0;
+
+	if (level <= -80.0f)
+		return get_table_gain(mode, -79.9f);
+
+	while (i < dyn_data[mode].num_points && dyn_data[mode].points[i].x < level) {
+		x1 = dyn_data[mode].points[i].x;
+		y1 = dyn_data[mode].points[i].y;
+		i++;
+	}
+	if (i < dyn_data[mode].num_points) {
+		x2 = dyn_data[mode].points[i].x;
+		y2 = dyn_data[mode].points[i].y;
+	} else
+		return 0.0f;
+
+	return y1 + ((level - x1) * (y2 - y1) / (x2 - x1)) - level;
+}
+
+
+/* Construct a new plugin instance. */
+LADSPA_Handle 
+instantiate_Dynamics(const LADSPA_Descriptor * Descriptor, unsigned long sample_rate) {
+	
+	LADSPA_Handle * ptr;
+
+	float * as = NULL;
+	unsigned int count = 0;
+        dyn_t amp = 0.0f;
+	dyn_t env = 0.0f;
+	float gain = 0.0f;
+	float gain_out = 0.0f;
+	rms_env * rms = NULL;
+	rms_t sum = 0;
+	int i;
+	
+	if ((ptr = malloc(sizeof(Dynamics))) == NULL)
+		return NULL;
+
+	((Dynamics *)ptr)->sample_rate = sample_rate;
+	((Dynamics *)ptr)->run_adding_gain = 1.0;
+
+        if ((rms = rms_env_new()) == NULL)
+		return NULL;
+
+        if ((as = malloc(TABSIZE * sizeof(float))) == NULL)
+		return NULL;
+
+        as[0] = 1.0f;
+        for (i = 1; i < TABSIZE; i++) {
+		as[i] = expf(-1.0f / (sample_rate * (float)i / (float)TABSIZE));
+        }
+
+        ((Dynamics *)ptr)->as = as;
+        ((Dynamics *)ptr)->count = count;
+        ((Dynamics *)ptr)->amp = amp;
+        ((Dynamics *)ptr)->env = env;
+        ((Dynamics *)ptr)->gain = gain;
+        ((Dynamics *)ptr)->gain_out = gain_out;
+        ((Dynamics *)ptr)->rms = rms;
+        ((Dynamics *)ptr)->sum = sum;
+
+	return ptr;
+}
+
+
+
+/* Connect a port to a data location. */
+void 
+connect_port_Dynamics(LADSPA_Handle Instance,
+		     unsigned long Port,
+		     LADSPA_Data * DataLocation) {
+	
+	Dynamics * ptr = (Dynamics *)Instance;
+
+	switch (Port) {
+	case ATTACK:
+		ptr->attack = DataLocation;
+		break;
+	case RELEASE:
+		ptr->release = DataLocation;
+		break;
+	case OFFSGAIN:
+		ptr->offsgain = DataLocation;
+		break;
+	case MUGAIN:
+		ptr->mugain = DataLocation;
+		break;
+	case RMSENV:
+		ptr->rmsenv = DataLocation;
+		*(ptr->rmsenv) = -60.0f;
+		break;
+	case MODGAIN:
+		ptr->modgain = DataLocation;
+		*(ptr->modgain) = 0.0f;
+		break;
+	case MODE:
+		ptr->mode = DataLocation;
+		break;
+	case INPUT:
+		ptr->input = DataLocation;
+		break;
+	case OUTPUT:
+		ptr->output = DataLocation;
+		break;
+	}
+}
+
+
+
+void 
+run_Dynamics(LADSPA_Handle Instance,
+	     unsigned long sample_count) {
+
+	Dynamics * ptr = (Dynamics *)Instance;
+	LADSPA_Data * input = ptr->input;
+	LADSPA_Data * output = ptr->output;
+        const float attack = LIMIT(*(ptr->attack), 4.0f, 500.0f);
+        const float release = LIMIT(*(ptr->release), 4.0f, 1000.0f);
+        const float offsgain = LIMIT(*(ptr->offsgain), -20.0f, 20.0f);
+        const float mugain = db2lin(LIMIT(*(ptr->mugain), -20.0f, 20.0f));
+	const int mode = LIMIT(*(ptr->mode), 0, NUM_MODES-1);
+	unsigned long sample_index;
+
+        dyn_t amp = ptr->amp;
+        dyn_t env = ptr->env;
+        float * as = ptr->as;
+        unsigned int count = ptr->count;
+        float gain = ptr->gain;
+        float gain_out = ptr->gain_out;
+        rms_env * rms = ptr->rms;
+        rms_t sum = ptr->sum;
+
+        const float ga = as[(unsigned int)(attack * 0.001f * (float)(TABSIZE-1))];
+        const float gr = as[(unsigned int)(release * 0.001f * (float)(TABSIZE-1))];
+        const float ef_a = ga * 0.25f;
+        const float ef_ai = 1.0f - ef_a;
+
+	float level = 0.0f;
+	float adjust = 0.0f;
+
+        for (sample_index = 0; sample_index < sample_count; sample_index++) {
+
+#ifdef DYN_CALC_FLOAT
+		sum += input[sample_index] * input[sample_index];
+		if (amp > env) {
+			env = env * ga + amp * (1.0f - ga);
+		} else {
+			env = env * gr + amp * (1.0f - gr);
+		}
+#else
+		sum += (rms_t)(input[sample_index] * F2S * input[sample_index] * F2S);
+		if (amp) {
+			if (amp > env) {
+				env = (double)env * ga + (double)amp * (1.0f - ga);
+			} else {
+				env = (double)env * gr + (double)amp * (1.0f - gr);
+			}
+		} else
+			env = 0;
+#endif
+
+		if (count++ % 4 == 3) {
+#ifdef DYN_CALC_FLOAT
+			amp = rms_env_process(rms, sum / 4);
+#else
+			if (sum)
+				amp = rms_env_process(rms, sum / 4);
+			else
+				amp = 0;
+#endif
+
+#ifdef DYN_CALC_FLOAT
+			if (isnan(amp))
+				amp = 0.0f;
+#endif
+			sum = 0;
+
+			/* set gain_out according to the difference between
+			   the envelope volume level (env) and the corresponding
+			   output level (from graph) */
+#ifdef DYN_CALC_FLOAT
+			level = 20 * log10f(2 * env);
+#else
+			level = 20 * log10f(2 * (double)env / (double)F2S);
+#endif
+			adjust = get_table_gain(mode, level + offsgain);
+			gain_out = db2lin(adjust);
+
+		}
+		gain = gain * ef_a + gain_out * ef_ai;
+		output[sample_index] = input[sample_index] * gain * mugain;
+        }
+        ptr->sum = sum;
+        ptr->amp = amp;
+        ptr->gain = gain;
+        ptr->gain_out = gain_out;
+        ptr->env = env;
+        ptr->count = count;
+
+	*(ptr->rmsenv) = LIMIT(level, -60.0f, 20.0f);
+	*(ptr->modgain) = LIMIT(adjust, -60.0f, 20.0f);
+}
+
+
+
+void
+set_run_adding_gain_Dynamics(LADSPA_Handle Instance, LADSPA_Data gain) {
+
+	Dynamics * ptr = (Dynamics *)Instance;
+
+	ptr->run_adding_gain = gain;
+}
+
+
+
+void 
+run_adding_Dynamics(LADSPA_Handle Instance,
+		    unsigned long sample_count) {
+
+	Dynamics * ptr = (Dynamics *)Instance;
+	LADSPA_Data * input = ptr->input;
+	LADSPA_Data * output = ptr->output;
+        const float attack = LIMIT(*(ptr->attack), 4.0f, 500.0f);
+        const float release = LIMIT(*(ptr->release), 4.0f, 1000.0f);
+        const float offsgain = LIMIT(*(ptr->offsgain), -20.0f, 20.0f);
+        const float mugain = db2lin(LIMIT(*(ptr->mugain), -20.0f, 20.0f));
+	const int mode = LIMIT(*(ptr->mode), 0, NUM_MODES-1);
+	unsigned long sample_index;
+
+        dyn_t amp = ptr->amp;
+        dyn_t env = ptr->env;
+        float * as = ptr->as;
+        unsigned int count = ptr->count;
+        float gain = ptr->gain;
+        float gain_out = ptr->gain_out;
+        rms_env * rms = ptr->rms;
+        rms_t sum = ptr->sum;
+
+        const float ga = as[(unsigned int)(attack * 0.001f * (float)(TABSIZE-1))];
+        const float gr = as[(unsigned int)(release * 0.001f * (float)(TABSIZE-1))];
+        const float ef_a = ga * 0.25f;
+        const float ef_ai = 1.0f - ef_a;
+
+	float level = 0.0f;
+	float adjust = 0.0f;
+
+        for (sample_index = 0; sample_index < sample_count; sample_index++) {
+
+#ifdef DYN_CALC_FLOAT
+		sum += input[sample_index] * input[sample_index];
+		if (amp > env) {
+			env = env * ga + amp * (1.0f - ga);
+		} else {
+			env = env * gr + amp * (1.0f - gr);
+		}
+#else
+		sum += (rms_t)(input[sample_index] * F2S * input[sample_index] * F2S);
+		if (amp) {
+			if (amp > env) {
+				env = (double)env * ga + (double)amp * (1.0f - ga);
+			} else {
+				env = (double)env * gr + (double)amp * (1.0f - gr);
+			}
+		} else
+			env = 0;
+#endif
+
+		if (count++ % 4 == 3) {
+#ifdef DYN_CALC_FLOAT
+			amp = rms_env_process(rms, sum / 4);
+#else
+			if (sum)
+				amp = rms_env_process(rms, sum / 4);
+			else
+				amp = 0;
+#endif
+
+#ifdef DYN_CALC_FLOAT
+			if (isnan(amp))
+				amp = 0.0f;
+#endif
+			sum = 0;
+
+			/* set gain_out according to the difference between
+			   the envelope volume level (env) and the corresponding
+			   output level (from graph) */
+#ifdef DYN_CALC_FLOAT
+			level = 20 * log10f(2 * env);
+#else
+			level = 20 * log10f(2 * (double)env / (double)F2S);
+#endif
+			adjust = get_table_gain(mode, level + offsgain);
+			gain_out = db2lin(adjust);
+
+		}
+		gain = gain * ef_a + gain_out * ef_ai;
+		output[sample_index] += ptr->run_adding_gain * input[sample_index] * gain * mugain;
+        }
+        ptr->sum = sum;
+        ptr->amp = amp;
+        ptr->gain = gain;
+        ptr->gain_out = gain_out;
+        ptr->env = env;
+        ptr->count = count;
+
+	*(ptr->rmsenv) = LIMIT(level, -60.0f, 20.0f);
+	*(ptr->modgain) = LIMIT(adjust, -60.0f, 20.0f);
+}
+
+
+
+
+/* Throw away a Dynamics effect instance. */
+void 
+cleanup_Dynamics(LADSPA_Handle Instance) {
+
+	Dynamics * ptr = (Dynamics *)Instance;
+
+	free(ptr->rms);
+	free(ptr->as);
+	free(Instance);
+}
+
+
+
+LADSPA_Descriptor * mono_descriptor = NULL;
+
+
+
+/* __attribute__((constructor)) _init() is called automatically when the plugin library is first
+   loaded. */
+void 
+__attribute__((constructor)) _init() {
+	
+	char ** port_names;
+	LADSPA_PortDescriptor * port_descriptors;
+	LADSPA_PortRangeHint * port_range_hints;
+	
+	if ((mono_descriptor = 
+	     (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor))) == NULL)
+		exit(1);
+	
+	mono_descriptor->UniqueID = ID_MONO;
+	mono_descriptor->Label = strdup("tap_dynamics_m");
+	mono_descriptor->Properties = 0;
+	mono_descriptor->Name = strdup("TAP Dynamics (M)");
+	mono_descriptor->Maker = strdup("Tom Szilagyi");
+	mono_descriptor->Copyright = strdup("GPL");
+	mono_descriptor->PortCount = PORTCOUNT_MONO;
+
+	if ((port_descriptors =
+	     (LADSPA_PortDescriptor *)calloc(PORTCOUNT_MONO, sizeof(LADSPA_PortDescriptor))) == NULL)
+		exit(1);
+
+	mono_descriptor->PortDescriptors = (const LADSPA_PortDescriptor *)port_descriptors;
+	port_descriptors[ATTACK] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[RELEASE] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[OFFSGAIN] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[MUGAIN] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[MODE] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[RMSENV] = LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[MODGAIN] = LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[INPUT] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+
+	if ((port_names = 
+	     (char **)calloc(PORTCOUNT_MONO, sizeof(char *))) == NULL)
+		exit(1);
+
+	mono_descriptor->PortNames = (const char **)port_names;
+	port_names[ATTACK] = strdup("Attack [ms]");
+	port_names[RELEASE] = strdup("Release [ms]");
+	port_names[OFFSGAIN] = strdup("Offset Gain [dB]");
+	port_names[MUGAIN] = strdup("Makeup Gain [dB]");
+	port_names[MODE] = strdup("Function");
+	port_names[RMSENV] = strdup("Envelope Volume [dB]");
+	port_names[MODGAIN] = strdup("Gain Adjustment [dB]");
+	port_names[INPUT] = strdup("Input");
+	port_names[OUTPUT] = strdup("Output");
+
+	if ((port_range_hints = 
+	     ((LADSPA_PortRangeHint *)calloc(PORTCOUNT_MONO, sizeof(LADSPA_PortRangeHint)))) == NULL)
+		exit(1);
+
+	mono_descriptor->PortRangeHints = (const LADSPA_PortRangeHint *)port_range_hints;
+	port_range_hints[ATTACK].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_LOW);
+	port_range_hints[RELEASE].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_MIDDLE);
+	port_range_hints[OFFSGAIN].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[MUGAIN].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[RMSENV].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[MODGAIN].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[MODE].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_INTEGER |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[ATTACK].LowerBound = 4.0f;
+	port_range_hints[ATTACK].UpperBound = 500.0f;
+	port_range_hints[RELEASE].LowerBound = 4.0f;
+	port_range_hints[RELEASE].UpperBound = 1000.0f;
+	port_range_hints[OFFSGAIN].LowerBound = -20.0f;
+	port_range_hints[OFFSGAIN].UpperBound = 20.0f;
+	port_range_hints[MUGAIN].LowerBound = -20.0f;
+	port_range_hints[MUGAIN].UpperBound = 20.0f;
+	port_range_hints[RMSENV].LowerBound = -60.0f;
+	port_range_hints[RMSENV].UpperBound = 20.0f;
+	port_range_hints[MODGAIN].LowerBound = -60.0f;
+	port_range_hints[MODGAIN].UpperBound = 20.0f;
+	port_range_hints[MODE].LowerBound = 0;
+	port_range_hints[MODE].UpperBound = NUM_MODES - 0.9f;
+	port_range_hints[INPUT].HintDescriptor = 0;
+	port_range_hints[OUTPUT].HintDescriptor = 0;
+	mono_descriptor->instantiate = instantiate_Dynamics;
+	mono_descriptor->connect_port = connect_port_Dynamics;
+	mono_descriptor->activate = NULL;
+	mono_descriptor->run = run_Dynamics;
+	mono_descriptor->run_adding = run_adding_Dynamics;
+	mono_descriptor->set_run_adding_gain = set_run_adding_gain_Dynamics;
+	mono_descriptor->deactivate = NULL;
+	mono_descriptor->cleanup = cleanup_Dynamics;
+}
+
+
+void
+delete_descriptor(LADSPA_Descriptor * descriptor) {
+	unsigned long index;
+	if (descriptor) {
+		free((char *)descriptor->Label);
+		free((char *)descriptor->Name);
+		free((char *)descriptor->Maker);
+		free((char *)descriptor->Copyright);
+		free((LADSPA_PortDescriptor *)descriptor->PortDescriptors);
+		for (index = 0; index < descriptor->PortCount; index++)
+			free((char *)(descriptor->PortNames[index]));
+		free((char **)descriptor->PortNames);
+		free((LADSPA_PortRangeHint *)descriptor->PortRangeHints);
+		free(descriptor);
+	}
+}
+
+
+/* __attribute__((destructor)) _fini() is called automatically when the library is unloaded. */
+void
+__attribute__((destructor)) _fini() {
+	delete_descriptor(mono_descriptor);
+}
+
+
+/* Return a descriptor of the requested plugin type. */
+const LADSPA_Descriptor * 
+ladspa_descriptor(unsigned long Index) {
+
+	switch (Index) {
+	case 0:
+		return mono_descriptor;
+	default:
+		return NULL;
+	}
+}

=== added file '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_dynamics_st.c'
--- .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_dynamics_st.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_dynamics_st.c	2014-04-11 06:58:04 +0000
@@ -0,0 +1,877 @@
+/*                                                     -*- linux-c -*-
+    Copyright (C) 2004 Tom Szilagyi
+    
+    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.
+
+    $Id: tap_dynamics_st.c,v 1.2 2004/06/15 14:50:55 tszilagyi Exp $
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <math.h>
+
+#include <ladspa.h>
+#include "tap_utils.h"
+
+
+/* ***** VERY IMPORTANT! *****
+ *
+ * If you enable this, the plugin will use float arithmetics in DSP
+ * calculations.  This usually yields lower average CPU usage, but
+ * occasionaly may result in high CPU peaks which cause trouble to you
+ * and your JACK server.  The default is to use fixpoint arithmetics
+ * (with the following #define commented out).  But (depending on the
+ * processor on which you run the code) you may find floating point
+ * mode usable.
+ */
+/*#define DYN_CALC_FLOAT*/
+
+
+typedef signed int sample;
+
+/* coefficient for float to sample (signed int) conversion */
+/* this allows for about 60 dB headroom above 0dB, if 0 dB is equivalent to 1.0f */
+/* As 2^31 equals more than 180 dB, about 120 dB dynamics remains below 0 dB */
+#define F2S 2147483
+
+
+#ifdef DYN_CALC_FLOAT
+typedef LADSPA_Data dyn_t;
+typedef float rms_t;
+#else
+typedef sample dyn_t;
+typedef int64_t rms_t;
+#endif
+
+
+
+/* The Unique ID of the plugin: */
+
+#define ID_STEREO         2153
+
+/* The port numbers for the plugin: */
+
+#define ATTACK          0
+#define RELEASE         1
+#define OFFSGAIN        2
+#define MUGAIN          3
+#define RMSENV_L        4
+#define RMSENV_R        5
+#define MODGAIN_L       6
+#define MODGAIN_R       7
+#define STEREO          8
+#define MODE            9
+#define INPUT_L         10
+#define INPUT_R         11
+#define OUTPUT_L        12
+#define OUTPUT_R        13
+
+
+/* Total number of ports */
+
+#define PORTCOUNT_STEREO   14
+
+
+#define TABSIZE 256
+#define RMSSIZE 64
+
+
+typedef struct {
+        rms_t        buffer[RMSSIZE];
+        unsigned int pos;
+        rms_t        sum;
+} rms_env;
+
+
+/* max. number of breakpoints on in/out dB graph */
+#define MAX_POINTS 20
+
+typedef struct {
+	LADSPA_Data x;
+	LADSPA_Data y;
+} GRAPH_POINT;
+
+typedef struct {
+	unsigned long num_points;
+	GRAPH_POINT points[MAX_POINTS];
+} DYNAMICS_DATA;
+
+#include "tap_dynamics_presets.h"
+
+
+/* The structure used to hold port connection information and state */
+
+typedef struct {
+	LADSPA_Data * attack;
+	LADSPA_Data * release;
+	LADSPA_Data * offsgain;
+	LADSPA_Data * mugain;
+	LADSPA_Data * rmsenv_L;
+	LADSPA_Data * rmsenv_R;
+	LADSPA_Data * modgain_L;
+	LADSPA_Data * modgain_R;
+	LADSPA_Data * stereo;
+	LADSPA_Data * mode;
+	LADSPA_Data * input_L;
+	LADSPA_Data * output_L;
+	LADSPA_Data * input_R;
+	LADSPA_Data * output_R;
+	unsigned long sample_rate;
+
+	float * as;
+	unsigned long count;
+	dyn_t amp_L;
+	dyn_t amp_R;
+	dyn_t env_L;
+	dyn_t env_R;
+	float gain_L;
+	float gain_R;
+	float gain_out_L;
+	float gain_out_R;
+	rms_env * rms_L;
+	rms_env * rms_R;
+	rms_t sum_L;
+	rms_t sum_R;
+
+	DYNAMICS_DATA graph;
+
+	LADSPA_Data run_adding_gain;
+} Dynamics;
+
+
+
+/* RMS envelope stuff, grabbed without a second thought from Steve Harris's swh-plugins, util/rms.c */
+/* Adapted, though, to be able to use fixed-point arithmetics as well. */
+
+rms_env *
+rms_env_new(void) {
+
+        rms_env * new = (rms_env *)calloc(1, sizeof(rms_env));
+
+        return new;
+}
+
+void
+rms_env_reset(rms_env *r) {
+
+        unsigned int i;
+
+        for (i = 0; i < RMSSIZE; i++) {
+                r->buffer[i] = 0.0f;
+        }
+        r->pos = 0;
+        r->sum = 0.0f;
+}
+
+inline static
+dyn_t
+rms_env_process(rms_env *r, const rms_t x) {
+
+        r->sum -= r->buffer[r->pos];
+        r->sum += x;
+        r->buffer[r->pos] = x;
+        r->pos = (r->pos + 1) & (RMSSIZE - 1);
+
+#ifdef DYN_CALC_FLOAT
+        return sqrt(r->sum / (float)RMSSIZE);
+#else
+        return sqrt(r->sum / RMSSIZE);
+#endif
+}
+
+
+
+inline
+LADSPA_Data
+get_table_gain(int mode, LADSPA_Data level) {
+
+	LADSPA_Data x1 = -80.0f;
+	LADSPA_Data y1 = -80.0f;
+	LADSPA_Data x2 = 0.0f;
+	LADSPA_Data y2 = 0.0f;
+	unsigned int i = 0;
+
+	if (level <= -80.0f)
+		return get_table_gain(mode, -79.9f);
+
+	while (i < dyn_data[mode].num_points && dyn_data[mode].points[i].x < level) {
+		x1 = dyn_data[mode].points[i].x;
+		y1 = dyn_data[mode].points[i].y;
+		i++;
+	}
+	if (i < dyn_data[mode].num_points) {
+		x2 = dyn_data[mode].points[i].x;
+		y2 = dyn_data[mode].points[i].y;
+	} else
+		return 0.0f;
+
+	return y1 + ((level - x1) * (y2 - y1) / (x2 - x1)) - level;
+}
+
+
+/* Construct a new plugin instance. */
+LADSPA_Handle 
+instantiate_Dynamics(const LADSPA_Descriptor * Descriptor, unsigned long sample_rate) {
+	
+	LADSPA_Handle * ptr;
+
+	float * as = NULL;
+	unsigned int count = 0;
+	dyn_t amp_L = 0.0f;
+	dyn_t amp_R = 0.0f;
+	dyn_t env_L = 0.0f;
+	dyn_t env_R = 0.0f;
+	float gain_L = 0.0f;
+	float gain_R = 0.0f;
+	float gain_out_L = 0.0f;
+	float gain_out_R = 0.0f;
+	rms_env * rms_L = NULL;
+	rms_env * rms_R = NULL;
+	rms_t sum_L = 0.0f;
+	rms_t sum_R = 0.0f;
+	int i;
+	
+	if ((ptr = malloc(sizeof(Dynamics))) == NULL)
+		return NULL;
+
+	((Dynamics *)ptr)->sample_rate = sample_rate;
+	((Dynamics *)ptr)->run_adding_gain = 1.0;
+
+        if ((rms_L = rms_env_new()) == NULL)
+		return NULL;
+        if ((rms_R = rms_env_new()) == NULL)
+		return NULL;
+
+        if ((as = malloc(TABSIZE * sizeof(float))) == NULL)
+		return NULL;
+
+        as[0] = 1.0f;
+        for (i = 1; i < TABSIZE; i++) {
+		as[i] = expf(-1.0f / (sample_rate * (float)i / (float)TABSIZE));
+        }
+
+        ((Dynamics *)ptr)->as = as;
+        ((Dynamics *)ptr)->count = count;
+        ((Dynamics *)ptr)->amp_L = amp_L;
+        ((Dynamics *)ptr)->amp_R = amp_R;
+        ((Dynamics *)ptr)->env_L = env_L;
+        ((Dynamics *)ptr)->env_R = env_R;
+        ((Dynamics *)ptr)->gain_L = gain_L;
+        ((Dynamics *)ptr)->gain_R = gain_R;
+        ((Dynamics *)ptr)->gain_out_L = gain_out_L;
+        ((Dynamics *)ptr)->gain_out_R = gain_out_R;
+        ((Dynamics *)ptr)->rms_L = rms_L;
+        ((Dynamics *)ptr)->rms_R = rms_R;
+        ((Dynamics *)ptr)->sum_L = sum_L;
+        ((Dynamics *)ptr)->sum_R = sum_R;
+
+	return ptr;
+}
+
+
+
+/* Connect a port to a data location. */
+void 
+connect_port_Dynamics(LADSPA_Handle Instance,
+		     unsigned long Port,
+		     LADSPA_Data * DataLocation) {
+	
+	Dynamics * ptr = (Dynamics *)Instance;
+
+	switch (Port) {
+	case ATTACK:
+		ptr->attack = DataLocation;
+		break;
+	case RELEASE:
+		ptr->release = DataLocation;
+		break;
+	case OFFSGAIN:
+		ptr->offsgain = DataLocation;
+		break;
+	case MUGAIN:
+		ptr->mugain = DataLocation;
+		break;
+	case RMSENV_L:
+		ptr->rmsenv_L = DataLocation;
+		*(ptr->rmsenv_L) = -60.0f;
+		break;
+	case RMSENV_R:
+		ptr->rmsenv_R = DataLocation;
+		*(ptr->rmsenv_R) = -60.0f;
+		break;
+	case MODGAIN_L:
+		ptr->modgain_L = DataLocation;
+		*(ptr->modgain_L) = 0.0f;
+		break;
+	case MODGAIN_R:
+		ptr->modgain_R = DataLocation;
+		*(ptr->modgain_R) = 0.0f;
+		break;
+	case STEREO:
+		ptr->stereo = DataLocation;
+		break;
+	case MODE:
+		ptr->mode = DataLocation;
+		break;
+	case INPUT_L:
+		ptr->input_L = DataLocation;
+		break;
+	case OUTPUT_L:
+		ptr->output_L = DataLocation;
+		break;
+	case INPUT_R:
+		ptr->input_R = DataLocation;
+		break;
+	case OUTPUT_R:
+		ptr->output_R = DataLocation;
+		break;
+	}
+}
+
+
+
+void 
+run_Dynamics(LADSPA_Handle Instance,
+	     unsigned long sample_count) {
+
+	Dynamics * ptr = (Dynamics *)Instance;
+	LADSPA_Data * input_L = ptr->input_L;
+	LADSPA_Data * output_L = ptr->output_L;
+	LADSPA_Data * input_R = ptr->input_R;
+	LADSPA_Data * output_R = ptr->output_R;
+        const float attack = LIMIT(*(ptr->attack), 4.0f, 500.0f);
+        const float release = LIMIT(*(ptr->release), 4.0f, 1000.0f);
+        const float offsgain = LIMIT(*(ptr->offsgain), -20.0f, 20.0f);
+        const float mugain = db2lin(LIMIT(*(ptr->mugain), -20.0f, 20.0f));
+	const int stereo = LIMIT(*(ptr->stereo), 0, 2);
+	const int mode = LIMIT(*(ptr->mode), 0, NUM_MODES-1);
+	unsigned long sample_index;
+
+        dyn_t amp_L = ptr->amp_L;
+        dyn_t amp_R = ptr->amp_R;
+        dyn_t env_L = ptr->env_L;
+        dyn_t env_R = ptr->env_R;
+        float * as = ptr->as;
+        unsigned int count = ptr->count;
+        float gain_L = ptr->gain_L;
+        float gain_R = ptr->gain_R;
+        float gain_out_L = ptr->gain_out_L;
+        float gain_out_R = ptr->gain_out_R;
+        rms_env * rms_L = ptr->rms_L;
+        rms_env * rms_R = ptr->rms_R;
+        rms_t sum_L = ptr->sum_L;
+        rms_t sum_R = ptr->sum_R;
+
+        const float ga = as[(unsigned int)(attack * 0.001f * (LADSPA_Data)(TABSIZE-1))];
+        const float gr = as[(unsigned int)(release * 0.001f * (LADSPA_Data)(TABSIZE-1))];
+        const float ef_a = ga * 0.25f;
+        const float ef_ai = 1.0f - ef_a;
+
+	float level_L = 0.0f;
+	float level_R = 0.0f;
+	float adjust_L = 0.0f;
+	float adjust_R = 0.0f;
+
+        for (sample_index = 0; sample_index < sample_count; sample_index++) {
+
+#ifdef DYN_CALC_FLOAT
+                sum_L += input_L[sample_index] * input_L[sample_index];
+                sum_R += input_R[sample_index] * input_R[sample_index];
+
+                if (amp_L > env_L) {
+                        env_L = env_L * ga + amp_L * (1.0f - ga);
+                } else {
+                        env_L = env_L * gr + amp_L * (1.0f - gr);
+                }
+                if (amp_R > env_R) {
+                        env_R = env_R * ga + amp_R * (1.0f - ga);
+                } else {
+                        env_R = env_R * gr + amp_R * (1.0f - gr);
+                }
+#else
+		sum_L += (rms_t)(input_L[sample_index] * F2S) * (rms_t)(input_L[sample_index] * F2S);
+		sum_R += (rms_t)(input_R[sample_index] * F2S) * (rms_t)(input_R[sample_index] * F2S);
+
+		if (amp_L) {
+			if (amp_L > env_L) {
+				env_L = (double)env_L * ga + (double)amp_L * (1.0f - ga);
+			} else {
+				env_L = (double)env_L * gr + (double)amp_L * (1.0f - gr);
+			}
+		} else
+			env_L = 0;
+
+		if (amp_R) {
+			if (amp_R > env_R) {
+				env_R = (double)env_R * ga + (double)amp_R * (1.0f - ga);
+			} else {
+				env_R = (double)env_R * gr + (double)amp_R * (1.0f - gr);
+			}
+		} else
+			env_R = 0;
+#endif
+
+		if (count++ % 4 == 3) {
+#ifdef DYN_CALC_FLOAT
+			amp_L = rms_env_process(rms_L, sum_L * 0.25f);
+			amp_R = rms_env_process(rms_R, sum_R * 0.25f);
+#else
+			if (sum_L)
+				amp_L = rms_env_process(rms_L, sum_L * 0.25f);
+			else
+				amp_L = 0;
+
+			if (sum_R)
+				amp_R = rms_env_process(rms_R, sum_R * 0.25f);
+			else
+				amp_R = 0;
+#endif
+
+
+#ifdef DYN_CALC_FLOAT
+			if (isnan(amp_L))
+				amp_L = 0.0f;
+			if (isnan(amp_R))
+				amp_R = 0.0f;
+#endif
+			sum_L = sum_R = 0;
+
+			/* set gain_out according to the difference between
+			   the envelope volume level (env) and the corresponding
+			   output level (from graph) */
+#ifdef DYN_CALC_FLOAT
+			level_L = 20 * log10f(2 * env_L);
+			level_R = 20 * log10f(2 * env_R);
+#else
+                        level_L = 20 * log10f(2 * (double)env_L / (double)F2S);
+                        level_R = 20 * log10f(2 * (double)env_R / (double)F2S);
+#endif
+			adjust_L = get_table_gain(mode, level_L + offsgain);
+			adjust_R = get_table_gain(mode, level_R + offsgain);
+
+			/* set gains according to stereo mode */
+			switch (stereo) {
+			case 0:
+				gain_out_L = db2lin(adjust_L);
+				gain_out_R = db2lin(adjust_R);
+				break;
+			case 1:
+				adjust_L = adjust_R = (adjust_L + adjust_R) / 2.0f;
+				gain_out_L = gain_out_R = db2lin(adjust_L);
+				break;
+			case 2:
+				adjust_L = adjust_R = (adjust_L > adjust_R) ? adjust_L : adjust_R;
+				gain_out_L = gain_out_R = db2lin(adjust_L);
+				break;
+			}
+
+		}
+		gain_L = gain_L * ef_a + gain_out_L * ef_ai;
+		gain_R = gain_R * ef_a + gain_out_R * ef_ai;
+		output_L[sample_index] = input_L[sample_index] * gain_L * mugain;
+		output_R[sample_index] = input_R[sample_index] * gain_R * mugain;
+        }
+        ptr->sum_L = sum_L;
+        ptr->sum_R = sum_R;
+        ptr->amp_L = amp_L;
+        ptr->amp_R = amp_R;
+        ptr->gain_L = gain_L;
+        ptr->gain_R = gain_R;
+        ptr->gain_out_L = gain_out_L;
+        ptr->gain_out_R = gain_out_R;
+        ptr->env_L = env_L;
+        ptr->env_R = env_R;
+        ptr->count = count;
+
+	*(ptr->rmsenv_L) = LIMIT(level_L, -60.0f, 20.0f);
+	*(ptr->rmsenv_R) = LIMIT(level_R, -60.0f, 20.0f);
+	*(ptr->modgain_L) = LIMIT(adjust_L, -60.0f, 20.0f);
+	*(ptr->modgain_R) = LIMIT(adjust_R, -60.0f, 20.0f);
+}
+
+
+
+void
+set_run_adding_gain_Dynamics(LADSPA_Handle Instance, LADSPA_Data gain) {
+
+	Dynamics * ptr = (Dynamics *)Instance;
+
+	ptr->run_adding_gain = gain;
+}
+
+
+
+void 
+run_adding_Dynamics(LADSPA_Handle Instance,
+		    unsigned long sample_count) {
+
+	Dynamics * ptr = (Dynamics *)Instance;
+	LADSPA_Data * input_L = ptr->input_L;
+	LADSPA_Data * output_L = ptr->output_L;
+	LADSPA_Data * input_R = ptr->input_R;
+	LADSPA_Data * output_R = ptr->output_R;
+        const float attack = LIMIT(*(ptr->attack), 4.0f, 500.0f);
+        const float release = LIMIT(*(ptr->release), 4.0f, 1000.0f);
+        const float offsgain = LIMIT(*(ptr->offsgain), -20.0f, 20.0f);
+        const float mugain = db2lin(LIMIT(*(ptr->mugain), -20.0f, 20.0f));
+	const int stereo = LIMIT(*(ptr->stereo), 0, 2);
+	const int mode = LIMIT(*(ptr->mode), 0, NUM_MODES-1);
+	unsigned long sample_index;
+
+        dyn_t amp_L = ptr->amp_L;
+        dyn_t amp_R = ptr->amp_R;
+        dyn_t env_L = ptr->env_L;
+        dyn_t env_R = ptr->env_R;
+        float * as = ptr->as;
+        unsigned int count = ptr->count;
+        float gain_L = ptr->gain_L;
+        float gain_R = ptr->gain_R;
+        float gain_out_L = ptr->gain_out_L;
+        float gain_out_R = ptr->gain_out_R;
+        rms_env * rms_L = ptr->rms_L;
+        rms_env * rms_R = ptr->rms_R;
+        rms_t sum_L = ptr->sum_L;
+        rms_t sum_R = ptr->sum_R;
+
+        const float ga = as[(unsigned int)(attack * 0.001f * (LADSPA_Data)(TABSIZE-1))];
+        const float gr = as[(unsigned int)(release * 0.001f * (LADSPA_Data)(TABSIZE-1))];
+        const float ef_a = ga * 0.25f;
+        const float ef_ai = 1.0f - ef_a;
+
+	float level_L = 0.0f;
+	float level_R = 0.0f;
+	float adjust_L = 0.0f;
+	float adjust_R = 0.0f;
+
+        for (sample_index = 0; sample_index < sample_count; sample_index++) {
+
+#ifdef DYN_CALC_FLOAT
+                sum_L += input_L[sample_index] * input_L[sample_index];
+                sum_R += input_R[sample_index] * input_R[sample_index];
+
+                if (amp_L > env_L) {
+                        env_L = env_L * ga + amp_L * (1.0f - ga);
+                } else {
+                        env_L = env_L * gr + amp_L * (1.0f - gr);
+                }
+                if (amp_R > env_R) {
+                        env_R = env_R * ga + amp_R * (1.0f - ga);
+                } else {
+                        env_R = env_R * gr + amp_R * (1.0f - gr);
+                }
+#else
+		sum_L += (rms_t)(input_L[sample_index] * F2S) * (rms_t)(input_L[sample_index] * F2S);
+		sum_R += (rms_t)(input_R[sample_index] * F2S) * (rms_t)(input_R[sample_index] * F2S);
+
+		if (amp_L) {
+			if (amp_L > env_L) {
+				env_L = (double)env_L * ga + (double)amp_L * (1.0f - ga);
+			} else {
+				env_L = (double)env_L * gr + (double)amp_L * (1.0f - gr);
+			}
+		} else
+			env_L = 0;
+
+		if (amp_R) {
+			if (amp_R > env_R) {
+				env_R = (double)env_R * ga + (double)amp_R * (1.0f - ga);
+			} else {
+				env_R = (double)env_R * gr + (double)amp_R * (1.0f - gr);
+			}
+		} else
+			env_R = 0;
+#endif
+
+		if (count++ % 4 == 3) {
+#ifdef DYN_CALC_FLOAT
+			amp_L = rms_env_process(rms_L, sum_L * 0.25f);
+			amp_R = rms_env_process(rms_R, sum_R * 0.25f);
+#else
+			if (sum_L)
+				amp_L = rms_env_process(rms_L, sum_L * 0.25f);
+			else
+				amp_L = 0;
+
+			if (sum_R)
+				amp_R = rms_env_process(rms_R, sum_R * 0.25f);
+			else
+				amp_R = 0;
+#endif
+
+
+#ifdef DYN_CALC_FLOAT
+			if (isnan(amp_L))
+				amp_L = 0.0f;
+			if (isnan(amp_R))
+				amp_R = 0.0f;
+#endif
+			sum_L = sum_R = 0;
+
+			/* set gain_out according to the difference between
+			   the envelope volume level (env) and the corresponding
+			   output level (from graph) */
+#ifdef DYN_CALC_FLOAT
+			level_L = 20 * log10f(2 * env_L);
+			level_R = 20 * log10f(2 * env_R);
+#else
+                        level_L = 20 * log10f(2 * (double)env_L / (double)F2S);
+                        level_R = 20 * log10f(2 * (double)env_R / (double)F2S);
+#endif
+			adjust_L = get_table_gain(mode, level_L + offsgain);
+			adjust_R = get_table_gain(mode, level_R + offsgain);
+
+			/* set gains according to stereo mode */
+			switch (stereo) {
+			case 0:
+				gain_out_L = db2lin(adjust_L);
+				gain_out_R = db2lin(adjust_R);
+				break;
+			case 1:
+				adjust_L = adjust_R = (adjust_L + adjust_R) / 2.0f;
+				gain_out_L = gain_out_R = db2lin(adjust_L);
+				break;
+			case 2:
+				adjust_L = adjust_R = (adjust_L > adjust_R) ? adjust_L : adjust_R;
+				gain_out_L = gain_out_R = db2lin(adjust_L);
+				break;
+			}
+
+		}
+		gain_L = gain_L * ef_a + gain_out_L * ef_ai;
+		gain_R = gain_R * ef_a + gain_out_R * ef_ai;
+		output_L[sample_index] += ptr->run_adding_gain * input_L[sample_index] * gain_L * mugain;
+		output_R[sample_index] += ptr->run_adding_gain * input_R[sample_index] * gain_R * mugain;
+        }
+        ptr->sum_L = sum_L;
+        ptr->sum_R = sum_R;
+        ptr->amp_L = amp_L;
+        ptr->amp_R = amp_R;
+        ptr->gain_L = gain_L;
+        ptr->gain_R = gain_R;
+        ptr->gain_out_L = gain_out_L;
+        ptr->gain_out_R = gain_out_R;
+        ptr->env_L = env_L;
+        ptr->env_R = env_R;
+        ptr->count = count;
+
+	*(ptr->rmsenv_L) = LIMIT(level_L, -60.0f, 20.0f);
+	*(ptr->rmsenv_R) = LIMIT(level_R, -60.0f, 20.0f);
+	*(ptr->modgain_L) = LIMIT(adjust_L, -60.0f, 20.0f);
+	*(ptr->modgain_R) = LIMIT(adjust_R, -60.0f, 20.0f);
+}
+
+
+
+
+/* Throw away a Dynamics effect instance. */
+void 
+cleanup_Dynamics(LADSPA_Handle Instance) {
+
+	Dynamics * ptr = (Dynamics *)Instance;
+
+	free(ptr->rms_L);
+	free(ptr->rms_R);
+	free(ptr->as);
+	free(Instance);
+}
+
+
+
+LADSPA_Descriptor * stereo_descriptor = NULL;
+
+
+
+/* __attribute__((constructor)) _init() is called automatically when the plugin library is first
+   loaded. */
+void 
+__attribute__((constructor)) _init() {
+	
+	char ** port_names;
+	LADSPA_PortDescriptor * port_descriptors;
+	LADSPA_PortRangeHint * port_range_hints;
+	
+	if ((stereo_descriptor = 
+	     (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor))) == NULL)
+		exit(1);
+	
+	stereo_descriptor->UniqueID = ID_STEREO;
+	stereo_descriptor->Label = strdup("tap_dynamics_st");
+	stereo_descriptor->Properties = 0;
+	stereo_descriptor->Name = strdup("TAP Dynamics (St)");
+	stereo_descriptor->Maker = strdup("Tom Szilagyi");
+	stereo_descriptor->Copyright = strdup("GPL");
+	stereo_descriptor->PortCount = PORTCOUNT_STEREO;
+
+	if ((port_descriptors =
+	     (LADSPA_PortDescriptor *)calloc(PORTCOUNT_STEREO, sizeof(LADSPA_PortDescriptor))) == NULL)
+		exit(1);
+
+	stereo_descriptor->PortDescriptors = (const LADSPA_PortDescriptor *)port_descriptors;
+	port_descriptors[ATTACK] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[RELEASE] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[OFFSGAIN] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[MUGAIN] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[STEREO] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[MODE] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[RMSENV_L] = LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[RMSENV_R] = LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[MODGAIN_L] = LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[MODGAIN_R] = LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[INPUT_L] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[INPUT_R] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT_L] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT_R] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+
+	if ((port_names = 
+	     (char **)calloc(PORTCOUNT_STEREO, sizeof(char *))) == NULL)
+		exit(1);
+
+	stereo_descriptor->PortNames = (const char **)port_names;
+	port_names[ATTACK] = strdup("Attack [ms]");
+	port_names[RELEASE] = strdup("Release [ms]");
+	port_names[OFFSGAIN] = strdup("Offset Gain [dB]");
+	port_names[MUGAIN] = strdup("Makeup Gain [dB]");
+	port_names[STEREO] = strdup("Stereo Mode");
+	port_names[MODE] = strdup("Function");
+	port_names[RMSENV_L] = strdup("Envelope Volume (L) [dB]");
+	port_names[RMSENV_R] = strdup("Envelope Volume (R) [dB]");
+	port_names[MODGAIN_L] = strdup("Gain Adjustment (L) [dB]");
+	port_names[MODGAIN_R] = strdup("Gain Adjustment (R) [dB]");
+	port_names[INPUT_L] = strdup("Input Left");
+	port_names[INPUT_R] = strdup("Input Right");
+	port_names[OUTPUT_L] = strdup("Output Left");
+	port_names[OUTPUT_R] = strdup("Output Right");
+
+	if ((port_range_hints = 
+	     ((LADSPA_PortRangeHint *)calloc(PORTCOUNT_STEREO, sizeof(LADSPA_PortRangeHint)))) == NULL)
+		exit(1);
+
+	stereo_descriptor->PortRangeHints = (const LADSPA_PortRangeHint *)port_range_hints;
+	port_range_hints[ATTACK].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_LOW);
+	port_range_hints[RELEASE].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_MIDDLE);
+	port_range_hints[OFFSGAIN].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[MUGAIN].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[RMSENV_L].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[RMSENV_R].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[MODGAIN_L].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[MODGAIN_R].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[STEREO].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_INTEGER |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[MODE].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_INTEGER |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[ATTACK].LowerBound = 4.0f;
+	port_range_hints[ATTACK].UpperBound = 500.0f;
+	port_range_hints[RELEASE].LowerBound = 4.0f;
+	port_range_hints[RELEASE].UpperBound = 1000.0f;
+	port_range_hints[OFFSGAIN].LowerBound = -20.0f;
+	port_range_hints[OFFSGAIN].UpperBound = 20.0f;
+	port_range_hints[MUGAIN].LowerBound = -20.0f;
+	port_range_hints[MUGAIN].UpperBound = 20.0f;
+	port_range_hints[RMSENV_L].LowerBound = -60.0f;
+	port_range_hints[RMSENV_L].UpperBound = 20.0f;
+	port_range_hints[RMSENV_R].LowerBound = -60.0f;
+	port_range_hints[RMSENV_R].UpperBound = 20.0f;
+	port_range_hints[MODGAIN_L].LowerBound = -60.0f;
+	port_range_hints[MODGAIN_L].UpperBound = 20.0f;
+	port_range_hints[MODGAIN_R].LowerBound = -60.0f;
+	port_range_hints[MODGAIN_R].UpperBound = 20.0f;
+	port_range_hints[STEREO].LowerBound = 0;
+	port_range_hints[STEREO].UpperBound = 2.1f;
+	port_range_hints[MODE].LowerBound = 0;
+	port_range_hints[MODE].UpperBound = NUM_MODES - 0.9f;
+	port_range_hints[INPUT_L].HintDescriptor = 0;
+	port_range_hints[INPUT_R].HintDescriptor = 0;
+	port_range_hints[OUTPUT_L].HintDescriptor = 0;
+	port_range_hints[OUTPUT_R].HintDescriptor = 0;
+	stereo_descriptor->instantiate = instantiate_Dynamics;
+	stereo_descriptor->connect_port = connect_port_Dynamics;
+	stereo_descriptor->activate = NULL;
+	stereo_descriptor->run = run_Dynamics;
+	stereo_descriptor->run_adding = run_adding_Dynamics;
+	stereo_descriptor->set_run_adding_gain = set_run_adding_gain_Dynamics;
+	stereo_descriptor->deactivate = NULL;
+	stereo_descriptor->cleanup = cleanup_Dynamics;
+}
+
+
+void
+delete_descriptor(LADSPA_Descriptor * descriptor) {
+	unsigned long index;
+	if (descriptor) {
+		free((char *)descriptor->Label);
+		free((char *)descriptor->Name);
+		free((char *)descriptor->Maker);
+		free((char *)descriptor->Copyright);
+		free((LADSPA_PortDescriptor *)descriptor->PortDescriptors);
+		for (index = 0; index < descriptor->PortCount; index++)
+			free((char *)(descriptor->PortNames[index]));
+		free((char **)descriptor->PortNames);
+		free((LADSPA_PortRangeHint *)descriptor->PortRangeHints);
+		free(descriptor);
+	}
+}
+
+
+/* __attribute__((destructor)) _fini() is called automatically when the library is unloaded. */
+void
+__attribute__((destructor)) _fini() {
+	delete_descriptor(stereo_descriptor);
+}
+
+
+/* Return a descriptor of the requested plugin type. */
+const LADSPA_Descriptor * 
+ladspa_descriptor(unsigned long Index) {
+
+	switch (Index) {
+	case 0:
+		return stereo_descriptor;
+	default:
+		return NULL;
+	}
+}

=== added file '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_echo.c'
--- .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_echo.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_echo.c	2014-04-11 06:58:04 +0000
@@ -0,0 +1,629 @@
+/*                                                     -*- linux-c -*-
+    Copyright (C) 2004 Tom Szilagyi
+    
+    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.
+
+    $Id: tap_echo.c,v 1.7 2004/12/06 09:32:41 tszilagyi Exp $
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include <ladspa.h>
+#include "tap_utils.h"
+
+/* The Unique ID of the plugin: */
+
+#define ID_STEREO       2143
+
+/* The port numbers for the plugin: */
+
+#define DELAYTIME_L 0
+#define FEEDBACK_L  1
+#define DELAYTIME_R 2
+#define FEEDBACK_R  3
+#define STRENGTH_L  4
+#define STRENGTH_R  5
+#define DRYLEVEL    6
+#define MODE        7
+#define HAAS        8
+#define REV_OUTCH   9
+
+#define INPUT_L     10
+#define OUTPUT_L    11
+#define INPUT_R     12
+#define OUTPUT_R    13
+
+/* Total number of ports */
+
+#define PORTCOUNT_STEREO 14
+
+
+/* Maximum delay (ms) */
+
+#define MAX_DELAY        2000
+
+
+/* The structure used to hold port connection information and state */
+
+typedef struct {
+	LADSPA_Data * delaytime_L;
+	LADSPA_Data * delaytime_R;
+	LADSPA_Data * feedback_L;
+	LADSPA_Data * feedback_R;
+	LADSPA_Data * strength_L;
+	LADSPA_Data * strength_R;
+	LADSPA_Data * drylevel;
+	LADSPA_Data * mode;
+	LADSPA_Data * haas;
+	LADSPA_Data * rev_outch;
+
+	LADSPA_Data * input_L;
+	LADSPA_Data * output_L;
+	LADSPA_Data * input_R;
+	LADSPA_Data * output_R;
+
+	unsigned long sample_rate;
+	LADSPA_Data mpx_out_L;
+	LADSPA_Data mpx_out_R;
+
+	LADSPA_Data * ringbuffer_L;
+	LADSPA_Data * ringbuffer_R;
+	unsigned long * buffer_pos_L;
+	unsigned long * buffer_pos_R;
+
+	LADSPA_Data run_adding_gain;
+} Echo;
+
+
+
+
+/* Construct a new plugin instance. */
+LADSPA_Handle 
+instantiate_Echo(const LADSPA_Descriptor * Descriptor,
+		 unsigned long             SampleRate) {
+	
+	LADSPA_Handle * ptr;
+	
+	if ((ptr = malloc(sizeof(Echo))) != NULL) {
+		((Echo *)ptr)->sample_rate = SampleRate;
+		((Echo *)ptr)->run_adding_gain = 1.0f;
+
+		/* allocate memory for ringbuffers and related dynamic vars */
+		if ((((Echo *)ptr)->ringbuffer_L = 
+		     calloc(MAX_DELAY * ((Echo *)ptr)->sample_rate / 1000,
+			    sizeof(LADSPA_Data))) == NULL)
+			exit(1);
+		if ((((Echo *)ptr)->ringbuffer_R = 
+		     calloc(MAX_DELAY * ((Echo *)ptr)->sample_rate / 1000,
+			    sizeof(LADSPA_Data))) == NULL)
+			exit(1);
+		if ((((Echo *)ptr)->buffer_pos_L = calloc(1, sizeof(unsigned long))) == NULL)
+			exit(1);
+		if ((((Echo *)ptr)->buffer_pos_R = calloc(1, sizeof(unsigned long))) == NULL)
+			exit(1);
+		
+		*(((Echo *)ptr)->buffer_pos_L) = 0;
+		*(((Echo *)ptr)->buffer_pos_R) = 0;
+		
+		return ptr;
+	}
+	
+	return NULL;
+}
+
+
+/* activate a plugin instance */
+void
+activate_Echo(LADSPA_Handle Instance) {
+
+	Echo * ptr = (Echo *)Instance;
+	unsigned int i;
+	
+	ptr->mpx_out_L = 0;
+	ptr->mpx_out_R = 0;
+	
+	*(ptr->buffer_pos_L) = 0;
+	*(ptr->buffer_pos_R) = 0;
+
+	for (i = 0; i < MAX_DELAY * ptr->sample_rate / 1000; i++) {
+		ptr->ringbuffer_L[i] = 0.0f;
+		ptr->ringbuffer_R[i] = 0.0f;
+	}
+}
+
+
+/* Connect a port to a data location. */
+void 
+connect_port_Echo(LADSPA_Handle Instance,
+		   unsigned long Port,
+		   LADSPA_Data * DataLocation) {
+	
+	Echo * ptr;
+	
+	ptr = (Echo *)Instance;
+	switch (Port) {
+	case DELAYTIME_L:
+		ptr->delaytime_L = DataLocation;
+		break;
+	case DELAYTIME_R:
+		ptr->delaytime_R = DataLocation;
+		break;
+	case FEEDBACK_L:
+		ptr->feedback_L = DataLocation;
+		break;
+	case FEEDBACK_R:
+		ptr->feedback_R = DataLocation;
+		break;
+	case STRENGTH_L:
+		ptr->strength_L = DataLocation;
+		break;
+	case STRENGTH_R:
+		ptr->strength_R = DataLocation;
+		break;
+	case MODE:
+		ptr->mode = DataLocation;
+		break;
+	case HAAS:
+		ptr->haas = DataLocation;
+		break;
+	case REV_OUTCH:
+		ptr->rev_outch = DataLocation;
+		break;
+	case DRYLEVEL:
+		ptr->drylevel = DataLocation;
+		break;
+	case INPUT_L:
+		ptr->input_L = DataLocation;
+		break;
+	case OUTPUT_L:
+		ptr->output_L = DataLocation;
+		break;
+	case INPUT_R:
+		ptr->input_R = DataLocation;
+		break;
+	case OUTPUT_R:
+		ptr->output_R = DataLocation;
+		break;
+	}
+}
+
+
+#define EPS 0.00000001f
+
+static inline float
+M(float x) {
+
+        if ((x > EPS) || (x < -EPS))
+                return x;
+        else
+                return 0.0f;
+}
+
+void 
+run_Echo(LADSPA_Handle Instance,
+	 unsigned long SampleCount) {
+	
+	Echo * ptr;
+	unsigned long sample_index;
+
+	LADSPA_Data delaytime_L;
+	LADSPA_Data delaytime_R;
+	LADSPA_Data feedback_L;
+	LADSPA_Data feedback_R;
+	LADSPA_Data strength_L;
+	LADSPA_Data strength_R;
+	LADSPA_Data drylevel;
+	LADSPA_Data mode;
+	LADSPA_Data haas;
+	LADSPA_Data rev_outch;
+
+	LADSPA_Data * input_L;
+	LADSPA_Data * output_L;
+	LADSPA_Data * input_R;
+	LADSPA_Data * output_R;
+
+	unsigned long sample_rate;
+	unsigned long buflen_L;
+	unsigned long buflen_R;
+
+	LADSPA_Data out_L = 0;
+	LADSPA_Data out_R = 0;
+	LADSPA_Data in_L = 0;
+	LADSPA_Data in_R = 0;
+
+	ptr = (Echo *)Instance;
+
+	delaytime_L = LIMIT(*(ptr->delaytime_L),0.0f,2000.0f);
+	delaytime_R = LIMIT(*(ptr->delaytime_R),0.0f,2000.0f);
+	feedback_L = LIMIT(*(ptr->feedback_L) / 100.0, 0.0f, 100.0f);
+	feedback_R = LIMIT(*(ptr->feedback_R) / 100.0, 0.0f, 100.0f);
+        strength_L = db2lin(LIMIT(*(ptr->strength_L),-70.0f,10.0f));
+	strength_R = db2lin(LIMIT(*(ptr->strength_R),-70.0f,10.0f));
+	drylevel = db2lin(LIMIT(*(ptr->drylevel),-70.0f,10.0f));
+	mode = LIMIT(*(ptr->mode),-2.0f,2.0f);
+	haas = LIMIT(*(ptr->haas),-2.0f,2.0f);
+	rev_outch = LIMIT(*(ptr->rev_outch),-2.0f,2.0f);
+
+      	input_L = ptr->input_L;
+	output_L = ptr->output_L;
+      	input_R = ptr->input_R;
+	output_R = ptr->output_R;
+
+	sample_rate = ptr->sample_rate;
+	buflen_L = delaytime_L * sample_rate / 1000;
+	buflen_R = delaytime_R * sample_rate / 1000;
+
+
+	for (sample_index = 0; sample_index < SampleCount; sample_index++) {
+		
+		in_L = *(input_L++);
+		in_R = *(input_R++);
+
+		out_L = in_L * drylevel + ptr->mpx_out_L * strength_L;
+		out_R = in_R * drylevel + ptr->mpx_out_R * strength_R;
+
+		if (haas > 0.0f)
+			in_R = 0.0f;
+
+		if (mode <= 0.0f) {
+			ptr->mpx_out_L = 
+				M(push_buffer(in_L + ptr->mpx_out_L * feedback_L,
+					      ptr->ringbuffer_L, buflen_L, ptr->buffer_pos_L));
+			ptr->mpx_out_R =
+				M(push_buffer(in_R + ptr->mpx_out_R * feedback_R,
+					      ptr->ringbuffer_R, buflen_R, ptr->buffer_pos_R));
+		} else {
+			ptr->mpx_out_R =
+				M(push_buffer(in_L + ptr->mpx_out_L * feedback_L,
+					      ptr->ringbuffer_L, buflen_L, ptr->buffer_pos_L));
+			ptr->mpx_out_L =
+				M(push_buffer(in_R + ptr->mpx_out_R * feedback_R,
+					      ptr->ringbuffer_R, buflen_R, ptr->buffer_pos_R));
+		}
+
+		if (rev_outch <= 0.0f) {
+			*(output_L++) = out_L;
+			*(output_R++) = out_R;
+		} else {
+			*(output_L++) = out_R;
+			*(output_R++) = out_L;
+		}
+	}
+}
+
+
+
+
+
+void
+set_run_adding_gain(LADSPA_Handle Instance, LADSPA_Data gain){
+
+	Echo * ptr;
+
+	ptr = (Echo *)Instance;
+
+	ptr->run_adding_gain = gain;
+}
+
+
+void 
+run_adding_gain_Echo(LADSPA_Handle Instance,
+	 unsigned long SampleCount) {
+	
+	Echo * ptr;
+	unsigned long sample_index;
+
+	LADSPA_Data delaytime_L;
+	LADSPA_Data delaytime_R;
+	LADSPA_Data feedback_L;
+	LADSPA_Data feedback_R;
+	LADSPA_Data strength_L;
+	LADSPA_Data strength_R;
+	LADSPA_Data drylevel;
+	LADSPA_Data mode;
+	LADSPA_Data haas;
+	LADSPA_Data rev_outch;
+
+	LADSPA_Data * input_L;
+	LADSPA_Data * output_L;
+	LADSPA_Data * input_R;
+	LADSPA_Data * output_R;
+
+	unsigned long sample_rate;
+	unsigned long buflen_L;
+	unsigned long buflen_R;
+
+	LADSPA_Data out_L = 0;
+	LADSPA_Data out_R = 0;
+	LADSPA_Data in_L = 0;
+	LADSPA_Data in_R = 0;
+
+	ptr = (Echo *)Instance;
+
+	delaytime_L = LIMIT(*(ptr->delaytime_L),0.0f,2000.0f);
+	delaytime_R = LIMIT(*(ptr->delaytime_R),0.0f,2000.0f);
+	feedback_L = LIMIT(*(ptr->feedback_L) / 100.0, 0.0f, 100.0f);
+	feedback_R = LIMIT(*(ptr->feedback_R) / 100.0, 0.0f, 100.0f);
+        strength_L = db2lin(LIMIT(*(ptr->strength_L),-70.0f,10.0f));
+	strength_R = db2lin(LIMIT(*(ptr->strength_R),-70.0f,10.0f));
+	drylevel = db2lin(LIMIT(*(ptr->drylevel),-70.0f,10.0f));
+	mode = LIMIT(*(ptr->mode),-2.0f,2.0f);
+	haas = LIMIT(*(ptr->haas),-2.0f,2.0f);
+	rev_outch = LIMIT(*(ptr->rev_outch),-2.0f,2.0f);
+
+      	input_L = ptr->input_L;
+	output_L = ptr->output_L;
+      	input_R = ptr->input_R;
+	output_R = ptr->output_R;
+
+	sample_rate = ptr->sample_rate;
+	buflen_L = delaytime_L * sample_rate / 1000;
+	buflen_R = delaytime_R * sample_rate / 1000;
+
+
+	for (sample_index = 0; sample_index < SampleCount; sample_index++) {
+		
+		in_L = *(input_L++);
+		in_R = *(input_R++);
+
+		out_L = in_L * drylevel + ptr->mpx_out_L * strength_L;
+		out_R = in_R * drylevel + ptr->mpx_out_R * strength_R;
+
+		if (haas > 0.0f)
+			in_R = 0.0f;
+
+		if (mode <= 0.0f) {
+			ptr->mpx_out_L = 
+				M(push_buffer(in_L + ptr->mpx_out_L * feedback_L,
+					      ptr->ringbuffer_L, buflen_L, ptr->buffer_pos_L));
+			ptr->mpx_out_R =
+				M(push_buffer(in_R + ptr->mpx_out_R * feedback_R,
+					      ptr->ringbuffer_R, buflen_R, ptr->buffer_pos_R));
+		} else {
+			ptr->mpx_out_R =
+				M(push_buffer(in_L + ptr->mpx_out_L * feedback_L,
+					      ptr->ringbuffer_L, buflen_L, ptr->buffer_pos_L));
+			ptr->mpx_out_L =
+				M(push_buffer(in_R + ptr->mpx_out_R * feedback_R,
+					      ptr->ringbuffer_R, buflen_R, ptr->buffer_pos_R));
+		}
+
+		if (rev_outch <= 0.0f) {
+			*(output_L++) += out_L * ptr->run_adding_gain;
+			*(output_R++) += out_R * ptr->run_adding_gain;
+		} else {
+			*(output_L++) += out_R * ptr->run_adding_gain;
+			*(output_R++) += out_L * ptr->run_adding_gain;
+		}
+	}
+}
+
+
+
+/* Throw away an Echo effect instance. */
+void 
+cleanup_Echo(LADSPA_Handle Instance) {
+
+	Echo * ptr = (Echo *)Instance;
+
+	free(ptr->ringbuffer_L);
+	free(ptr->ringbuffer_R);
+	free(ptr->buffer_pos_L);
+	free(ptr->buffer_pos_R);
+
+	free(Instance);
+}
+
+
+
+LADSPA_Descriptor * stereo_descriptor = NULL;
+
+
+
+/* __attribute__((constructor)) _init() is called automatically when the plugin library is first
+   loaded. */
+void 
+__attribute__((constructor)) _init() {
+	
+	char ** port_names;
+	LADSPA_PortDescriptor * port_descriptors;
+	LADSPA_PortRangeHint * port_range_hints;
+	
+	if ((stereo_descriptor =
+	     (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor))) == NULL)
+		exit(1);		
+	
+
+	/* init the stereo Echo */
+	
+	stereo_descriptor->UniqueID = ID_STEREO;
+	stereo_descriptor->Label = strdup("tap_stereo_echo");
+	stereo_descriptor->Properties = LADSPA_PROPERTY_HARD_RT_CAPABLE;
+	stereo_descriptor->Name = strdup("TAP Stereo Echo");
+	stereo_descriptor->Maker = strdup("Tom Szilagyi");
+	stereo_descriptor->Copyright = strdup("GPL");
+	stereo_descriptor->PortCount = PORTCOUNT_STEREO;
+
+	if ((port_descriptors = 
+	     (LADSPA_PortDescriptor *)calloc(PORTCOUNT_STEREO, sizeof(LADSPA_PortDescriptor))) == NULL)
+		exit(1);		
+
+	stereo_descriptor->PortDescriptors = (const LADSPA_PortDescriptor *)port_descriptors;
+	port_descriptors[DELAYTIME_L] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[DELAYTIME_R] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[FEEDBACK_L] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[FEEDBACK_R] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[STRENGTH_L] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[STRENGTH_R] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[DRYLEVEL] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[MODE] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[HAAS] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+	port_descriptors[REV_OUTCH] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
+
+	port_descriptors[INPUT_L] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT_L] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[INPUT_R] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
+	port_descriptors[OUTPUT_R] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
+
+	if ((port_names = 
+	     (char **)calloc(PORTCOUNT_STEREO, sizeof(char *))) == NULL)
+		exit(1);		
+
+	stereo_descriptor->PortNames = (const char **)port_names;
+
+	port_names[DELAYTIME_L] = strdup("L Delay [ms]");
+	port_names[DELAYTIME_R] = strdup("R/Haas Delay [ms]");
+	port_names[FEEDBACK_L] = strdup("L Feedback [%]");
+	port_names[FEEDBACK_R] = strdup("R/Haas Feedback [%]");
+	port_names[STRENGTH_L] = strdup("L Echo Level [dB]");
+	port_names[STRENGTH_R] = strdup("R Echo Level [dB]");
+	port_names[DRYLEVEL] = strdup("Dry Level [dB]");
+	port_names[MODE] = strdup("Cross Mode");
+	port_names[HAAS] = strdup("Haas Effect");
+	port_names[REV_OUTCH] = strdup("Swap Outputs");
+
+	port_names[INPUT_L] = strdup("Input Left");
+	port_names[OUTPUT_L] = strdup("Output Left");
+	port_names[INPUT_R] = strdup("Input Right");
+	port_names[OUTPUT_R] = strdup("Output Right");
+
+	if ((port_range_hints = 
+	     ((LADSPA_PortRangeHint *)calloc(PORTCOUNT_STEREO, sizeof(LADSPA_PortRangeHint)))) == NULL)
+		exit(1);		
+
+	stereo_descriptor->PortRangeHints = (const LADSPA_PortRangeHint *)port_range_hints;
+
+	port_range_hints[DELAYTIME_L].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_100);
+	port_range_hints[DELAYTIME_L].LowerBound = 0;
+	port_range_hints[DELAYTIME_L].UpperBound = MAX_DELAY;
+
+	port_range_hints[DELAYTIME_R].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_100);
+	port_range_hints[DELAYTIME_R].LowerBound = 0;
+	port_range_hints[DELAYTIME_R].UpperBound = MAX_DELAY;
+
+	port_range_hints[FEEDBACK_L].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[FEEDBACK_L].LowerBound = 0;
+	port_range_hints[FEEDBACK_L].UpperBound = 100;
+
+	port_range_hints[FEEDBACK_R].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[FEEDBACK_R].LowerBound = 0;
+	port_range_hints[FEEDBACK_R].UpperBound = 100;
+
+	port_range_hints[STRENGTH_L].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[STRENGTH_L].LowerBound = -70;
+	port_range_hints[STRENGTH_L].UpperBound = 10;
+
+	port_range_hints[STRENGTH_R].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[STRENGTH_R].LowerBound = -70;
+	port_range_hints[STRENGTH_R].UpperBound = 10;
+
+	port_range_hints[MODE].HintDescriptor = 
+		(LADSPA_HINT_TOGGLED |
+		 LADSPA_HINT_DEFAULT_0);
+
+	port_range_hints[HAAS].HintDescriptor = 
+		(LADSPA_HINT_TOGGLED |
+		 LADSPA_HINT_DEFAULT_0);
+
+	port_range_hints[REV_OUTCH].HintDescriptor = 
+		(LADSPA_HINT_TOGGLED |
+		 LADSPA_HINT_DEFAULT_0);
+
+	port_range_hints[DRYLEVEL].HintDescriptor = 
+		(LADSPA_HINT_BOUNDED_BELOW |
+		 LADSPA_HINT_BOUNDED_ABOVE |
+		 LADSPA_HINT_DEFAULT_0);
+	port_range_hints[DRYLEVEL].LowerBound = -70;
+	port_range_hints[DRYLEVEL].UpperBound = 10;
+
+
+	port_range_hints[INPUT_L].HintDescriptor = 0;
+	port_range_hints[OUTPUT_L].HintDescriptor = 0;
+	port_range_hints[INPUT_R].HintDescriptor = 0;
+	port_range_hints[OUTPUT_R].HintDescriptor = 0;
+
+
+	stereo_descriptor->instantiate = instantiate_Echo;
+	stereo_descriptor->connect_port = connect_port_Echo;
+	stereo_descriptor->activate = activate_Echo;
+	stereo_descriptor->run = run_Echo;
+	stereo_descriptor->run_adding = run_adding_gain_Echo;
+	stereo_descriptor->set_run_adding_gain = set_run_adding_gain;
+	stereo_descriptor->deactivate = NULL;
+	stereo_descriptor->cleanup = cleanup_Echo;
+	
+}
+
+
+void
+delete_descriptor(LADSPA_Descriptor * descriptor) {
+	unsigned long index;
+	if (descriptor) {
+		free((char *)descriptor->Label);
+		free((char *)descriptor->Name);
+		free((char *)descriptor->Maker);
+		free((char *)descriptor->Copyright);
+		free((LADSPA_PortDescriptor *)descriptor->PortDescriptors);
+		for (index = 0; index < descriptor->PortCount; index++)
+			free((char *)(descriptor->PortNames[index]));
+		free((char **)descriptor->PortNames);
+		free((LADSPA_PortRangeHint *)descriptor->PortRangeHints);
+		free(descriptor);
+	}
+}
+
+
+/* __attribute__((destructor)) _fini() is called automatically when the library is unloaded. */
+void
+__attribute__((destructor)) _fini() {
+	delete_descriptor(stereo_descriptor);
+}
+
+
+/* Return a descriptor of the requested plugin type. */
+
+const 
+LADSPA_Descriptor * 
+ladspa_descriptor(unsigned long Index) {
+
+	switch (Index) {
+	case 0:
+		return stereo_descriptor;
+	default:
+		return NULL;
+	}
+}

=== added file '.pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_eq.c'
--- .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_eq.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_eq.c	2014-04-11 06:58:04 +0000
@@ -0,0 +1,777 @@
+/*                                                     -*- linux-c -*-
+    Copyright (C) 2004 Tom Szilagyi
+
+    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.
+    
+    $Id: tap_eq.c,v 1.7 2006/08/09 12:03:24 tszilagyi Exp $
+*/
+
+
+/* Please note that this plugin was inspired by and its code based
+upon Steve Harris's "DJ EQ" plugin (no. 1901).  While I give him
+credit for his excellent work, I reserve myself to be blamed for any
+bugs or malfunction. */
+
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include <ladspa.h>
+#include "tap_utils.h"
+
+/* The Unique ID of the plugin */
+#define ID_MONO        2141
+
+
+/* Bandwidth of EQ filters in octaves */
+#define BWIDTH        1.0f
+
+
+/* Port numbers */
+
+#define EQ_CH0G                     0
+#define EQ_CH1G                     1
+#define EQ_CH2G                     2
+#define EQ_CH3G                     3
+#define EQ_CH4G                     4
+#define EQ_CH5G                     5
+#define EQ_CH6G                     6
+#define EQ_CH7G                     7
+
+#define EQ_CH0F                     8
+#define EQ_CH1F                     9
+#define EQ_CH2F                     10
+#define EQ_CH3F                     11
+#define EQ_CH4F                     12
+#define EQ_CH5F                     13
+#define EQ_CH6F                     14
+#define EQ_CH7F                     15
+
+#define EQ_INPUT                    16
+#define EQ_OUTPUT                   17
+
+
+/* Total number of ports */
+#define PORTCOUNT_MONO  18
+
+
+static LADSPA_Descriptor *eqDescriptor = NULL;
+
+typedef struct {
+	LADSPA_Data *ch0f;
+	LADSPA_Data *ch0g;
+	LADSPA_Data *ch1f;
+	LADSPA_Data *ch1g;
+	LADSPA_Data *ch2f;
+	LADSPA_Data *ch2g;
+	LADSPA_Data *ch3f;
+	LADSPA_Data *ch3g;
+	LADSPA_Data *ch4f;
+	LADSPA_Data *ch4g;
+	LADSPA_Data *ch5f;
+	LADSPA_Data *ch5g;
+	LADSPA_Data *ch6f;
+	LADSPA_Data *ch6g;
+	LADSPA_Data *ch7f;
+	LADSPA_Data *ch7g;
+	LADSPA_Data *input;
+	LADSPA_Data *output;
+	biquad *     filters;
+	float        fs;
+	LADSPA_Data old_ch0f;
+	LADSPA_Data old_ch0g;
+	LADSPA_Data old_ch1f;
+	LADSPA_Data old_ch1g;
+	LADSPA_Data old_ch2f;
+	LADSPA_Data old_ch2g;
+	LADSPA_Data old_ch3f;
+	LADSPA_Data old_ch3g;
+	LADSPA_Data old_ch4f;
+	LADSPA_Data old_ch4g;
+	LADSPA_Data old_ch5f;
+	LADSPA_Data old_ch5g;
+	LADSPA_Data old_ch6f;
+	LADSPA_Data old_ch6g;
+	LADSPA_Data old_ch7f;
+	LADSPA_Data old_ch7g;
+
+	LADSPA_Data run_adding_gain;
+} eq;
+
+const
+LADSPA_Descriptor *
+ladspa_descriptor(unsigned long index) {
+	
+	switch (index) {
+	case 0:
+		return eqDescriptor;
+	default:
+	        return NULL;
+	}
+}
+
+static
+void
+activate_eq(LADSPA_Handle instance) {
+
+        eq *ptr = (eq *)instance;
+        biquad *filters = ptr->filters;
+
+	biquad_init(&filters[0]);
+	biquad_init(&filters[1]);
+	biquad_init(&filters[2]);
+	biquad_init(&filters[3]);
+	biquad_init(&filters[4]);
+	biquad_init(&filters[5]);
+	biquad_init(&filters[6]);
+	biquad_init(&filters[7]);
+}
+
+
+
+static
+void
+cleanup_eq(LADSPA_Handle instance) {
+
+	free(instance);
+}
+
+
+static 
+void 
+connectPort_eq(LADSPA_Handle instance, unsigned long port, LADSPA_Data *data) {
+
+	eq *plugin;
+	
+	plugin = (eq *)instance;
+	switch (port) {
+	case EQ_CH0F:
+		plugin->ch0f = data;
+		break;
+	case EQ_CH0G:
+		plugin->ch0g = data;
+		break;
+	case EQ_CH1F:
+		plugin->ch1f = data;
+		break;
+	case EQ_CH1G:
+		plugin->ch1g = data;
+		break;
+	case EQ_CH2F:
+		plugin->ch2f = data;
+		break;
+	case EQ_CH2G:
+		plugin->ch2g = data;
+		break;
+	case EQ_CH3F:
+		plugin->ch3f = data;
+		break;
+	case EQ_CH3G:
+		plugin->ch3g = data;
+		break;
+	case EQ_CH4F:
+		plugin->ch4f = data;
+		break;
+	case EQ_CH4G:
+		plugin->ch4g = data;
+		break;
+	case EQ_CH5F:
+		plugin->ch5f = data;
+		break;
+	case EQ_CH5G:
+		plugin->ch5g = data;
+		break;
+	case EQ_CH6F:
+		plugin->ch6f = data;
+		break;
+	case EQ_CH6G:
+		plugin->ch6g = data;
+		break;
+	case EQ_CH7F:
+		plugin->ch7f = data;
+		break;
+	case EQ_CH7G:
+		plugin->ch7g = data;
+		break;
+	case EQ_INPUT:
+		plugin->input = data;
+		break;
+	case EQ_OUTPUT:
+		plugin->output = data;
+		break;
+	}
+}
+
+static 
+LADSPA_Handle 
+instantiate_eq(const LADSPA_Descriptor *descriptor, unsigned long s_rate) {
+
+	eq *ptr = (eq *)malloc(sizeof(eq));
+	biquad *filters = NULL;
+	float fs;
+
+	fs = s_rate;
+
+	memset(ptr, 0, sizeof(eq));
+	
+	filters = calloc(8, sizeof(biquad));
+
+	ptr->filters = filters;
+	ptr->fs = fs;
+	ptr->run_adding_gain = 1.0f;
+
+	ptr->old_ch0f = 100.0f;
+	ptr->old_ch0g = 0;
+
+	ptr->old_ch1f = 200.0f;
+	ptr->old_ch1g = 0;
+
+	ptr->old_ch2f = 400.0f;
+	ptr->old_ch2g = 0;
+
+	ptr->old_ch3f = 1000.0f;
+	ptr->old_ch3g = 0;
+
+	ptr->old_ch4f = 3000.0f;
+	ptr->old_ch4g = 0;
+
+	ptr->old_ch5f = 6000.0f;
+	ptr->old_ch5g = 0;
+
+	ptr->old_ch6f = 12000.0f;
+	ptr->old_ch6g = 0;
+
+	ptr->old_ch7f = 15000.0f;
+	ptr->old_ch7g = 0;
+
+	eq_set_params(&filters[0], 100.0f, 0.0f, BWIDTH, fs);
+	eq_set_params(&filters[1], 200.0f, 0.0f, BWIDTH, fs);
+	eq_set_params(&filters[2], 400.0f, 0.0f, BWIDTH, fs);
+	eq_set_params(&filters[3], 1000.0f, 0.0f, BWIDTH, fs);
+	eq_set_params(&filters[4], 3000.0f, 0.0f, BWIDTH, fs);
+	eq_set_params(&filters[5], 6000.0f, 0.0f, BWIDTH, fs);
+	eq_set_params(&filters[6], 12000.0f, 0.0f, BWIDTH, fs);
+	eq_set_params(&filters[7], 15000.0f, 0.0f, BWIDTH, fs);
+
+	return (LADSPA_Handle)ptr;
+}
+
+
+static 
+void 
+run_eq(LADSPA_Handle instance, unsigned long sample_count) {
+
+	eq * ptr = (eq *)instance;
+
+	const LADSPA_Data ch0f = LIMIT(*(ptr->ch0f),40.0f,280.0f);
+	const LADSPA_Data ch0g = LIMIT(*(ptr->ch0g),-50.0f,20.0f);
+	const LADSPA_Data ch1f = LIMIT(*(ptr->ch1f),100.0f,500.0f);
+	const LADSPA_Data ch1g = LIMIT(*(ptr->ch1g),-50.0f,20.0f);
+	const LADSPA_Data ch2f = LIMIT(*(ptr->ch2f),200.0f,1000.0f);
+	const LADSPA_Data ch2g = LIMIT(*(ptr->ch2g),-50.0f,20.0f);
+	const LADSPA_Data ch3f = LIMIT(*(ptr->ch3f),400.0f,2800.0f);
+	const LADSPA_Data ch3g = LIMIT(*(ptr->ch3g),-50.0f,20.0f);
+	const LADSPA_Data ch4f = LIMIT(*(ptr->ch4f),1000.0f,5000.0f);
+	const LADSPA_Data ch4g = LIMIT(*(ptr->ch4g),-50.0f,20.0f);
+	const LADSPA_Data ch5f = LIMIT(*(ptr->ch5f),3000.0f,9000.0f);
+	const LADSPA_Data ch5g = LIMIT(*(ptr->ch5g),-50.0f,20.0f);
+	const LADSPA_Data ch6f = LIMIT(*(ptr->ch6f),6000.0f,18000.0f);
+	const LADSPA_Data ch6g = LIMIT(*(ptr->ch6g),-50.0f,20.0f);
+	const LADSPA_Data ch7f = LIMIT(*(ptr->ch7f),10000.0f,20000.0f);
+	const LADSPA_Data ch7g = LIMIT(*(ptr->ch7g),-50.0f,20.0f);
+
+	const LADSPA_Data * input = ptr->input;
+	LADSPA_Data * output = ptr->output;
+
+	biquad * filters = ptr->filters;
+	float fs = ptr->fs;
+
+	unsigned long pos;
+	float samp;
+
+
+	if ((ch0f != ptr->old_ch0f) ||
+	    (ch0g != ptr->old_ch0g)) {
+		ptr->old_ch0f = ch0f;
+		ptr->old_ch0g = ch0g;
+		eq_set_params(&filters[0], ch0f, ch0g, BWIDTH, fs);
+	}
+	if ((ch1f != ptr->old_ch1f) ||
+	    (ch1g != ptr->old_ch1g)) {
+		ptr->old_ch1f = ch1f;
+		ptr->old_ch1g = ch1g;
+		eq_set_params(&filters[1], ch1f, ch1g, BWIDTH, fs);
+	}
+	if ((ch2f != ptr->old_ch2f) ||
+	    (ch2g != ptr->old_ch2g)) {
+		ptr->old_ch2f = ch2f;
+		ptr->old_ch2g = ch2g;
+		eq_set_params(&filters[2], ch2f, ch2g, BWIDTH, fs);
+	}
+	if ((ch3f != ptr->old_ch3f) ||
+	    (ch3g != ptr->old_ch3g)) {
+		ptr->old_ch3f = ch3f;
+		ptr->old_ch3g = ch3g;
+		eq_set_params(&filters[3], ch3f, ch3g, BWIDTH, fs);
+	}
+	if ((ch4f != ptr->old_ch4f) ||
+	    (ch4g != ptr->old_ch4g)) {
+		ptr->old_ch4f = ch4f;
+		ptr->old_ch4g = ch4g;
+		eq_set_params(&filters[4], ch4f, ch4g, BWIDTH, fs);
+	}
+	if ((ch5f != ptr->old_ch5f) ||
+	    (ch5g != ptr->old_ch5g)) {
+		ptr->old_ch5f = ch5f;
+		ptr->old_ch5g = ch5g;
+		eq_set_params(&filters[5], ch5f, ch5g, BWIDTH, fs);
+	}
+	if ((ch6f != ptr->old_ch6f) ||
+	    (ch6g != ptr->old_ch6g)) {
+		ptr->old_ch6f = ch6f;
+		ptr->old_ch6g = ch6g;
+		eq_set_params(&filters[6], ch6f, ch6g, BWIDTH, fs);
+	}
+	if ((ch7f != ptr->old_ch7f) ||
+	    (ch7g != ptr->old_ch7g)) {
+		ptr->old_ch7f = ch7f;
+		ptr->old_ch7g = ch7g;
+		eq_set_params(&filters[7], ch7f, ch7g, BWIDTH, fs);
+	}
+
+	for (pos = 0; pos < sample_count; pos++) {
+		samp = input[pos];
+		if (ch0g != 0.0f)
+			samp = biquad_run(&filters[0], samp);
+		if (ch1g != 0.0f)
+			samp = biquad_run(&filters[1], samp);
+		if (ch2g != 0.0f)
+			samp = biquad_run(&filters[2], samp);
+		if (ch3g != 0.0f)
+			samp = biquad_run(&filters[3], samp);
+		if (ch4g != 0.0f)
+			samp = biquad_run(&filters[4], samp);
+		if (ch5g != 0.0f)
+			samp = biquad_run(&filters[5], samp);
+		if (ch6g != 0.0f)
+			samp = biquad_run(&filters[6], samp);
+		if (ch7g != 0.0f)
+			samp = biquad_run(&filters[7], samp);
+		output[pos] = samp;
+	}
+}
+
+
+
+void
+set_run_adding_gain(LADSPA_Handle instance, LADSPA_Data gain) {
+
+	eq * ptr = (eq *)instance;
+
+	ptr->run_adding_gain = gain;
+}
+
+
+
+static
+void
+run_adding_eq(LADSPA_Handle instance, unsigned long sample_count) {
+
+	eq * ptr = (eq *)instance;
+
+	const LADSPA_Data ch0f = LIMIT(*(ptr->ch0f),40.0f,280.0f);
+	const LADSPA_Data ch0g = LIMIT(*(ptr->ch0g),-50.0f,20.0f);
+	const LADSPA_Data ch1f = LIMIT(*(ptr->ch1f),100.0f,500.0f);
+	const LADSPA_Data ch1g = LIMIT(*(ptr->ch1g),-50.0f,20.0f);
+	const LADSPA_Data ch2f = LIMIT(*(ptr->ch2f),200.0f,1000.0f);
+	const LADSPA_Data ch2g = LIMIT(*(ptr->ch2g),-50.0f,20.0f);
+	const LADSPA_Data ch3f = LIMIT(*(ptr->ch3f),400.0f,2800.0f);
+	const LADSPA_Data ch3g = LIMIT(*(ptr->ch3g),-50.0f,20.0f);
+	const LADSPA_Data ch4f = LIMIT(*(ptr->ch4f),1000.0f,5000.0f);