*** empty log message ***

svn path=/trunk/externals/postlude/; revision=4538

5 files changed, 2459 insertions, 0 deletions

diff --git a/dssi/doc/help-dssi.pd b/dssi/doc/help-dssi.pd
new file mode 100644
index 0000000..821779f
--- /dev/null
+++ b/dssi/doc/help-dssi.pd
@@ -0,0 +1,141 @@
+#N canvas 65 172 1411 654 10;
+#X obj 1177 528 catch~ mix;
+#X text 602 15 dssi~ - a DSSI host for Pure Data ---------------------------------
+;
+#X obj 7 63 cnv 15 1400 300 empty empty dssi~_instance_1 20 12 0 14
+-257472 -66577 0;
+#X obj 443 203 line;
+#X msg 443 182 \$1 10;
+#X obj 441 225 expr $f1 / 127 * 16383;
+#X msg 443 122 0;
+#X floatatom 300 185 5 0 0 0 - - -;
+#X floatatom 443 165 5 0 0 0 - - -;
+#X obj 345 295 dssi~ /usr/local/lib/dssi/hexter.so 2;
+#X msg 1214 136 show 2;
+#X obj 598 274 list;
+#X msg 1130 137 hide;
+#X msg 1171 136 show;
+#X msg 915 162 configure GLOBAL:polyphony 10;
+#X msg 72 256 n \$1;
+#X obj 110 256 r chan;
+#X msg 731 140 load TX-SYX/TFI2.SYX 2;
+#X msg 732 160 load TX-SYX/TFI1.SYX 1;
+#X obj 51 231 list prepend n 2;
+#X obj 300 226 list prepend c 2;
+#X obj 51 208 pack f f;
+#X msg 33 147 60;
+#X msg 78 147 80;
+#X msg 300 205 7 \$1;
+#X obj 441 247 list prepend b 2 0;
+#X obj 344 322 throw~ mix;
+#X obj 119 148 hsl 128 15 60 80 0 0 empty empty empty -2 -6 0 8 -262144
+-1 -1 9200 1;
+#X obj 167 206 select -1;
+#X obj 356 250 r chan;
+#X obj 303 146 hsl 128 15 0 127 0 0 empty empty empty -2 -6 0 8 -262144
+-1 -1 0 1;
+#X obj 446 144 hsl 128 15 -63 63 0 1 empty empty empty -2 -6 0 8 -262144
+-1 -1 6350 1;
+#X obj 598 254 r dssi1-config;
+#X obj 730 185 s dssi1-config;
+#X obj 916 184 s dssi1-config;
+#X obj 1129 186 s dssi1-config;
+#X floatatom 595 142 5 0 0 0 - - -;
+#X msg 318 250 c \$1;
+#X obj 528 268 r chan;
+#X msg 473 268 b \$1 0;
+#X obj 1014 337 s chan;
+#X floatatom 1015 319 5 1 2 1 channel - -;
+#X text 283 98 ----control change----;
+#X obj 667 222 r chan;
+#X text 447 97 ----pitch bend----;
+#X text 585 97 --program change--;
+#X text 105 96 -----notes-----;
+#X text 718 97 --sysex patch/bank load--;
+#X msg 914 140 configure polyphony 10 2;
+#X obj 5 371 cnv 15 400 300 empty empty dssi~_instance_2 20 12 0 14
+-225280 -66577 0;
+#X obj 38 540 dssi~ /usr/lib/dssi/less_trivial_synth.so;
+#X msg 319 495 show;
+#X obj 321 519 list;
+#X msg 357 496 hide;
+#X obj 39 512 list prepend n 1;
+#X msg 40 435 80;
+#X obj 37 561 throw~ mix;
+#X obj 39 492 pack f f;
+#X msg 88 436 60;
+#X text 563 480 Usage: [dssi~ <path to plugin> <number of plugin instances>]
+;
+#X obj 474 122 loadbang;
+#X text 806 212 LAST ARGUMENT GIVES PLUGIN INSTANCE TO BE CONFIGURED
+NO LAST ARGUMENT=(ALL INSTANCES);
+#X msg 613 221 p \$1 0;
+#X text 940 96 --configuration--;
+#X text 947 113 (key value pair);
+#X text 867 279 Select channel (hexter instance) for note \, bend \,
+program and control data:;
+#X obj 595 199 list prepend p 2 0;
+#X obj 39 461 makenote 100 1000;
+#X text 1126 98 --show/hide GUI--;
+#X obj 1175 551 dssi/output~;
+#X obj 49 186 makenote 80 10000;
+#X msg 1282 136 reset;
+#X msg 1340 136 reset 1;
+#X text 1286 98 -reset plugin-;
+#X text 1286 115 (all notes off);
+#X connect 0 0 69 0;
+#X connect 0 0 69 1;
+#X connect 3 0 5 0;
+#X connect 4 0 3 0;
+#X connect 5 0 25 0;
+#X connect 6 0 31 0;
+#X connect 7 0 24 0;
+#X connect 8 0 4 0;
+#X connect 9 0 26 0;
+#X connect 9 1 26 0;
+#X connect 10 0 35 0;
+#X connect 11 0 9 1;
+#X connect 12 0 35 0;
+#X connect 13 0 35 0;
+#X connect 14 0 34 0;
+#X connect 15 0 19 1;
+#X connect 16 0 15 0;
+#X connect 17 0 33 0;
+#X connect 18 0 33 0;
+#X connect 19 0 9 0;
+#X connect 20 0 9 0;
+#X connect 21 0 19 0;
+#X connect 22 0 70 0;
+#X connect 23 0 70 0;
+#X connect 24 0 20 0;
+#X connect 25 0 9 0;
+#X connect 27 0 70 0;
+#X connect 28 1 70 0;
+#X connect 29 0 37 0;
+#X connect 30 0 7 0;
+#X connect 31 0 8 0;
+#X connect 32 0 11 0;
+#X connect 36 0 66 0;
+#X connect 37 0 20 1;
+#X connect 38 0 39 0;
+#X connect 39 0 25 1;
+#X connect 41 0 40 0;
+#X connect 43 0 62 0;
+#X connect 48 0 34 0;
+#X connect 50 0 56 0;
+#X connect 51 0 52 0;
+#X connect 52 0 50 1;
+#X connect 53 0 52 0;
+#X connect 54 0 50 0;
+#X connect 55 0 67 0;
+#X connect 57 0 54 0;
+#X connect 58 0 67 0;
+#X connect 60 0 6 0;
+#X connect 62 0 66 1;
+#X connect 66 0 9 0;
+#X connect 67 0 57 0;
+#X connect 67 1 57 1;
+#X connect 70 0 21 0;
+#X connect 70 1 21 1;
+#X connect 71 0 35 0;
+#X connect 72 0 35 0;
diff --git a/dssi/doc/output~.pd b/dssi/doc/output~.pd
new file mode 100644
index 0000000..4db0809
--- /dev/null
+++ b/dssi/doc/output~.pd
@@ -0,0 +1,69 @@
+#N canvas 0 0 757 675 12;
+#X obj 516 522 t b;
+#X obj 516 469 f;
+#X obj 516 547 f;
+#X msg 630 546 0;
+#X obj 516 499 moses 1;
+#X obj 630 518 t b f;
+#X obj 596 479 moses 1;
+#X obj 29 97 dbtorms;
+#X obj 85 170 inlet~;
+#X msg 278 300 \; pd dsp 1;
+#X obj 29 170 line~;
+#X obj 64 242 *~;
+#X obj 64 272 dac~;
+#X obj 29 127 pack 0 50;
+#X text 121 146 audio in;
+#X text 301 496 test if less than 1 -->;
+#X text 267 523 if true convert to bang -->;
+#X text 100 96 <-- convert from dB to linear units;
+#X floatatom 278 221 3 0 100 0 dB - -;
+#X obj 516 449 bng 15 250 50 0 empty empty mute -38 7 0 12 -262144
+-1 -1;
+#X text 118 126 <-- make a ramp to avoid clicks or zipper noise;
+#X obj 148 170 inlet~;
+#X obj 154 241 *~;
+#X text 502 399 MUTE logic:;
+#X obj 278 193 r \$0-master-lvl;
+#X obj 516 573 s \$0-master-lvl;
+#X obj 293 247 s \$0-master-out;
+#X obj 29 71 r \$0-master-out;
+#X obj 596 450 r \$0-master-out;
+#X text 60 10 Level control abstraction \, used in many of the Pd example
+patches. The level and mute controls show up on the parent \, calling
+patch.;
+#X text 229 549 previous nonzero master-lvl -->;
+#X text 301 453 recall previous;
+#X text 301 471 value of master-lvl -->;
+#X text 16 310 automatically start DSP -->;
+#X obj 85 192 hip~ 3;
+#X obj 147 192 hip~ 3;
+#X text 26 608 NOTE: This abstraction was written by Miller Puckette
+\, and is include with the PD examples as part of the 'standard' PD
+documentation. JB 23/05/05;
+#X connect 0 0 2 0;
+#X connect 1 0 4 0;
+#X connect 2 0 25 0;
+#X connect 3 0 25 0;
+#X connect 4 0 0 0;
+#X connect 4 1 5 0;
+#X connect 5 0 3 0;
+#X connect 6 1 2 1;
+#X connect 7 0 13 0;
+#X connect 8 0 34 0;
+#X connect 10 0 22 0;
+#X connect 10 0 11 0;
+#X connect 11 0 12 0;
+#X connect 13 0 10 0;
+#X connect 18 0 9 0;
+#X connect 18 0 26 0;
+#X connect 19 0 1 0;
+#X connect 21 0 35 0;
+#X connect 22 0 12 1;
+#X connect 24 0 18 0;
+#X connect 27 0 7 0;
+#X connect 28 0 1 1;
+#X connect 28 0 6 0;
+#X connect 34 0 11 1;
+#X connect 35 0 22 1;
+#X coords 0 0 1 1 65 55 1;
diff --git a/dssi/include/seq_event.h b/dssi/include/seq_event.h
new file mode 100644
index 0000000..6d59ca4
--- /dev/null
+++ b/dssi/include/seq_event.h
@@ -0,0 +1,452 @@
+/**
+ * \file include/seq_event.h
+ * \brief Application interface library for the ALSA driver
+ * \author Jaroslav Kysela <perex@suse.cz>
+ * \author Abramo Bagnara <abramo@alsa-project.org>
+ * \author Takashi Iwai <tiwai@suse.de>
+ * \date 1998-2001
+ *
+ * Application interface library for the ALSA driver
+ */
+/*
+ *   This library is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as
+ *   published by the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public
+ *   License along with this library; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ */
+
+#ifndef __ALSA_SEQ_EVENT_H
+#define __ALSA_SEQ_EVENT_H
+
+/**
+ *  \defgroup SeqEvents Sequencer Event Definitions
+ *  Sequencer Event Definitions
+ *  \ingroup Sequencer
+ *  \{
+ */
+
+/**
+ * Sequencer event data type
+ */
+typedef unsigned char snd_seq_event_type_t;
+
+/** Sequencer event type */
+enum snd_seq_event_type {
+	/** system status; event data type = #snd_seq_result_t */
+	SND_SEQ_EVENT_SYSTEM = 0,
+	/** returned result status; event data type = #snd_seq_result_t */
+	SND_SEQ_EVENT_RESULT,
+
+	/** note on and off with duration; event data type = #snd_seq_ev_note_t */
+	SND_SEQ_EVENT_NOTE = 5,
+	/** note on; event data type = #snd_seq_ev_note_t */
+	SND_SEQ_EVENT_NOTEON,
+	/** note off; event data type = #snd_seq_ev_note_t */
+	SND_SEQ_EVENT_NOTEOFF,
+	/** key pressure change (aftertouch); event data type = #snd_seq_ev_note_t */
+	SND_SEQ_EVENT_KEYPRESS,
+	
+	/** controller; event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_CONTROLLER = 10,
+	/** program change; event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_PGMCHANGE,
+	/** channel pressure; event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_CHANPRESS,
+	/** pitchwheel; event data type = #snd_seq_ev_ctrl_t; data is from -8192 to 8191) */
+	SND_SEQ_EVENT_PITCHBEND,
+	/** 14 bit controller value; event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_CONTROL14,
+	/** 14 bit NRPN;  event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_NONREGPARAM,
+	/** 14 bit RPN; event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_REGPARAM,
+
+	/** SPP with LSB and MSB values; event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_SONGPOS = 20,
+	/** Song Select with song ID number; event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_SONGSEL,
+	/** midi time code quarter frame; event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_QFRAME,
+	/** SMF Time Signature event; event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_TIMESIGN,
+	/** SMF Key Signature event; event data type = #snd_seq_ev_ctrl_t */
+	SND_SEQ_EVENT_KEYSIGN,
+	        
+	/** MIDI Real Time Start message; event data type = #snd_seq_ev_queue_control_t */
+	SND_SEQ_EVENT_START = 30,
+	/** MIDI Real Time Continue message; event data type = #snd_seq_ev_queue_control_t */
+	SND_SEQ_EVENT_CONTINUE,
+	/** MIDI Real Time Stop message; event data type = #snd_seq_ev_queue_control_t */
+	SND_SEQ_EVENT_STOP,
+	/** Set tick queue position; event data type = #snd_seq_ev_queue_control_t */
+	SND_SEQ_EVENT_SETPOS_TICK,
+	/** Set real-time queue position; event data type = #snd_seq_ev_queue_control_t */
+	SND_SEQ_EVENT_SETPOS_TIME,
+	/** (SMF) Tempo event; event data type = #snd_seq_ev_queue_control_t */
+	SND_SEQ_EVENT_TEMPO,
+	/** MIDI Real Time Clock message; event data type = #snd_seq_ev_queue_control_t */
+	SND_SEQ_EVENT_CLOCK,
+	/** MIDI Real Time Tick message; event data type = #snd_seq_ev_queue_control_t */
+	SND_SEQ_EVENT_TICK,
+	/** Queue timer skew; event data type = #snd_seq_ev_queue_control_t */
+	SND_SEQ_EVENT_QUEUE_SKEW,
+	/** Sync position changed; event data type = #snd_seq_ev_queue_control_t */
+	SND_SEQ_EVENT_SYNC_POS,
+
+	/** Tune request; event data type = none */
+	SND_SEQ_EVENT_TUNE_REQUEST = 40,
+	/** Reset to power-on state; event data type = none */
+	SND_SEQ_EVENT_RESET,
+	/** Active sensing event; event data type = none */
+	SND_SEQ_EVENT_SENSING,
+
+	/** Echo-back event; event data type = any type */
+	SND_SEQ_EVENT_ECHO = 50,
+	/** OSS emulation raw event; event data type = any type */
+	SND_SEQ_EVENT_OSS,
+
+	/** New client has connected; event data type = #snd_seq_addr_t */
+	SND_SEQ_EVENT_CLIENT_START = 60,
+	/** Client has left the system; event data type = #snd_seq_addr_t */
+	SND_SEQ_EVENT_CLIENT_EXIT,
+	/** Client status/info has changed; event data type = #snd_seq_addr_t */
+	SND_SEQ_EVENT_CLIENT_CHANGE,
+	/** New port was created; event data type = #snd_seq_addr_t */
+	SND_SEQ_EVENT_PORT_START,
+	/** Port was deleted from system; event data type = #snd_seq_addr_t */
+	SND_SEQ_EVENT_PORT_EXIT,
+	/** Port status/info has changed; event data type = #snd_seq_addr_t */
+	SND_SEQ_EVENT_PORT_CHANGE,
+
+	/** Ports connected; event data type = #snd_seq_connect_t */
+	SND_SEQ_EVENT_PORT_SUBSCRIBED,
+	/** Ports disconnected; event data type = #snd_seq_connect_t */
+	SND_SEQ_EVENT_PORT_UNSUBSCRIBED,
+
+	/** Sample select; event data type = #snd_seq_ev_sample_control_t */
+	SND_SEQ_EVENT_SAMPLE = 70,
+	/** Sample cluster select; event data type = #snd_seq_ev_sample_control_t */
+	SND_SEQ_EVENT_SAMPLE_CLUSTER,
+	/** voice start */
+	SND_SEQ_EVENT_SAMPLE_START,
+	/** voice stop */
+	SND_SEQ_EVENT_SAMPLE_STOP,
+	/** playback frequency */
+	SND_SEQ_EVENT_SAMPLE_FREQ,
+	/** volume and balance */
+	SND_SEQ_EVENT_SAMPLE_VOLUME,
+	/** sample loop */
+	SND_SEQ_EVENT_SAMPLE_LOOP,
+	/** sample position */
+	SND_SEQ_EVENT_SAMPLE_POSITION,
+	/** private (hardware dependent) event */
+	SND_SEQ_EVENT_SAMPLE_PRIVATE1,
+
+	/** user-defined event; event data type = any (fixed size) */
+	SND_SEQ_EVENT_USR0 = 90,
+	/** user-defined event; event data type = any (fixed size) */
+	SND_SEQ_EVENT_USR1,
+	/** user-defined event; event data type = any (fixed size) */
+	SND_SEQ_EVENT_USR2,
+	/** user-defined event; event data type = any (fixed size) */
+	SND_SEQ_EVENT_USR3,
+	/** user-defined event; event data type = any (fixed size) */
+	SND_SEQ_EVENT_USR4,
+	/** user-defined event; event data type = any (fixed size) */
+	SND_SEQ_EVENT_USR5,
+	/** user-defined event; event data type = any (fixed size) */
+	SND_SEQ_EVENT_USR6,
+	/** user-defined event; event data type = any (fixed size) */
+	SND_SEQ_EVENT_USR7,
+	/** user-defined event; event data type = any (fixed size) */
+	SND_SEQ_EVENT_USR8,
+	/** user-defined event; event data type = any (fixed size) */
+	SND_SEQ_EVENT_USR9,
+
+	/** begin of instrument management */
+	SND_SEQ_EVENT_INSTR_BEGIN = 100,
+	/** end of instrument management */
+	SND_SEQ_EVENT_INSTR_END,
+	/** query instrument interface info */
+	SND_SEQ_EVENT_INSTR_INFO,
+	/** result of instrument interface info */
+	SND_SEQ_EVENT_INSTR_INFO_RESULT,
+	/** query instrument format info */
+	SND_SEQ_EVENT_INSTR_FINFO,
+	/** result of instrument format info */
+	SND_SEQ_EVENT_INSTR_FINFO_RESULT,
+	/** reset instrument instrument memory */
+	SND_SEQ_EVENT_INSTR_RESET,
+	/** get instrument interface status */
+	SND_SEQ_EVENT_INSTR_STATUS,
+	/** result of instrument interface status */
+	SND_SEQ_EVENT_INSTR_STATUS_RESULT,
+	/** put an instrument to port */
+	SND_SEQ_EVENT_INSTR_PUT,
+	/** get an instrument from port */
+	SND_SEQ_EVENT_INSTR_GET,
+	/** result of instrument query */
+	SND_SEQ_EVENT_INSTR_GET_RESULT,
+	/** free instrument(s) */
+	SND_SEQ_EVENT_INSTR_FREE,
+	/** get instrument list */
+	SND_SEQ_EVENT_INSTR_LIST,
+	/** result of instrument list */
+	SND_SEQ_EVENT_INSTR_LIST_RESULT,
+	/** set cluster parameters */
+	SND_SEQ_EVENT_INSTR_CLUSTER,
+	/** get cluster parameters */
+	SND_SEQ_EVENT_INSTR_CLUSTER_GET,
+	/** result of cluster parameters */
+	SND_SEQ_EVENT_INSTR_CLUSTER_RESULT,
+	/** instrument change */
+	SND_SEQ_EVENT_INSTR_CHANGE,
+
+	/** system exclusive data (variable length);  event data type = #snd_seq_ev_ext_t */
+	SND_SEQ_EVENT_SYSEX = 130,
+	/** error event;  event data type = #snd_seq_ev_ext_t */
+	SND_SEQ_EVENT_BOUNCE,
+	/** reserved for user apps;  event data type = #snd_seq_ev_ext_t */
+	SND_SEQ_EVENT_USR_VAR0 = 135,
+	/** reserved for user apps; event data type = #snd_seq_ev_ext_t */
+	SND_SEQ_EVENT_USR_VAR1,
+	/** reserved for user apps; event data type = #snd_seq_ev_ext_t */
+	SND_SEQ_EVENT_USR_VAR2,
+	/** reserved for user apps; event data type = #snd_seq_ev_ext_t */
+	SND_SEQ_EVENT_USR_VAR3,
+	/** reserved for user apps; event data type = #snd_seq_ev_ext_t */
+	SND_SEQ_EVENT_USR_VAR4,
+
+	/** NOP; ignored in any case */
+	SND_SEQ_EVENT_NONE = 255
+};
+
+
+/** Sequencer event address */
+typedef struct snd_seq_addr {
+	unsigned char client;	/**< Client id */
+	unsigned char port;	/**< Port id */
+} snd_seq_addr_t;
+
+/** Connection (subscription) between ports */
+typedef struct snd_seq_connect {
+	snd_seq_addr_t sender;	/**< sender address */
+	snd_seq_addr_t dest;	/**< destination address */
+} snd_seq_connect_t;
+
+
+/** Real-time data record */
+typedef struct snd_seq_real_time {
+	unsigned int tv_sec;		/**< seconds */
+	unsigned int tv_nsec;		/**< nanoseconds */
+} snd_seq_real_time_t;
+
+/** (MIDI) Tick-time data record */
+typedef unsigned int snd_seq_tick_time_t;
+
+/** unioned time stamp */
+typedef union snd_seq_timestamp {
+	snd_seq_tick_time_t tick;	/**< tick-time */
+	struct snd_seq_real_time time;	/**< real-time */
+} snd_seq_timestamp_t;
+
+
+/**
+ * Event mode flags
+ *
+ * NOTE: only 8 bits available!
+ */
+#define SND_SEQ_TIME_STAMP_TICK		(0<<0)	/**< timestamp in clock ticks */
+#define SND_SEQ_TIME_STAMP_REAL		(1<<0)	/**< timestamp in real time */
+#define SND_SEQ_TIME_STAMP_MASK		(1<<0)	/**< mask for timestamp bits */
+
+#define SND_SEQ_TIME_MODE_ABS		(0<<1)	/**< absolute timestamp */
+#define SND_SEQ_TIME_MODE_REL		(1<<1)	/**< relative to current time */
+#define SND_SEQ_TIME_MODE_MASK		(1<<1)	/**< mask for time mode bits */
+
+#define SND_SEQ_EVENT_LENGTH_FIXED	(0<<2)	/**< fixed event size */
+#define SND_SEQ_EVENT_LENGTH_VARIABLE	(1<<2)	/**< variable event size */
+#define SND_SEQ_EVENT_LENGTH_VARUSR	(2<<2)	/**< variable event size - user memory space */
+#define SND_SEQ_EVENT_LENGTH_MASK	(3<<2)	/**< mask for event length bits */
+
+#define SND_SEQ_PRIORITY_NORMAL		(0<<4)	/**< normal priority */
+#define SND_SEQ_PRIORITY_HIGH		(1<<4)	/**< event should be processed before others */
+#define SND_SEQ_PRIORITY_MASK		(1<<4)	/**< mask for priority bits */
+
+
+/** Note event */
+typedef struct snd_seq_ev_note {
+	unsigned char channel;		/**< channel number */
+	unsigned char note;		/**< note */
+	unsigned char velocity;		/**< velocity */
+	unsigned char off_velocity;	/**< note-off velocity; only for #SND_SEQ_EVENT_NOTE */
+	unsigned int duration;		/**< duration until note-off; only for #SND_SEQ_EVENT_NOTE */
+} snd_seq_ev_note_t;
+
+/** Controller event */
+typedef struct snd_seq_ev_ctrl {
+	unsigned char channel;		/**< channel number */
+	unsigned char unused[3];	/**< reserved */
+	unsigned int param;		/**< control parameter */
+	signed int value;		/**< control value */
+} snd_seq_ev_ctrl_t;
+
+/** generic set of bytes (12x8 bit) */
+typedef struct snd_seq_ev_raw8 {
+	unsigned char d[12];		/**< 8 bit value */
+} snd_seq_ev_raw8_t;
+
+/** generic set of integers (3x32 bit) */
+typedef struct snd_seq_ev_raw32 {
+	unsigned int d[3];		/**< 32 bit value */
+} snd_seq_ev_raw32_t;
+
+/** external stored data */
+typedef struct snd_seq_ev_ext {
+	unsigned int len;		/**< length of data */
+	void *ptr;			/**< pointer to data (note: can be 64-bit) */
+} __attribute__((packed)) snd_seq_ev_ext_t;
+
+/** Instrument cluster type */
+typedef unsigned int snd_seq_instr_cluster_t;
+
+/** Instrument type */
+typedef struct snd_seq_instr {
+	snd_seq_instr_cluster_t cluster;	/**< cluster id */
+	unsigned int std;	/**< instrument standard id; the upper byte means a private instrument (owner - client id) */
+	unsigned short bank;	/**< instrument bank id */
+	unsigned short prg;	/**< instrument program id */
+} snd_seq_instr_t;
+
+/** sample number */
+typedef struct snd_seq_ev_sample {
+	unsigned int std;	/**< sample standard id */
+	unsigned short bank;	/**< sample bank id */
+	unsigned short prg;	/**< sample program id */
+} snd_seq_ev_sample_t;
+
+/** sample cluster */
+typedef struct snd_seq_ev_cluster {
+	snd_seq_instr_cluster_t cluster;	/**< cluster id */
+} snd_seq_ev_cluster_t;
+
+/** sample position */
+typedef unsigned int snd_seq_position_t; /**< playback position (in samples) * 16 */
+
+/** sample stop mode */
+typedef enum snd_seq_stop_mode {
+	SND_SEQ_SAMPLE_STOP_IMMEDIATELY = 0,	/**< terminate playing immediately */
+	SND_SEQ_SAMPLE_STOP_VENVELOPE = 1,	/**< finish volume envelope */
+	SND_SEQ_SAMPLE_STOP_LOOP = 2		/**< terminate loop and finish wave */
+} snd_seq_stop_mode_t;
+
+/** sample frequency */
+typedef int snd_seq_frequency_t; /**< playback frequency in HZ * 16 */
+
+/** sample volume control; if any value is set to -1 == do not change */
+typedef struct snd_seq_ev_volume {
+	signed short volume;	/**< range: 0-16383 */
+	signed short lr;	/**< left-right balance; range: 0-16383 */
+	signed short fr;	/**< front-rear balance; range: 0-16383 */
+	signed short du;	/**< down-up balance; range: 0-16383 */
+} snd_seq_ev_volume_t;
+
+/** simple loop redefinition */
+typedef struct snd_seq_ev_loop {
+	unsigned int start;	/**< loop start (in samples) * 16 */
+	unsigned int end;	/**< loop end (in samples) * 16 */
+} snd_seq_ev_loop_t;
+
+/** Sample control events */
+typedef struct snd_seq_ev_sample_control {
+	unsigned char channel;		/**< channel */
+	unsigned char unused[3];	/**< reserved */
+	union {
+		snd_seq_ev_sample_t sample;	/**< sample number */
+		snd_seq_ev_cluster_t cluster;	/**< cluster number */
+		snd_seq_position_t position;	/**< position */
+		snd_seq_stop_mode_t stop_mode;	/**< stop mode */
+		snd_seq_frequency_t frequency;	/**< frequency */
+		snd_seq_ev_volume_t volume;	/**< volume */
+		snd_seq_ev_loop_t loop;		/**< loop control */
+		unsigned char raw8[8];		/**< raw 8-bit */
+	} param;		/**< control parameters */
+} snd_seq_ev_sample_control_t;
+
+
+
+/** INSTR_BEGIN event */
+typedef struct snd_seq_ev_instr_begin {
+	int timeout;		/**< zero = forever, otherwise timeout in ms */
+} snd_seq_ev_instr_begin_t;
+
+/** Result events */
+typedef struct snd_seq_result {
+	int event;		/**< processed event type */
+	int result;		/**< status */
+} snd_seq_result_t;
+
+/** Queue skew values */
+typedef struct snd_seq_queue_skew {
+	unsigned int value;	/**< skew value */
+	unsigned int base;	/**< skew base */
+} snd_seq_queue_skew_t;
+
+/** queue timer control */
+typedef struct snd_seq_ev_queue_control {
+	unsigned char queue;			/**< affected queue */
+	unsigned char unused[3];		/**< reserved */
+	union {
+		signed int value;		/**< affected value (e.g. tempo) */
+		snd_seq_timestamp_t time;	/**< time */
+		unsigned int position;		/**< sync position */
+		snd_seq_queue_skew_t skew;	/**< queue skew */
+		unsigned int d32[2];		/**< any data */
+		unsigned char d8[8];		/**< any data */
+	} param;				/**< data value union */
+} snd_seq_ev_queue_control_t;
+
+
+/** Sequencer event */
+typedef struct snd_seq_event {
+	snd_seq_event_type_t type;	/**< event type */
+	unsigned char flags;		/**< event flags */
+	unsigned char tag;		/**< tag */
+	
+	unsigned char queue;		/**< schedule queue */
+	snd_seq_timestamp_t time;	/**< schedule time */
+
+	snd_seq_addr_t source;		/**< source address */
+	snd_seq_addr_t dest;		/**< destination address */
+
+	union {
+		snd_seq_ev_note_t note;		/**< note information */
+		snd_seq_ev_ctrl_t control;	/**< MIDI control information */
+		snd_seq_ev_raw8_t raw8;		/**< raw8 data */
+		snd_seq_ev_raw32_t raw32;	/**< raw32 data */
+		snd_seq_ev_ext_t ext;		/**< external data */
+		snd_seq_ev_queue_control_t queue; /**< queue control */
+		snd_seq_timestamp_t time;	/**< timestamp */
+		snd_seq_addr_t addr;		/**< address */
+		snd_seq_connect_t connect;	/**< connect information */
+		snd_seq_result_t result;	/**< operation result code */
+		snd_seq_ev_instr_begin_t instr_begin; /**< instrument */
+		snd_seq_ev_sample_control_t sample; /**< sample control */
+	} data;				/**< event data... */
+} snd_seq_event_t;
+
+
+/** \} */
+
+#endif /* __ALSA_SEQ_EVENT_H */
+
diff --git a/dssi/src/dssi~.c b/dssi/src/dssi~.c
new file mode 100644
index 0000000..11736c3
--- /dev/null
+++ b/dssi/src/dssi~.c
@@ -0,0 +1,1740 @@
+/* dssi~ - A DSSI host for PD 
+ * 
+ * Copyright 2006 Jamie Bullock and others 
+ *
+ * This file incorporates code from the following sources:
+ * 
+ * jack-dssi-host (BSD-style license): Copyright 2004 Chris Cannam, Steve Harris and Sean Bolton.
+ *		   
+ * Hexter (GPL license): Copyright (C) 2004 Sean Bolton and others.
+ * 
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+
+
+/* TODO:
+   1. Fix memory allocation issues.
+   2. Restore Trivial Synth compatibility, i.e. is GUI fails, don't crash. - DONE!
+   3. Reomve alsa.h dependency - Included header file!
+   4. Get Hexter/Fluidsynth working - DONE!
+   5. Get LTS working (full functionality i.e Pitch Bend, Control etc.) - DONE!
+   6. Do OSC/GUI - DONE!
+   7. Multiple instances -DONE!
+   8. If OSC is received from another source - update the GUI.
+   9. Patch saving/loading. -DONE (for Hexter)!
+   10. Make GUI close when app closes, or new plugin loaded. -DONE!
+   11. Make ll-scope work.
+   12. Fix note hangs. - DONE - this was due to precedence problems in the PD patch!
+   13. Fix inability to run two instances of the dssi~ external. - DONE!
+   14. Fix exiting handler -DONE!
+   15. Fix GUI close when PD quit - don't leave defunct process
+   16. Fix free() call if plugin isn't loaded successfully -DONE!
+   17. Implement GUI show/hide. -DONE!
+   18. Fix segfault if dssi~ recieves on MIDI channel it doesn't have an instance for -DONE!
+   19. Fix program crash when patch load if audio running. -DONE!
+   20. Make info logged to pd console more meaningful
+   21. Add more error checking.
+   22. Fix: global polyphony handling - DONE!
+   23. Fix: config malloc bugs
+   24. Fix: exit call instance deactivate function - DONE!
+   25. Check DSSI spec conformity!
+   26. FIX: Why does is incorrect patch name chown when program is changed from GUI? - DONE! - query_programs must be sent for each configure call
+   27. FIX: Generic valgrind error - also in jack-dssi-host.
+ */
+
+
+#include "dssi~.h"
+
+
+
+static t_class *dssi_tilde_class;
+
+/*From dx7_voice_data.c by Sean Bolton */
+
+static char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/*From dx7_voice.h by Sean Bolton */
+
+typedef struct _dx7_patch_t {
+	uint8_t data[128];
+} dx7_patch_t;
+
+typedef struct _dssi_instance {
+   
+   long             currentBank;
+   long             currentProgram;
+   int              pendingBankLSB;
+   int              pendingBankMSB;
+   int              pendingProgramChange;
+   
+   int plugin_ProgramCount;
+   DSSI_Program_Descriptor *pluginPrograms;
+
+   lo_address       uiTarget; /*osc stuff */
+   int              ui_hidden;
+   int              ui_show;
+   int              uiNeedsProgramUpdate;
+   char            *ui_osc_control_path;
+   char            *ui_osc_configure_path;
+   char            *ui_osc_program_path;
+   char            *ui_osc_show_path;
+   char            *ui_osc_hide_path;
+   
+   int *plugin_PortControlInNumbers; /*not sure if this should go here?*/
+  
+   char *osc_url_path;
+   pid_t	gui_pid;
+   
+} t_dssi_instance;
+
+typedef struct _dssi_tilde {
+  t_object  x_obj;
+  char *dll_path;/*abs path to plugin*/
+  void *dll_handle;
+  char *dir; /* project dircetory */
+  LADSPA_Handle *instanceHandles; /*was handle*/
+  t_dssi_instance *instances; 
+  int n_instances;
+  unsigned long *instanceEventCounts;
+  snd_seq_event_t **instanceEventBuffers;
+
+snd_seq_event_t midiEventBuf[EVENT_BUFSIZE];
+/*static snd_seq_event_t **instanceEventBuffers;*/
+int bufWriteIndex, bufReadIndex;
+pthread_mutex_t midiEventBufferMutex;
+/*static pthread_mutex_t listHandlerMutex = PTHREAD_MUTEX_INITIALIZER;*/
+   
+  DSSI_Descriptor_Function desc_func;
+  const DSSI_Descriptor *descriptor;
+  
+  t_int	ports_in, ports_out, ports_controlIn, ports_controlOut;
+  t_int plugin_ins;/* total audio input ports for plugin*/
+  t_int plugin_outs;/* total audio output ports plugin*/
+  t_int plugin_controlIns;/* total control input ports*/
+  t_int plugin_controlOuts;/* total control output ports */
+
+  unsigned long *plugin_ControlInPortNumbers; /*Array of input port numbers for the plugin */
+
+  t_float **plugin_InputBuffers, **plugin_OutputBuffers; /* arrays of arrays for buffering audio for each audio port */
+  t_float *plugin_ControlDataInput, *plugin_ControlDataOutput; /*arrays for control data for each port (1 item per 'run')*/
+  lo_server_thread osc_thread;
+  char *osc_url_base;
+  char *dll_name;
+  
+  t_int time_ref; /*logical time reference */
+  t_int sr;
+  t_float sr_inv;
+  t_int blksize;
+  t_float f;
+  
+  t_float **outlets;
+  
+} t_dssi_tilde;
+
+static void dssi_load_gui(t_dssi_tilde *x, int instance);
+
+static int osc_message_handler(const char *path, const char *types, 
+		lo_arg **argv, int argc, void *data, void *user_data);
+static LADSPA_Data get_port_default(t_dssi_tilde *x, int port);
+static void MIDIbuf(int type, int chan, int param, int val, t_dssi_tilde *x);
+
+
+
+/*static void init_MidiEventBuf(snd_seq_event_t *MidiEventBuf){
+	int i;
+	for(i = 0; i < EVENT_BUFSIZE; i++){
+		MidiEventBuf[i].*/
+
+
+/*
+ * encode_7in6
+** Taken from gui_data.c by Sean Bolton **
+ *
+ * encode a block of 7-bit data, in base64-ish style
+ */
+char *
+encode_7in6(uint8_t *data, int length)
+{
+    char *buffer;
+    int in, reg, above, below, shift, out;
+    int outchars = (length * 7 + 5) / 6;
+    unsigned int sum = 0;
+
+    if (!(buffer = (char *)malloc(25 + outchars)))
+        return NULL;
+
+    out = snprintf(buffer, 12, "%d ", length);
+
+    in = reg = above = below = 0;
+    while (outchars) {
+        if (above == 6) {
+            buffer[out] = base64[reg >> 7];
+            reg &= 0x7f;
+            above = 0;
+            out++;
+            outchars--;
+        }
+        if (below == 0) {
+            if (in < length) {
+                reg |= data[in] & 0x7f;
+                sum += data[in];
+            }
+            below = 7;
+            in++;
+        }
+        shift = 6 - above;
+        if (below < shift) shift = below;
+        reg <<= shift;
+        above += shift;
+        below -= shift;
+    }
+
+    snprintf(buffer + out, 12, " %d", sum);
+
+    return buffer;
+}
+
+
+
+
+static void dssi_load(char *dll_path, void **dll_handle){
+	
+	*dll_handle = dlopen(dll_path, RTLD_NOW);
+	if (*dll_handle){
+		post("%s loaded successfully", dll_path);
+	}
+	else
+		post("Failed: %s", dlerror());
+	
+}
+	
+static void portInfo(t_dssi_tilde *x){
+	t_int i;
+	for (i = 0; i < (t_int)x->descriptor->LADSPA_Plugin->PortCount; i++) {
+		LADSPA_PortDescriptor pod =	
+			x->descriptor->LADSPA_Plugin->PortDescriptors[i];
+#if DEBUG
+		post("Port %d: %s", i, x->descriptor->LADSPA_Plugin->PortNames[i]);
+#endif
+		if (LADSPA_IS_PORT_AUDIO(pod)) {
+			if (LADSPA_IS_PORT_INPUT(pod)) ++x->plugin_ins;
+			else if (LADSPA_IS_PORT_OUTPUT(pod)) ++x->plugin_outs;
+		} 
+		else if (LADSPA_IS_PORT_CONTROL(pod)) {
+			if (LADSPA_IS_PORT_INPUT(pod)) ++x->plugin_controlIns;
+			else if (LADSPA_IS_PORT_OUTPUT(pod)) ++x->plugin_controlOuts;
+		}
+	}
+#if DEBUG
+post("%d inputs, %d outputs, %d control inputs, %d control outs", x->plugin_ins, x->plugin_outs, x->plugin_controlIns, x->plugin_controlOuts);
+#endif
+}
+
+static void dssi_assignPorts(t_dssi_tilde *x){
+	int i;
+
+#if DEBUG
+	post("%d instances", x->n_instances);
+#endif
+
+    x->plugin_ins *= x->n_instances;
+    x->plugin_outs *= x->n_instances;
+    x->plugin_controlIns *= x->n_instances;
+    x->plugin_controlOuts *= x->n_instances;
+
+#if DEBUG
+	post("%d plugin outs", x->plugin_outs);
+#endif
+	
+	x->plugin_InputBuffers = 
+		(float **)malloc(x->plugin_ins * sizeof(float *));
+	x->plugin_OutputBuffers = 
+		(float **)malloc(x->plugin_outs * sizeof(float *));
+	x->plugin_ControlDataInput = 
+		(float *)calloc(x->plugin_controlIns, sizeof(float));
+	x->plugin_ControlDataOutput = 
+		(float *)calloc(x->plugin_controlOuts, sizeof(float));
+	for(i = 0; i < x->plugin_ins; i++)
+		x->plugin_InputBuffers[i] = 
+			(float *)calloc(x->blksize, sizeof(float));
+	for(i = 0; i < x->plugin_outs; i++)
+		x->plugin_OutputBuffers[i] = 
+			(float *)calloc(x->blksize, sizeof(float));
+	x->instanceEventBuffers = 
+		(snd_seq_event_t **)malloc(x->n_instances * sizeof(snd_seq_event_t *));
+
+	
+    x->instanceHandles = (LADSPA_Handle *)malloc(x->n_instances *
+                                              sizeof(LADSPA_Handle));
+    x->instanceEventCounts = (unsigned long *)malloc(x->n_instances *
+                                                  sizeof(unsigned long));
+
+	for(i = 0; i < x->n_instances; i++){
+		x->instanceEventBuffers[i] = (snd_seq_event_t *)malloc(EVENT_BUFSIZE *
+								sizeof(snd_seq_event_t));
+
+		x->instances[i].plugin_PortControlInNumbers = 
+			(int *)malloc(x->descriptor->LADSPA_Plugin->PortCount * 
+						  sizeof(int));/* hmmm... as we don't support instances of differing plugin types, we probably don't need to do this dynamically*/
+	}
+	
+	x->plugin_ControlInPortNumbers = 
+		(unsigned long *)malloc(sizeof(unsigned long) * x->plugin_controlIns);
+
+#if DEBUG		
+	post("Buffers assigned!");
+#endif
+
+}
+
+static void dssi_init(t_dssi_tilde *x, t_int instance){
+
+	x->instances[instance].pluginPrograms = NULL;
+	x->instances[instance].currentBank = 0;
+	x->instances[instance].currentProgram = 0;
+	x->instances[instance].uiTarget = NULL;
+	x->instances[instance].ui_osc_control_path = NULL;
+	x->instances[instance].ui_osc_program_path = NULL;
+	x->instances[instance].ui_osc_show_path = NULL;
+	x->instances[instance].ui_osc_hide_path = NULL;
+	x->instances[instance].ui_osc_configure_path = NULL;
+	x->instances[instance].uiNeedsProgramUpdate = 0;
+	x->instances[instance].pendingProgramChange = -1;
+	x->instances[instance].pendingBankMSB = -1;
+	x->instances[instance].pendingBankLSB = -1;
+	x->instances[instance].ui_hidden = 1;
+	x->instances[instance].ui_show = 0;
+#if DEBUG		
+	post("Instance %d initialized!", instance);
+#endif
+
+
+}
+
+static void dssi_connectPorts(t_dssi_tilde *x, t_int instance){
+
+	t_int i;
+
+	for(i = 0; i < (t_int)x->descriptor->LADSPA_Plugin->PortCount; i++){
+#if DEBUG
+		post("PortCount: %d of %d", i, 
+				x->descriptor->LADSPA_Plugin->PortCount);
+#endif
+		LADSPA_PortDescriptor pod =
+					 x->descriptor->LADSPA_Plugin->PortDescriptors[i];
+
+		x->instances[instance].plugin_PortControlInNumbers[i] = -1;
+		
+		if (LADSPA_IS_PORT_AUDIO(pod)) {
+			if (LADSPA_IS_PORT_INPUT(pod)) {
+				x->descriptor->LADSPA_Plugin->connect_port
+					(x->instanceHandles[instance], i, 
+					 x->plugin_InputBuffers[x->ports_in++]);
+			} 
+			else if (LADSPA_IS_PORT_OUTPUT(pod)) {
+				x->descriptor->LADSPA_Plugin->connect_port
+					(x->instanceHandles[instance], i, 
+					 x->plugin_OutputBuffers[x->ports_out++]);
+#if DEBUG
+				post("Outport port %d connected", x->ports_out);
+#endif
+			}
+		} 
+		else if (LADSPA_IS_PORT_CONTROL(pod)) {
+			if (LADSPA_IS_PORT_INPUT(pod)) {
+				x->plugin_ControlInPortNumbers[x->ports_controlIn] = (unsigned long) i;
+				x->instances[instance].plugin_PortControlInNumbers[i] = x->ports_controlIn;
+				x->plugin_ControlDataInput[x->ports_controlIn] = 
+					(t_float) get_port_default(x, i);
+#if DEBUG
+				post("default for port %d, controlIn, %d is %.2f",i,
+						x->ports_controlIn, x->plugin_ControlDataInput[x->ports_controlIn]);
+#endif
+
+				x->descriptor->LADSPA_Plugin->connect_port
+					(x->instanceHandles[instance], i, 
+					 &x->plugin_ControlDataInput[x->ports_controlIn++]);
+
+			} else if (LADSPA_IS_PORT_OUTPUT(pod)) {
+				x->descriptor->LADSPA_Plugin->connect_port
+					(x->instanceHandles[instance], i, 
+					 &x->plugin_ControlDataOutput[x->ports_controlOut++]);
+			}
+		}
+	}
+	
+#if DEBUG
+post("ports connected!");
+#endif
+	
+}
+
+static void dssi_activate(t_dssi_tilde *x, t_int instance){
+
+		x->descriptor->LADSPA_Plugin->activate(x->instanceHandles[instance]);
+#if DEBUG
+		post("plugin activated!");
+#endif
+}
+
+static void osc_error(int num, const char *msg, const char *where)
+{
+    post("osc error %d in path %s: %s\n",num, where, msg);
+}
+
+static void query_programs(t_dssi_tilde *x, t_int instance) {
+    int i;
+#if DEBUG
+post("querying programs");
+#endif
+    /* free old lot */
+    if (x->instances[instance].pluginPrograms) {
+        for (i = 0; i < x->instances[instance].plugin_ProgramCount; i++)
+			free((void *)x->instances[instance].pluginPrograms[i].Name);
+		x->instances[instance].pluginPrograms = NULL;
+		x->instances[instance].plugin_ProgramCount = 0;
+    }
+
+    x->instances[instance].pendingBankLSB = -1;
+    x->instances[instance].pendingBankMSB = -1;
+    x->instances[instance].pendingProgramChange = -1;
+
+    if (x->descriptor->get_program &&
+        x->descriptor->select_program) {
+
+	/* Count the plugins first */
+		for (i = 0; x->descriptor->
+					   get_program(x->instanceHandles[instance], i); ++i);
+
+		if (i > 0) {
+			x->instances[instance].plugin_ProgramCount = i;
+			x->instances[instance].pluginPrograms = 
+				(DSSI_Program_Descriptor *)malloc(i * sizeof(DSSI_Program_Descriptor)); 
+			while (i > 0) {
+				const DSSI_Program_Descriptor *descriptor;
+				--i;
+				descriptor = x->descriptor->
+					get_program(x->instanceHandles[instance], i);
+				x->instances[instance].pluginPrograms[i].Bank = 
+					descriptor->Bank;
+				x->instances[instance].pluginPrograms[i].Program = 
+					descriptor->Program;
+				x->instances[instance].pluginPrograms[i].Name = 
+					strdup(descriptor->Name);
+#if DEBUG
+				post("program %d is MIDI bank %lu program %lu, named '%s'",i,
+				   x->instances[instance].pluginPrograms[i].Bank,
+				   x->instances[instance].pluginPrograms[i].Program,
+				   x->instances[instance].pluginPrograms[i].Name);
+#endif
+			}
+		}
+	}
+}
+
+static LADSPA_Data get_port_default(t_dssi_tilde *x, int port)
+{
+	LADSPA_Descriptor *plugin = (LADSPA_Descriptor *)x->descriptor->LADSPA_Plugin;
+    LADSPA_PortRangeHint hint = plugin->PortRangeHints[port];
+    float lower = hint.LowerBound *
+	(LADSPA_IS_HINT_SAMPLE_RATE(hint.HintDescriptor) ? x->sr : 1.0f);
+    float upper = hint.UpperBound *
+	(LADSPA_IS_HINT_SAMPLE_RATE(hint.HintDescriptor) ? x->sr : 1.0f);
+
+    if (!LADSPA_IS_HINT_HAS_DEFAULT(hint.HintDescriptor)) {
+	if (!LADSPA_IS_HINT_BOUNDED_BELOW(hint.HintDescriptor) ||
+	    !LADSPA_IS_HINT_BOUNDED_ABOVE(hint.HintDescriptor)) {
+	    /* No hint, its not bounded, wild guess */
+	    return 0.0f;
+	}
+
+	if (lower <= 0.0f && upper >= 0.0f) {
+	    /* It spans 0.0, 0.0 is often a good guess */
+	    return 0.0f;
+	}
+
+	/* No clues, return minimum */
+	return lower;
+    }
+
+    /* Try all the easy ones */
+    
+    if (LADSPA_IS_HINT_DEFAULT_0(hint.HintDescriptor)) {
+	return 0.0f;
+    } else if (LADSPA_IS_HINT_DEFAULT_1(hint.HintDescriptor)) {
+	return 1.0f;
+    } else if (LADSPA_IS_HINT_DEFAULT_100(hint.HintDescriptor)) {
+	return 100.0f;
+    } else if (LADSPA_IS_HINT_DEFAULT_440(hint.HintDescriptor)) {
+	return 440.0f;
+    }
+
+    /* All the others require some bounds */
+
+    if (LADSPA_IS_HINT_BOUNDED_BELOW(hint.HintDescriptor)) {
+	if (LADSPA_IS_HINT_DEFAULT_MINIMUM(hint.HintDescriptor)) {
+	    return lower;
+	}
+    }
+    if (LADSPA_IS_HINT_BOUNDED_ABOVE(hint.HintDescriptor)) {
+	if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(hint.HintDescriptor)) {
+	    return upper;
+	}
+	if (LADSPA_IS_HINT_BOUNDED_BELOW(hint.HintDescriptor)) {
+	    if (LADSPA_IS_HINT_DEFAULT_LOW(hint.HintDescriptor)) {
+		return lower * 0.75f + upper * 0.25f;
+	    } else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(hint.HintDescriptor)) {
+		return lower * 0.5f + upper * 0.5f;
+	    } else if (LADSPA_IS_HINT_DEFAULT_HIGH(hint.HintDescriptor)) {
+		return lower * 0.25f + upper * 0.75f;
+	    }
+	}
+    }
+
+    /* fallback */
+    return 0.0f;
+}
+
+
+
+static int osc_debug_handler(const char *path, const char *types, lo_arg **argv,
+                      int argc, void *data, t_dssi_tilde *x)
+{
+    int i;
+    printf("got unhandled OSC message:\npath: <%s>\n", path);
+    for (i=0; i<argc; i++) {
+        printf("arg %d '%c' ", i, types[i]);
+        lo_arg_pp(types[i], argv[i]);
+        printf("\n");
+    }
+    return 1;
+}
+
+static void dssi_ProgramChange(t_dssi_tilde *x, int instance){
+/* jack-dssi-host queues program changes by using  pending program change variables. In the audio callback, if a program change is received via MIDI it over writes the pending value (if any) set by the GUI. If unset, or processed the value will default back to -1. The following call to select_program is then made. I don't think it eventually needs to be done this way - i.e. do we need 'pending'? */ 
+#if DEBUG
+	post("executing program change");
+#endif
+	if (x->instances[instance].pendingProgramChange >= 0){           
+		if (x->instances[instance].pendingBankLSB >= 0) {
+			if (x->instances[instance].pendingBankMSB >= 0) {
+				x->instances[instance].currentBank = x->instances[instance].pendingBankLSB + 128 * x->instances[instance].pendingBankMSB;
+			} 
+			else {
+				x->instances[instance].currentBank = x->instances[instance].pendingBankLSB + 
+					128 * (x->instances[instance].currentBank / 128);
+			}
+		} 
+		else if (x->instances[instance].pendingBankMSB >= 0) {
+			x->instances[instance].currentBank = (x->instances[instance].currentBank % 128) + 128 * x->instances[instance].pendingBankMSB;
+		}
+
+		x->instances[instance].currentProgram = x->instances[instance].pendingProgramChange;
+
+	   if (x->descriptor->select_program) {
+			x->descriptor->select_program(x->instanceHandles[instance],
+							   x->instances[instance].currentBank, x->instances[instance].currentProgram);
+	   }
+	   if (x->instances[instance].uiNeedsProgramUpdate){
+#if DEBUG
+		   post("Updating GUI program");
+#endif 
+		   lo_send(x->instances[instance].uiTarget, 
+				   x->instances[instance].ui_osc_program_path, "ii", 
+				   x->instances[instance].currentBank, 
+				   x->instances[instance].currentProgram);
+	   }
+		x->instances[instance].uiNeedsProgramUpdate = 0;
+	    x->instances[instance].pendingProgramChange = -1;
+		x->instances[instance].pendingBankMSB = -1;
+		x->instances[instance].pendingBankLSB = -1;
+	}
+}
+
+static int osc_program_handler(t_dssi_tilde *x, lo_arg **argv, int instance)
+{
+    unsigned long bank = argv[0]->i;
+    unsigned long program = argv[1]->i;
+    int i;
+    int found = 0;
+
+#if DEBUG
+post("osc_program_hander active!");
+
+post("%d programs", x->instances[instance].plugin_ProgramCount);
+	
+#endif
+    for (i = 0; i < x->instances[instance].plugin_ProgramCount; ++i) {
+		if (x->instances[instance].pluginPrograms[i].Bank == bank &&
+			x->instances[instance].pluginPrograms[i].Program == program) {
+			post("OSC: setting bank %u, program %u, name %s\n",
+				bank, program, x->instances[instance].pluginPrograms[i].Name);
+	    
+			found = 1;
+			break;
+		}
+    }
+
+    if (!found) {
+	printf(": OSC:  UI requested unknown program: bank %d, program %u: sending to plugin anyway (plugin should ignore it)\n", (int)bank,(int)program);
+    }
+
+    x->instances[instance].pendingBankMSB = bank / 128;
+    x->instances[instance].pendingBankLSB = bank % 128;
+    x->instances[instance].pendingProgramChange = program;
+#if DEBUG
+	post("bank = %d, program = %d, BankMSB = %d BankLSB = %d", bank, program, x->instances[instance].pendingBankMSB, x->instances[instance].pendingBankLSB);
+#endif
+	dssi_ProgramChange(x, instance);
+	
+    return 0;
+}
+
+
+static int osc_control_handler(t_dssi_tilde *x, lo_arg **argv, int instance)
+{
+    int port = argv[0]->i;
+    LADSPA_Data value = argv[1]->f;
+
+    x->plugin_ControlDataInput[x->instances[instance].plugin_PortControlInNumbers[port]] = value;
+#if DEBUG
+	post("OSC: port %d = %f", port, value);
+#endif
+    
+    return 0;
+}
+
+static int osc_midi_handler(t_dssi_tilde *x, lo_arg **argv, t_int instance)
+{
+
+	int ev_type = 0, chan = 0;
+/*	div_t divstruct; *//*division strucutre for integer division*/
+#if DEBUG
+	post("OSC: got midi request for"
+	       "(%02x %02x %02x %02x)",
+	       argv[0]->m[0], argv[0]->m[1], argv[0]->m[2], argv[0]->m[3]);
+#endif
+/*	divstruct = div(argv[0]->m[1], 16);
+	chan = divstruct.rem + 1; */ /*Wrong! the GUI's all use channel 0 */
+	chan = instance;
+#if DEBUG
+	post("channel: %d", chan);
+#endif
+
+	if(argv[0]->m[1] <= 239){
+		if(argv[0]->m[1] >= 224)
+			ev_type = SND_SEQ_EVENT_PITCHBEND;
+		else if(argv[0]->m[1] >= 208)
+			ev_type = SND_SEQ_EVENT_CHANPRESS;
+		else if(argv[0]->m[1] >= 192)
+			ev_type = SND_SEQ_EVENT_PGMCHANGE;
+		else if(argv[0]->m[1] >= 176)
+			ev_type = SND_SEQ_EVENT_CONTROLLER;
+		else if(argv[0]->m[1] >= 160)
+			ev_type = SND_SEQ_EVENT_KEYPRESS;
+		else if(argv[0]->m[1] >= 144)
+			ev_type = SND_SEQ_EVENT_NOTEON;
+		else if(argv[0]->m[1] >= 128)
+			ev_type = SND_SEQ_EVENT_NOTEOFF;
+	}
+	if(ev_type != 0)
+		MIDIbuf(ev_type, chan, argv[0]->m[2], argv[0]->m[3], x);
+
+    return 0;
+}
+
+static int osc_configure_handler(t_dssi_tilde *x, lo_arg **argv, int instance)
+{
+    const char *key = (const char *)&argv[0]->s;
+    const char *value = (const char *)&argv[1]->s;
+    char *message;
+
+#if DEBUG
+	post("osc_configure_handler active!");
+#endif
+    
+    if (x->descriptor->configure) {
+
+	if (!strncmp(key, DSSI_RESERVED_CONFIGURE_PREFIX,
+		     strlen(DSSI_RESERVED_CONFIGURE_PREFIX))) {
+	    fprintf(stderr, ": OSC: UI for plugin '' attempted to use reserved configure key \"%s\", ignoring\n", key);
+	    return 0;
+	}
+	
+	    message = x->descriptor->configure(x->instanceHandles[instance], key, value);
+	    if (message) {
+		printf(": on configure  '%s', plugin '' returned error '%s'\n",
+		        key, message);
+		free(message);
+	    }
+		
+	    query_programs(x, instance);
+
+	}	    
+    
+
+    return 0;
+}
+
+
+
+
+
+static int osc_exiting_handler(t_dssi_tilde *x, lo_arg **argv, int instance){
+
+#if DEBUG
+	post("exiting handler called: Freeing ui_osc");
+#endif
+	lo_address_free(x->instances[instance].uiTarget);
+     free(x->instances[instance].ui_osc_control_path);
+     free(x->instances[instance].ui_osc_configure_path);
+     free(x->instances[instance].ui_osc_hide_path);
+     free(x->instances[instance].ui_osc_program_path);
+     free(x->instances[instance].ui_osc_show_path); 
+     x->instances[instance].uiTarget = NULL;
+     x->instances[instance].ui_osc_control_path = NULL;
+     x->instances[instance].ui_osc_configure_path = NULL;
+     x->instances[instance].ui_osc_hide_path = NULL;
+     x->instances[instance].ui_osc_program_path = NULL;
+     x->instances[instance].ui_osc_show_path = NULL;
+
+	x->instances[instance].ui_hidden = 1;
+
+	return 0;
+}
+
+static int osc_update_handler(t_dssi_tilde *x, lo_arg **argv, int instance)
+{
+    const char *url = (char *)&argv[0]->s;
+    const char *path;
+    t_int i;
+    char *host, *port;
+
+#if DEBUG
+	post("OSC: got update request from <%s>, instance %d", url, instance);
+#endif
+
+
+    if (x->instances[instance].uiTarget) 
+		lo_address_free(x->instances[instance].uiTarget);
+    host = lo_url_get_hostname(url);
+    port = lo_url_get_port(url);
+    x->instances[instance].uiTarget = lo_address_new(host, port);
+    free(host);
+    free(port);
+
+    path = lo_url_get_path(url);
+
+    if (x->instances[instance].ui_osc_control_path) 
+		free(x->instances[instance].ui_osc_control_path);
+    x->instances[instance].ui_osc_control_path = 
+		(char *)malloc(strlen(path) + 10);
+    sprintf(x->instances[instance].ui_osc_control_path, "%s/control", path);
+
+    if (x->instances[instance].ui_osc_configure_path) 
+		free(x->instances[instance].ui_osc_configure_path);
+    x->instances[instance].ui_osc_configure_path = 
+		(char *)malloc(strlen(path) + 12);
+    sprintf(x->instances[instance].ui_osc_configure_path, "%s/configure", path);
+
+    if (x->instances[instance].ui_osc_program_path) 
+		free(x->instances[instance].ui_osc_program_path); 
+    x->instances[instance].ui_osc_program_path = 
+		(char *)malloc(strlen(path) + 10);
+    sprintf(x->instances[instance].ui_osc_program_path, "%s/program", path);
+
+    if (x->instances[instance].ui_osc_show_path) 
+		free(x->instances[instance].ui_osc_show_path); 
+    x->instances[instance].ui_osc_show_path = (char *)malloc(strlen(path) + 10);
+    sprintf(x->instances[instance].ui_osc_show_path, "%s/show", path);
+    
+    if (x->instances[instance].ui_osc_hide_path) 
+		free(x->instances[instance].ui_osc_hide_path); 
+    x->instances[instance].ui_osc_hide_path = (char *)malloc(strlen(path) + 10);
+    sprintf(x->instances[instance].ui_osc_hide_path, "%s/hide", path);
+
+    free((char *)path);
+
+    /* At this point a more substantial host might also call
+     * configure() on the UI to set any state that it had remembered
+     * for the plugin x.  But we don't remember state for
+     * plugin xs (see our own configure() implementation in
+     * osc_configure_handler), and so we have nothing to send except
+     * the optional project directory. */
+
+    if (x->dir) 
+	lo_send(x->instances[instance].uiTarget, x->instances[instance].ui_osc_configure_path, "ss",DSSI_PROJECT_DIRECTORY_KEY, x->dir);
+    
+
+    /* Send current bank/program  (-FIX- another race...) */
+	if (x->instances[instance].pendingProgramChange >= 0)
+		dssi_ProgramChange(x, instance);
+#if DEBUG
+	post("pendingProgramChange = %d", x->instances[instance].pendingProgramChange);
+#endif
+	if (x->instances[instance].pendingProgramChange < 0) {
+        unsigned long bank = x->instances[instance].currentBank;
+        unsigned long program = x->instances[instance].currentProgram;
+        x->instances[instance].uiNeedsProgramUpdate = 0;
+        if (x->instances[instance].uiTarget) {
+            lo_send(x->instances[instance].uiTarget, 
+					x->instances[instance].ui_osc_program_path, 
+					"ii", bank, program);
+        }
+    }
+
+    /* Send control ports */
+    for (i = 0; i < x->plugin_controlIns; i++) {
+	lo_send(x->instances[instance].uiTarget, x->instances[instance].ui_osc_control_path, "if", 
+			x->plugin_ControlInPortNumbers[i], x->plugin_ControlDataInput[i]);  
+#if DEBUG
+	post("Port: %d, Default value: %.2f", x->plugin_ControlInPortNumbers[i], x->plugin_ControlDataInput[i]);
+#endif
+    }
+
+/* Send 'show' */
+    if (x->instances[instance].ui_show) {
+        lo_send(x->instances[instance].uiTarget, x->instances[instance].ui_osc_show_path, "");
+        x->instances[instance].ui_hidden = 0;
+        x->instances[instance].ui_show = 0;
+    }
+
+
+
+    return 0;
+}
+
+static void dssi_osc_setup(t_dssi_tilde *x, int instance){
+
+	if(instance == 0){
+		x->osc_thread = lo_server_thread_new(NULL, osc_error);
+		char *osc_url_tmp;
+		osc_url_tmp = lo_server_thread_get_url(x->osc_thread);
+#if DEBUG
+		post("string length of osc_url_tmp:%d", strlen(osc_url_tmp));
+#endif
+		x->osc_url_base = (char *)malloc(sizeof(char) 
+				* (strlen(osc_url_tmp) + strlen("dssi") + 1)); 
+		sprintf(x->osc_url_base, "%s%s", osc_url_tmp, "dssi");
+		free(osc_url_tmp);
+		lo_server_thread_add_method(x->osc_thread, NULL, NULL, 
+				osc_message_handler, x);
+		lo_server_thread_start(x->osc_thread);
+	}
+	x->instances[instance].osc_url_path = (char *)malloc(sizeof(char) * 
+			(strlen(x->dll_name) + strlen(x->descriptor->LADSPA_Plugin->Label) + 			strlen("chan00") + 3));
+	sprintf(x->instances[instance].osc_url_path, "%s/%s/chan%02d", x->dll_name, 
+			x->descriptor->LADSPA_Plugin->Label, instance); 
+#if DEBUG
+post("OSC Path is: %s", x->instances[instance].osc_url_path);
+	post("OSC thread started: %s", x->osc_url_base);
+#endif
+}
+
+static void dssi_programs(t_dssi_tilde *x, int instance){
+
+#if DEBUG
+	post("Setting up program data");
+#endif
+	query_programs(x, instance);
+	if (x->descriptor->select_program &&
+			x->instances[instance].plugin_ProgramCount > 0) {
+
+		/* select program at index 0 */
+			unsigned long bank = 
+				x->instances[instance].pluginPrograms[0].Bank;
+			x->instances[instance].pendingBankMSB = bank / 128;
+			x->instances[instance].pendingBankLSB = bank % 128;
+			x->instances[instance].pendingProgramChange = 
+				x->instances[instance].pluginPrograms[0].Program;
+			x->instances[instance].uiNeedsProgramUpdate = 1;
+	}
+}
+
+static void dssi_load_gui(t_dssi_tilde *x, int instance){
+	t_int err = 0;
+    	char *osc_url;
+	char *gui_path;
+	struct dirent *dir_entry = NULL;
+	char *gui_base;
+	size_t baselen;
+	DIR *dp;
+	char *gui_str;
+	
+	gui_base = (char *)malloc(baselen = sizeof(char) * (strlen(x->dll_path) - strlen(".so")));
+
+	strncpy(gui_base, x->dll_path, baselen);
+/*	gui_base = strndup(x->dll_path, baselen);*/
+#if DEBUG
+post("gui_base: %s", gui_base);
+#endif
+
+	gui_str = (char *)malloc(sizeof(char) * (strlen("channel 00") + 1));
+	sprintf (gui_str,"channel %02d", instance);
+
+#if DEBUG
+	post("GUI name string, %s", gui_str);
+#endif
+
+	if(!(dp = opendir(gui_base))){
+		post("can't open %s, unable to find GUI", gui_base);
+		return;
+	}
+	else {
+		while((dir_entry = readdir(dp))){
+			if (dir_entry->d_name[0] == '.') continue;
+			break;
+		}
+#if DEBUG
+		post("GUI filename: %s", dir_entry->d_name);
+#endif
+	
+	}
+
+	gui_path = (char *)malloc(sizeof(char) * (strlen(gui_base) + strlen("/") + 
+				strlen(dir_entry->d_name) + 1));
+	
+
+	sprintf(gui_path, "%s/%s", gui_base, dir_entry->d_name);
+			
+	free(gui_base);
+#if DEBUG
+	post("gui_path: %s", gui_path);
+#endif
+	
+	osc_url = (char *)malloc
+		(sizeof(char) * (strlen(x->osc_url_base) + 
+						 strlen(x->instances[instance].osc_url_path) + 2));
+
+
+	
+
+	
+/*	char osc_url[1024];*/
+	sprintf(osc_url, "%s/%s", x->osc_url_base, 
+			x->instances[instance].osc_url_path);
+	post("Instance %d OSC URL is: %s",instance, osc_url);
+#if DEBUG
+	post("Trying to open GUI!");
+#endif
+	x->instances[instance].gui_pid = fork();
+	if (x->instances[instance].gui_pid == 0){
+		err = execlp(gui_path, gui_path, osc_url, dir_entry->d_name, 
+				x->descriptor->LADSPA_Plugin->Label, gui_str, NULL);
+	    perror("exec failed");
+		exit(1); /* terminates the process */ 
+	}
+
+#if DEBUG
+post("errorcode = %d", err);
+#endif
+
+	free(gui_path);
+	free(osc_url);
+	free(gui_str);
+	if(dp){
+
+#if DEBUG
+		post("directory handle closed = %d", closedir(dp));
+#endif
+	}
+}
+
+static void MIDIbuf(int type, int chan, int param, int val, t_dssi_tilde *x){
+
+
+	if(chan > x->n_instances - 1 || chan < 0){
+		post("Note discarded: MIDI data is destined for a channel that doesn't exist");
+		return;
+	}
+
+	
+	t_int time_ref = x->time_ref;
+	
+pthread_mutex_lock(&x->midiEventBufferMutex);
+	
+	x->midiEventBuf[x->bufWriteIndex].time.time.tv_sec = 
+		(t_int)(clock_gettimesince(time_ref) * .001); 
+	x->midiEventBuf[x->bufWriteIndex].time.time.tv_nsec = 
+		(t_int)(clock_gettimesince(time_ref) * 1000); /*actually usec - we can't store this in nsec! */
+	
+	if ((type == SND_SEQ_EVENT_NOTEON && val != 0) || 
+			type != SND_SEQ_EVENT_NOTEON) {
+		x->midiEventBuf[x->bufWriteIndex].type = type;
+		switch (type) {
+		case SND_SEQ_EVENT_NOTEON:
+			x->midiEventBuf[x->bufWriteIndex].data.note.channel = chan;
+			x->midiEventBuf[x->bufWriteIndex].data.note.note = param;
+			x->midiEventBuf[x->bufWriteIndex].data.note.velocity = val;
+			break;
+		case SND_SEQ_EVENT_NOTEOFF:
+			x->midiEventBuf[x->bufWriteIndex].data.note.channel = chan;
+			x->midiEventBuf[x->bufWriteIndex].data.note.note = param;
+			x->midiEventBuf[x->bufWriteIndex].data.note.velocity = val;
+			break;
+		case SND_SEQ_EVENT_CONTROLLER:
+			x->midiEventBuf[x->bufWriteIndex].data.control.channel = chan;
+			x->midiEventBuf[x->bufWriteIndex].data.control.param = param;
+			x->midiEventBuf[x->bufWriteIndex].data.control.value = val;
+			break;
+		case SND_SEQ_EVENT_PITCHBEND:
+			x->midiEventBuf[x->bufWriteIndex].data.control.channel = chan;
+			x->midiEventBuf[x->bufWriteIndex].data.control.param = 0;
+			x->midiEventBuf[x->bufWriteIndex].data.control.value = val;
+			break;
+		case SND_SEQ_EVENT_PGMCHANGE:
+			x->instances[chan].pendingBankMSB = (param - 1) / 128;
+			x->instances[chan].pendingBankLSB = (param - 1) % 128;
+			x->instances[chan].pendingProgramChange = val;
+			x->instances[chan].uiNeedsProgramUpdate = 1; 
+#if DEBUG
+			post("pgm chabge received in buffer: MSB: %d, LSB %d, prog: %d",
+					x->instances[chan].pendingBankMSB, x->instances[chan].pendingBankLSB, val);
+#endif
+			dssi_ProgramChange(x, chan);
+			break;
+		}
+	}
+	else if (type == SND_SEQ_EVENT_NOTEON && val == 0) {
+		x->midiEventBuf[x->bufWriteIndex].type = SND_SEQ_EVENT_NOTEOFF;
+		x->midiEventBuf[x->bufWriteIndex].data.note.channel = chan;
+		x->midiEventBuf[x->bufWriteIndex].data.note.note = param;
+		x->midiEventBuf[x->bufWriteIndex].data.note.velocity = val;
+	}
+
+#if DEBUG
+			post("MIDI received in buffer: chan %d, param %d, val %d",
+					chan, param, val);
+#endif
+	    x->bufWriteIndex = (x->bufWriteIndex + 1) % EVENT_BUFSIZE;
+    pthread_mutex_unlock(&x->midiEventBufferMutex); /**release mutex*/
+}
+
+static void dssi_show(t_dssi_tilde *x, t_int instance, t_int toggle){
+	if(x->instances[instance].uiTarget){
+		if (x->instances[instance].ui_hidden && toggle) {
+			lo_send(x->instances[instance].uiTarget, 
+				x->instances[instance].ui_osc_show_path, "");
+			x->instances[instance].ui_hidden = 0;
+		 }
+		else if (!x->instances[instance].ui_hidden && !toggle) {
+			lo_send(x->instances[instance].uiTarget, 
+				x->instances[instance].ui_osc_hide_path, "");
+			x->instances[instance].ui_hidden = 1;
+		}
+	}
+	else if(toggle){
+		x->instances[instance].ui_show = 1;
+		dssi_load_gui(x, instance);
+	}
+	/*	if(x->instances[instance].uiTarget){
+			lo_send(x->instances[instance].uiTarget, 
+				x->instances[instance].ui_osc_show_path, "");
+			x->instances[instance].ui_hidden = 0;
+		}
+	}*/
+
+}
+
+
+static void dssi_list(t_dssi_tilde *x, t_symbol *s, int argc, t_atom *argv) {
+	char *msg_type;
+	int ev_type = 0;
+	msg_type = (char *)malloc(TYPE_STRING_SIZE);
+	atom_string(argv, msg_type, TYPE_STRING_SIZE);
+	int chan = (int)atom_getfloatarg(1, argc, argv) - 1;
+	int param = (int)atom_getfloatarg(2, argc, argv);
+	int val = (int)atom_getfloatarg(3, argc, argv);
+	switch (msg_type[0]){
+		case ASCII_n: ev_type = SND_SEQ_EVENT_NOTEON;
+					  break;
+		case ASCII_c: ev_type = SND_SEQ_EVENT_CONTROLLER;
+					  break;
+		case ASCII_p: ev_type = SND_SEQ_EVENT_PGMCHANGE;
+					  break;
+		case ASCII_b: ev_type = SND_SEQ_EVENT_PITCHBEND;
+					  break;
+	}
+#if DEBUG
+	post("initial midi NOTE:, arg1 = %d, arg2 = %d, arg3 = %d, arg4 = %d",ev_type,chan,param,val);
+#endif
+	if(ev_type != 0){
+		MIDIbuf(ev_type, chan, param, val, x);
+	}
+	free(msg_type);
+}
+
+/* Method for list data through right inlet */
+/*FIX: rewrite at some point - this is bad*/
+static t_int dssi_config(t_dssi_tilde *x, t_symbol *s, int argc, t_atom *argv) {
+	char *msg_type, *debug, *filename, *key, *value;
+	msg_type = (char *)malloc(TYPE_STRING_SIZE);
+	int instance = -1, pathlen, toggle; 
+	int n_instances = x->n_instances;
+	int count, maxpatches;
+	t_float val;
+	long filelength = 0;
+	unsigned char *raw_patch_data = NULL;
+	FILE *fp;
+	size_t filename_length;
+	dx7_patch_t *patchbuf, *firstpatch;
+	atom_string(argv, msg_type, TYPE_STRING_SIZE);
+	debug = NULL;
+	key = NULL;	
+	value = NULL;
+	maxpatches = 128; 
+	patchbuf = malloc(32 * sizeof(dx7_patch_t));
+	firstpatch = &patchbuf[0];
+	val = 0;
+
+
+	/*FIX: Temporary - at the moment we always load the first 32 patches to 0 */
+	if(strcmp(msg_type, "configure")){
+		instance = (int)atom_getfloatarg(2, argc, argv) - 1;
+		
+
+
+	
+	
+/*	if(!strcmp(msg_type, "load") && x->descriptor->configure){
+		filename = argv[1].a_w.w_symbol->s_name;
+		instance = (int)atom_getfloatarg(2, argc, argv) - 1;
+		post("loading patch: %s for instance %d", filename, instance);
+		if(instance == -1){
+			while(n_instances--)		
+				debug = 
+				x->descriptor->configure(
+			x->instanceHandles[n_instances], "bank", filename);
+		
+		}
+		else{
+			debug = x->descriptor->configure(
+			x->instanceHandles[instance], "bank", filename);
+			dssi_programs(x, instance);
+			lo_send(x->instances[instance].uiTarget, 
+				x->instances[instance].ui_osc_program_path,"ii", 				0,0);
+			x->instances[instance].uiNeedsProgramUpdate = 0;
+		    	x->instances[instance].pendingProgramChange = -1;
+			x->instances[instance].pendingBankMSB = -1;
+			x->instances[instance].pendingBankLSB = -1;
+		}
+
+	}
+	
+*/
+	if(!strcmp(msg_type, "load") && x->descriptor->configure){
+		filename = argv[1].a_w.w_symbol->s_name;
+		key = malloc(10 * sizeof(char)); /* holds "patchesN" */
+		strcpy(key, "patches0");
+		post("loading patch: %s for instance %d", filename, instance);
+		fp = fopen(filename, "rb");
+		
+	/*From dx7_voice_data by Sean Bolton */
+		if(fp == NULL){
+			post("Unable to open patch file: %s", filename);
+			return 0;
+		}
+		if (fseek(fp, 0, SEEK_END) || 
+			(filelength = ftell(fp)) == -1 ||
+			fseek(fp, 0, SEEK_SET)) {
+				post("couldn't get length of patch file: %s", 
+					filename);
+			fclose(fp);
+			return 0;
+    		}
+		if (filelength == 0) {
+			post("patch file has zero length");
+			fclose(fp);
+			return 0;
+		} else if (filelength > 16384) {
+			post("patch file is too large");
+			fclose(fp);
+			return 0;
+		}
+		if (!(raw_patch_data = (unsigned char *)malloc(filelength))) 		     {
+			post("couldn't allocate memory for raw patch file");
+			fclose(fp);
+			return 0;
+		}
+		if (fread(raw_patch_data, 1, filelength, fp) 
+						!= (size_t)filelength) {
+			post("short read on patch file: %s", filename);
+			free(raw_patch_data);
+			fclose(fp);
+			return 0;
+	    	}
+		fclose(fp);
+	/* At the moment we only support Hexter patches */
+		if(strcmp(x->descriptor->LADSPA_Plugin->Label, "hexter"))
+			post("Sorry dssi~ only supports	dx7 patches at the moment.");
+		else{
+		 /* figure out what kind of file it is */
+		    filename_length = strlen(filename);
+		    if (filename_length > 4 &&
+			       !strcmp(filename + filename_length - 4, ".dx7") &&
+			       filelength % DX7_VOICE_SIZE_PACKED == 0) {  
+				/* It's a raw DX7 patch bank */
+
+			count = filelength / DX7_VOICE_SIZE_PACKED;
+			if (count > maxpatches)
+			    count = maxpatches;
+			memcpy(firstpatch, raw_patch_data, count * 
+				DX7_VOICE_SIZE_PACKED);
+
+		    } else if (filelength > 6 &&
+			       raw_patch_data[0] == 0xf0 &&
+			       raw_patch_data[1] == 0x43 &&
+			       (raw_patch_data[2] & 0xf0) == 0x00 &&
+			       raw_patch_data[3] == 0x09 &&
+			       (raw_patch_data[4] == 0x10 || 
+					raw_patch_data[4] == 0x20) &&  
+			   /* 0x10 is actual, 0x20 matches typo in manual */
+			       raw_patch_data[5] == 0x00) {  
+			    /* It's a DX7 sys-ex 32 voice dump */
+
+			if (filelength != DX7_DUMP_SIZE_BULK ||
+			    raw_patch_data[DX7_DUMP_SIZE_BULK - 1] != 0xf7) {
+			    post("badly formatted DX7 32 voice dump!");
+			    count = 0;
+		
+#ifdef CHECKSUM_PATCH_FILES_ON_LOAD
+			} else if (dx7_bulk_dump_checksum(&raw_patch_data[6],
+				DX7_VOICE_SIZE_PACKED * 32) !=
+				   raw_patch_data[DX7_DUMP_SIZE_BULK - 2]) {
+
+			    post("DX7 32 voice dump with bad checksum!");
+			    count = 0;
+
+#endif
+			} else {
+
+			    count = 32;
+			    if (count > maxpatches)
+				count = maxpatches;
+			    memcpy(firstpatch, raw_patch_data + 6, count * DX7_VOICE_SIZE_PACKED);
+
+			}
+		    } else {
+
+			/* unsuccessful load */
+			post("unknown patch bank file format!");
+			count = 0;
+
+		    }
+
+		    free(raw_patch_data);
+/*		    return count;*/
+		    
+		if(count == 32)
+ 		    value = encode_7in6((uint8_t *)&patchbuf[0].data[0], 
+					count * DX7_VOICE_SIZE_PACKED);
+	/*	    post("value = %s", value);	*/
+
+/*FIX: make this generic do key value pairs in one go at end of dssi_config after they have been determined */	
+
+				
+				
+	     }
+        }	
+	/*FIX: tidy up */
+	if(!strcmp(msg_type, "dir") && x->descriptor->configure){
+	/*	if(x->dir)
+			free(x->dir); *//*Should never happen */
+		pathlen = strlen(argv[1].a_w.w_symbol->s_name) + 2;
+		x->dir = malloc((pathlen) * sizeof(char));
+		atom_string(&argv[1], x->dir, pathlen);
+	/*	instance = (int)atom_getfloatarg(2, argc, argv) - 1;*/
+		post("Project directory for instance %d has been set to: %s", instance, x->dir);
+		key = DSSI_PROJECT_DIRECTORY_KEY;
+		value = x->dir;
+	}
+			/*	if(x->instances[instance].uiTarget)
+			post("uiTarget: %s",x->instances[instance].uiTarget);
+		if(x->instances[instance].ui_osc_configure_path)
+			post("osc_config_path: %s",x->instances[instance].ui_osc_configure_path);
+*//*		 lo_send(x->instances[instance].uiTarget, 
+			x->instances[instance].ui_osc_configure_path, 
+			"ss", DSSI_PROJECT_DIRECTORY_KEY, path);
+*/	
+
+	
+	else if(!strcmp(msg_type, "dir"))
+		post("%s %s: operation not supported", msg_type, 
+			argv[1].a_w.w_symbol->s_name);
+	
+	if(!strcmp(msg_type, "show") || !strcmp(msg_type, "hide")){
+		instance = (int)atom_getfloatarg(1, argc, argv) - 1;
+		if(!strcmp(msg_type, "show"))
+			toggle = 1;
+		else
+			toggle = 0;
+
+		if(instance == -1){
+			while(n_instances--)
+				dssi_show(x, n_instances, toggle);
+		}
+		else
+			dssi_show(x, instance, toggle);
+	  }
+	 if(!strcmp(msg_type, "reset")){
+		instance = (int)atom_getfloatarg(1, argc, argv) - 1;
+		if (instance == -1){
+			for(instance = 0; instance < x->n_instances; instance++) 			{
+			    if (x->descriptor->LADSPA_Plugin->deactivate &&
+				  x->descriptor->LADSPA_Plugin->activate){ 
+				x->descriptor->LADSPA_Plugin->deactivate
+				    (x->instanceHandles[instance]);
+				x->descriptor->LADSPA_Plugin->activate
+				    (x->instanceHandles[instance]);
+			    }
+			}
+		}
+		else if (x->descriptor->LADSPA_Plugin->deactivate && 
+			  x->descriptor->LADSPA_Plugin->activate) {
+			x->descriptor->LADSPA_Plugin->deactivate
+			    (x->instanceHandles[instance]);
+			x->descriptor->LADSPA_Plugin->activate
+			    (x->instanceHandles[instance]);
+		}
+        }
+    }
+
+
+	
+	/*Use this to send arbitrary configure message to plugin */
+	else if(!strcmp(msg_type, "configure")){
+		key = 
+		  malloc(strlen(argv[1].a_w.w_symbol->s_name) * sizeof(char)); 
+		atom_string(&argv[1], key, TYPE_STRING_SIZE);
+		
+		if (argv[2].a_type == A_FLOAT){
+			val = atom_getfloatarg(2, argc, argv);
+			value = malloc(TYPE_STRING_SIZE * sizeof(char));
+			sprintf(value, "%.2f", val);
+		}
+		else if(argv[2].a_type == A_SYMBOL){
+			value = 
+		         malloc(strlen(argv[2].a_w.w_symbol->s_name) * 
+					 sizeof(char)); 
+			atom_string(&argv[2], value, TYPE_STRING_SIZE);
+		}		
+		if(argv[3].a_type == A_FLOAT)
+			instance = atom_getfloatarg(3, argc, argv) - 1;
+	/*	else if(argv[3].a_type == A_SYMBOL)
+			post("Argument 4 should be an integer!");
+	*/
+	}
+
+	if(key != NULL && value != NULL){
+		if(instance == -1){
+			while(n_instances--){
+				debug = 
+				   x->descriptor->configure(
+				    x->instanceHandles[n_instances], 
+				     key, value);
+				/*FIX - sort out 'pending' system so that new GUI's for instances get updated */
+				if(x->instances[n_instances].uiTarget != NULL){
+	/*		if(!strcmp(msg_type, "load"))*/
+					lo_send(x->instances[n_instances].uiTarget, x->instances[n_instances].ui_osc_configure_path, "ss", key, value);
+					query_programs(x, n_instances);
+					/*FIX: better way to do this - OSC handler?*/
+	 			}
+			}
+		}
+		/*FIX: Put some error checking in here to make sure instance is valid*/
+		else{
+			debug = 
+			  x->descriptor->configure(
+			   x->instanceHandles[instance], 
+			    key, value);
+		/*	if(!strcmp(msg_type, "load"))*/
+			if(x->instances[n_instances].uiTarget != NULL)
+				lo_send(x->instances[instance].uiTarget, 
+				  x->instances[instance].ui_osc_configure_path,
+				   "ss", key, value);
+			query_programs(x, instance);
+		}
+	}
+#if DEBUG
+	post("The plugin returned %s", debug);
+#endif
+/*		if(debug != NULL)
+			free(debug);*/
+free(msg_type);
+free(patchbuf);
+free(value);
+
+if(key != NULL)
+	free(key);
+if(x->dir != NULL)
+	free(x->dir);
+return 0;
+	
+}
+
+static void dssi_bang(t_dssi_tilde *x)
+{
+	post("Running instances of %s", x->descriptor->LADSPA_Plugin->Label);
+}
+
+static t_int *dssi_tilde_perform(t_int *w)
+{
+	  int N = (int)(w[1]);
+	  t_dssi_tilde *x = (t_dssi_tilde *)(w[2]);
+	  int i, n, timediff, framediff, instance = 0; 
+ 
+	/*FIX -hmmm do we need this */
+	if(x->n_instances){
+	  for (i = 0; i < x->n_instances; i++)
+		  x->instanceEventCounts[i] = 0;
+	  
+	  /*Instances = (LADSPA_Handle *)malloc(sizeof(LADSPA_Handle));*/
+									
+	  for (;x->bufReadIndex != x->bufWriteIndex; x->bufReadIndex = 
+			  (x->bufReadIndex + 1) % EVENT_BUFSIZE) {
+			
+		    instance = x->midiEventBuf[x->bufReadIndex].data.note.channel;
+		    /*This should never happen, but check anyway*/
+		    if(instance > x->n_instances || instance < 0){
+				post("%s: discarding spurious MIDI data, for instance %d", x->descriptor->LADSPA_Plugin->Label, instance);
+#if DEBUG
+				post("n_instances = %d", x->n_instances);
+#endif
+				continue;
+			}
+			  
+			if (x->instanceEventCounts[instance] == EVENT_BUFSIZE){
+				post("MIDI overflow on channel %d", instance);
+				continue;
+			}
+			
+			timediff = (t_int)(clock_gettimesince(x->time_ref) * 1000) - 
+				 x->midiEventBuf[x->bufReadIndex].time.time.tv_nsec;
+			framediff = (t_int)((t_float)timediff * .000001 / x->sr_inv); 
+			
+			if (framediff >= N || framediff < 0) 
+				x->midiEventBuf[x->bufReadIndex].time.tick = 0;
+			else
+				x->midiEventBuf[x->bufReadIndex].time.tick = N - framediff - 1;
+			
+			x->instanceEventBuffers[instance][x->instanceEventCounts[instance]]
+				= x->midiEventBuf[x->bufReadIndex];
+#if DEBUG
+post("%s, note received on channel %d", x->descriptor->LADSPA_Plugin->Label, x->instanceEventBuffers[instance][x->instanceEventCounts[instance]].data.note.channel);
+#endif
+			x->instanceEventCounts[instance]++; 
+			
+#if DEBUG
+					post("Instance event count for instance %d of %d: %d\n",
+					instance + 1, x->n_instances, x->instanceEventCounts[instance]);
+#endif
+
+	  }
+
+	  	i = 0;
+		while(i < x->n_instances){
+			if(x->instanceHandles[i] && 
+					x->descriptor->run_multiple_synths){
+				  x->descriptor->run_multiple_synths
+					  (x->n_instances, x->instanceHandles, 
+					   (unsigned long)N, x->instanceEventBuffers,
+					   &x->instanceEventCounts[0]);
+				break; 
+			}
+			else if (x->instanceHandles[i]){
+				  x->descriptor->run_synth(x->instanceHandles[i], 
+						  (unsigned long)N, x->instanceEventBuffers[i],
+						  x->instanceEventCounts[i]); 
+				  i++;
+			}
+		}
+		
+		for(i = 0; i < x->n_instances; i++){
+/*			t_float *out = x->outlets[i];*/
+			for(n = 0; n < N; n++)
+				x->outlets[i][n] = x->plugin_OutputBuffers[i][n];
+/*				x->outlets[i][n] = 1;*/
+		}
+	}
+	return (w+3);
+}
+
+static void dssi_tilde_dsp(t_dssi_tilde *x, t_signal **sp)
+{
+	/*FIX -hmmm what's the best way to do this? */
+	if(x->n_instances){
+		int n;
+		t_float **outlets = x->outlets;
+
+		for(n = 0; n < x->n_instances; n++)
+			*outlets++ = sp[n+1]->s_vec;
+	}		
+	    dsp_add(dssi_tilde_perform, 2, sp[0]->s_n, x);
+	
+	
+}
+
+static void *dssi_tilde_new(t_symbol *s, t_int argc, t_atom *argv){
+
+	t_dssi_tilde *x = (t_dssi_tilde *)pd_new(dssi_tilde_class);
+	post("dssi~ %.2f\n a DSSI host for Pure Data\n by Jamie Bullock\nIncluding Code from jack-dssi-host\n by Chris Cannam, Steve Harris and Sean Bolton", VERSION);
+	
+    if (argc){
+	int i, stop = 0;
+	
+
+	/*x->midiEventBufferMutex = PTHREAD_MUTEX_INITIALIZER;
+	*/
+
+	pthread_mutex_init(&x->midiEventBufferMutex, NULL);
+	
+	x->sr = (t_int)sys_getsr();
+	x->sr_inv = 1 / (t_float)x->sr;
+
+	x->dir = NULL;
+	x->bufWriteIndex = x->bufReadIndex = 0;
+	
+	x->dll_name = (char *)malloc(sizeof(char) * 8);/* HARD CODED! */
+	sprintf(x->dll_name, "%s", "plugin");       /* for now - Fix! */
+	
+	if(argc >= 2)
+		x->n_instances = (t_int)argv[1].a_w.w_float;
+	else
+		x->n_instances = 1;
+	
+	x->instances = (t_dssi_instance *)malloc(sizeof(t_dssi_instance) * 
+			x->n_instances);
+	
+#if DEBUG
+	post("sr_inv = %.6f", x->sr_inv);
+#endif
+	x->time_ref = (t_int)clock_getlogicaltime;
+	x->blksize = sys_getblksize();
+	x->ports_in = x->ports_out = x->ports_controlIn = x->ports_controlOut = 0;
+	
+		x->dll_path = argv[0].a_w.w_symbol->s_name;
+		dssi_load(x->dll_path, &x->dll_handle);
+		if (x->dll_handle){
+			x->desc_func = (DSSI_Descriptor_Function)dlsym(x->dll_handle, 
+					"dssi_descriptor");
+			if(x->descriptor = x->desc_func(0)){
+#if DEBUG
+				post("%s loaded successfully!", 
+						x->descriptor->LADSPA_Plugin->Label);
+#endif
+				portInfo(x);
+				dssi_assignPorts(x);
+				for(i = 0; i < x->n_instances; i++){
+					x->instanceHandles[i] = x->descriptor->LADSPA_Plugin->instantiate(x->descriptor->LADSPA_Plugin, x->sr);
+					if (!x->instanceHandles[i]){
+						post("instantiation of instance %d failed", i);
+						stop = 1;
+						break;
+					}
+				}
+				if(!stop){
+					for(i = 0;i < x->n_instances; i++)
+						dssi_init(x, i);
+					for(i = 0;i < x->n_instances; i++)
+						dssi_connectPorts(x, i); /* fix this */
+					for(i = 0;i < x->n_instances; i++)
+						dssi_osc_setup(x, i);
+					for(i = 0;i < x->n_instances; i++)
+						dssi_activate(x, i);
+					for(i = 0;i < x->n_instances; i++)
+						dssi_programs(x, i);
+#if LOADGUI
+					for(i = 0;i < x->n_instances; i++)
+						dssi_load_gui(x, i);
+#endif
+					for(i = 0;i < x->n_instances; i++)
+						outlet_new(&x->x_obj, &s_signal);
+					
+					x->outlets = (t_float **)calloc(x->n_instances, 
+							sizeof(t_float *));
+				}
+			}
+
+			/*Create right inlet for configuration messages */
+			inlet_new(&x->x_obj, &x->x_obj.ob_pd, 
+					&s_list, gensym("config"));
+		}
+	
+		else
+			post("unknown error");
+	}
+	else
+		post("No arguments given, please supply a path");
+  return (void *)x;
+}
+
+static void dssi_free(t_dssi_tilde *x){
+
+t_int instance;
+  for(instance = 0; instance < x->n_instances; instance++) {
+        /* no -- see comment in osc_exiting_handler */
+        /* if (!instances[i].inactive) { */
+            if (x->descriptor->LADSPA_Plugin->deactivate) {
+                x->descriptor->LADSPA_Plugin->deactivate
+                    (x->instanceHandles[instance]);
+            }
+        /* } */
+        if (x->descriptor->LADSPA_Plugin &&
+            x->descriptor->LADSPA_Plugin->cleanup) {
+            x->descriptor->LADSPA_Plugin->cleanup
+                (x->instanceHandles[instance]);
+        }
+    }
+
+	
+#if DEBUG
+		  post("Calling dssi_free");
+#endif
+ if(x->dll_handle){ 
+	instance = x->n_instances;
+	free((LADSPA_Handle)x->instanceHandles);
+	  free(x->plugin_ControlInPortNumbers); 
+	  free((t_float *)x->plugin_InputBuffers);
+	  free((t_float *)x->plugin_OutputBuffers);
+	  free((snd_seq_event_t *)x->instanceEventBuffers);
+	  free(x->instanceEventCounts);
+	  free(x->plugin_ControlDataInput);
+	  free(x->plugin_ControlDataOutput);
+
+	  while(instance--){
+		if(x->instances[instance].gui_pid){
+#if DEBUG
+		  post("Freeing GUI process PID = %d", x->instances[instance].gui_pid);
+#endif
+			kill(x->instances[instance].gui_pid, SIGKILL);
+		} 
+		  free(x->instances[instance].ui_osc_control_path);
+		  free(x->instances[instance].ui_osc_configure_path);
+		  free(x->instances[instance].ui_osc_program_path);
+		  free(x->instances[instance].ui_osc_show_path);
+		  free(x->instances[instance].ui_osc_hide_path);
+		  free(x->instances[instance].osc_url_path);
+		  free(x->instances[instance].plugin_PortControlInNumbers);
+	  }
+	  free((t_float *)x->outlets);
+	  free(x->osc_url_base);
+	  free(x->dll_name);
+ }
+}
+
+
+
+void dssi_tilde_setup(void) {
+	
+	dssi_tilde_class = class_new(gensym("dssi~"), (t_newmethod)dssi_tilde_new,(t_method)dssi_free, sizeof(t_dssi_tilde), 0, A_GIMME, 0);
+	class_addlist(dssi_tilde_class, dssi_list);
+	class_addbang(dssi_tilde_class, dssi_bang);
+  class_addmethod(dssi_tilde_class, (t_method)dssi_tilde_dsp, gensym("dsp"), 0);
+	class_addmethod(dssi_tilde_class, (t_method)dssi_config, 
+			gensym("config"), A_GIMME, 0);
+  	class_sethelpsymbol(dssi_tilde_class, gensym("help-dssi"));
+  CLASS_MAINSIGNALIN(dssi_tilde_class, t_dssi_tilde,f);
+}
+
+static int osc_message_handler(const char *path, const char *types, 
+		lo_arg **argv,int argc, void *data, void *user_data)
+{
+#if DEBUG
+	post("osc_message_handler active");
+#endif
+    int i, instance = 0;
+    const char *method;
+	char chantemp[2];
+	t_dssi_tilde *x = (t_dssi_tilde *)(user_data);
+	
+    if (strncmp(path, "/dssi/", 6)){
+#if DEBUG
+		post("calling osc_debug_handler"); 
+#endif
+        return osc_debug_handler(path, types, argv, argc, data, x);
+	}
+	for (i = 0; i < x->n_instances; i++) {
+		if (!strncmp(path + 6, x->instances[i].osc_url_path,
+					 strlen(x->instances[i].osc_url_path))) {
+			instance = i;
+			break;
+		}
+	}
+#if DEBUG
+	for(i = 0; i < argc; i++){
+		post("got osc request %c from instance %d, path: %s", 
+			types[i],instance,path);
+	}
+#endif
+	
+    if (!x->instances[instance].osc_url_path){
+#if DEBUG
+		post("calling osc_debug_handler"); 
+#endif
+        return osc_debug_handler(path, types, argv, argc, data, x);
+	}
+    method = path + 6 + strlen(x->instances[instance].osc_url_path);
+    if (*method != '/' || *(method + 1) == 0){
+#if DEBUG
+		post("calling osc_debug_handler"); 
+#endif
+        return osc_debug_handler(path, types, argv, argc, data, x);
+	}
+    method++;
+
+    if (!strcmp(method, "configure") && argc == 2 && !strcmp(types, "ss")) {
+
+#if DEBUG
+		post("calling osc_configure_handler");
+#endif
+        return osc_configure_handler(x, argv, instance);
+
+    } else if (!strcmp(method, "control") && argc == 2 && !strcmp(types, "if")) {
+#if DEBUG
+		post("calling osc_control_handler");
+#endif
+        return osc_control_handler(x, argv, instance);
+	}
+
+     else if (!strcmp(method, "midi") && argc == 1 && !strcmp(types, "m")) {
+		
+#if DEBUG
+		post("calling osc_midi_handler");
+#endif
+        return osc_midi_handler(x, argv, instance);
+
+    } else if (!strcmp(method, "program") && argc == 2 && !strcmp(types, "ii")){
+#if DEBUG
+		post("calling osc_program_handler"); 
+#endif
+        return osc_program_handler(x, argv, instance);
+
+    } else if (!strcmp(method, "update") && argc == 1 && !strcmp(types, "s")){
+#if DEBUG
+		post("calling osc_update_handler"); 
+#endif
+        return osc_update_handler(x, argv, instance);
+	
+
+    } else if (!strcmp(method, "exiting") && argc == 0) {
+
+        return osc_exiting_handler(x, argv, instance);
+    }
+
+    return osc_debug_handler(path, types, argv, argc, data, x);
+}
+
diff --git a/dssi/src/dssi~.h b/dssi/src/dssi~.h
new file mode 100644
index 0000000..8f82772
--- /dev/null
+++ b/dssi/src/dssi~.h
@@ -0,0 +1,57 @@
+/* dssi~ - A DSSI host for PD 
+ * 
+ * Copyright 2006 Jamie Bullock and others 
+ *
+ * This file incorporates code from the following sources:
+ * 
+ * jack-dssi-host (BSD-style license): Copyright 2004 Chris Cannam, Steve Harris and Sean Bolton.
+ *		   
+ * Hexter (GPL license): Copyright (C) 2004 Sean Bolton and others.
+ * 
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*/
+
+#include "m_pd.h"
+#include "dssi.h"
+#include <dlfcn.h>
+#include <lo/lo.h> 
+#include <unistd.h>
+#include <stdio.h>
+#define __USE_GNU /* for strndup */
+#include <string.h>
+
+#include <stdlib.h> /*for exit()*/
+#include <sys/types.h> /* for fork() */
+#include <signal.h> /* for kill() */
+#include <dirent.h> /* for readdir() */
+
+#define DX7_VOICE_SIZE_PACKED 	128 /*From hexter_types.h by Sean Bolton */
+#define DX7_DUMP_SIZE_BULK 	4096+8
+
+
+#define VERSION 0.8
+#define EVENT_BUFSIZE 1024
+#define OSC_BASE_MAX 1024
+#define TYPE_STRING_SIZE 20 /* Max size of event type string (must be two more bytes than needed) */
+#define DIR_STRING_SIZE 1024 /* Max size of directory string */
+#define ASCII_n 110
+#define ASCII_p 112
+#define ASCII_c 99
+#define ASCII_b 98
+
+#define LOADGUI 1 /* FIX: depracate this */
+#define DEBUG 0
+