Add 'blip', an LV2 port of the LADSPA 'blop' collection.

git-svn-id: http://svn.drobilla.net/lad/trunk/plugins/blip.lv2@3525 a436a847-0d15-0410-975c-d299462d15a1

1 files changed, 685 insertions, 0 deletions

diff --git a/src/dahdsr.c b/src/dahdsr.c
new file mode 100644
index 0000000..01115bb
--- /dev/null
+++ b/src/dahdsr.c
@@ -0,0 +1,685 @@
+/*
+  An LV2 plugin to generate DAHDSR envelopes Gate and (re)trigger
+  Copyright 2011 David Robillard
+  Copyright 2004 Mike Rawes
+
+  This 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 3 of the License, or
+  (at your option) any later version.
+
+  This software 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 software.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdlib.h>
+#include "lv2/lv2plug.in/ns/lv2core/lv2.h"
+#include "common.h"
+
+#define DAHDSR_GATE    0
+#define DAHDSR_TRIGGER 1
+#define DAHDSR_DELAY   2
+#define DAHDSR_ATTACK  3
+#define DAHDSR_HOLD    4
+#define DAHDSR_DECAY   5
+#define DAHDSR_SUSTAIN 6
+#define DAHDSR_RELEASE 7
+#define DAHDSR_OUTPUT  8
+
+typedef enum {
+	IDLE,
+	DELAY,
+	ATTACK,
+	HOLD,
+	DECAY,
+	SUSTAIN,
+	RELEASE
+} DAHDSRState;
+
+typedef struct {
+	float*      gate;
+	float*      trigger;
+	float*      delay;
+	float*      attack;
+	float*      hold;
+	float*      decay;
+	float*      sustain;
+	float*      release;
+	float*      output;
+	float       srate;
+	float       inv_srate;
+	float       last_gate;
+	float       last_trigger;
+	float       from_level;
+	float       level;
+	DAHDSRState state;
+	uint32_t    samples;
+} Dahdsr;
+
+static void
+cleanup(LV2_Handle instance)
+{
+	free(instance);
+}
+
+static void
+connect_port(LV2_Handle instance,
+             uint32_t   port,
+             void*      data)
+{
+	Dahdsr* plugin = (Dahdsr*)instance;
+
+	switch (port) {
+	case DAHDSR_GATE:
+		plugin->gate = data;
+		break;
+	case DAHDSR_TRIGGER:
+		plugin->trigger = data;
+		break;
+	case DAHDSR_DELAY:
+		plugin->delay = data;
+		break;
+	case DAHDSR_ATTACK:
+		plugin->attack = data;
+		break;
+	case DAHDSR_HOLD:
+		plugin->hold = data;
+		break;
+	case DAHDSR_DECAY:
+		plugin->decay = data;
+		break;
+	case DAHDSR_SUSTAIN:
+		plugin->sustain = data;
+		break;
+	case DAHDSR_RELEASE:
+		plugin->release = data;
+		break;
+	case DAHDSR_OUTPUT:
+		plugin->output = data;
+		break;
+	}
+}
+
+static LV2_Handle
+instantiate(const LV2_Descriptor*     descriptor,
+            double                    sample_rate,
+            const char*               bundle_path,
+            const LV2_Feature* const* features)
+{
+	Dahdsr* plugin = (Dahdsr*)malloc(sizeof(Dahdsr));
+
+	plugin->srate     = (float)sample_rate;
+	plugin->inv_srate = 1.0f / plugin->srate;
+
+	return (LV2_Handle)plugin;
+}
+
+static void
+activate(LV2_Handle instance)
+{
+	Dahdsr* plugin = (Dahdsr*)instance;
+
+	plugin->last_gate    = 0.0f;
+	plugin->last_trigger = 0.0f;
+	plugin->from_level   = 0.0f;
+	plugin->level        = 0.0f;
+	plugin->state        = IDLE;
+	plugin->samples      = 0;
+}
+
+static void
+runDahdsr_Audio(LV2_Handle instance,
+                uint32_t   sample_count)
+{
+	Dahdsr* plugin = (Dahdsr*)instance;
+
+	/* Gate */
+	float* gate = plugin->gate;
+
+	/* Trigger */
+	float* trigger = plugin->trigger;
+
+	/* Delay Time (s) */
+	float* delay = plugin->delay;
+
+	/* Attack Time (s) */
+	float* attack = plugin->attack;
+
+	/* Hold Time (s) */
+	float* hold = plugin->hold;
+
+	/* Decay Time (s) */
+	float* decay = plugin->decay;
+
+	/* Sustain Level */
+	float* sustain = plugin->sustain;
+
+	/* Release Time (s) */
+	float* release = plugin->release;
+
+	/* Envelope Out */
+	float* output = plugin->output;
+
+	/* Instance Data */
+	float       srate        = plugin->srate;
+	float       inv_srate    = plugin->inv_srate;
+	float       last_gate    = plugin->last_gate;
+	float       last_trigger = plugin->last_trigger;
+	float       from_level   = plugin->from_level;
+	float       level        = plugin->level;
+	DAHDSRState state        = plugin->state;
+	uint32_t    samples      = plugin->samples;
+
+	float gat, trg, del, att, hld, dec, sus, rel;
+	float elapsed;
+
+	for (uint32_t s = 0; s < sample_count; ++s) {
+		/* Convert times into rates */
+		del = delay[s] > 0.0f ? inv_srate / delay[s] : srate;
+		att = attack[s] > 0.0f ? inv_srate / attack[s] : srate;
+		hld = hold[s] > 0.0f ? inv_srate / hold[s] : srate;
+		dec = decay[s] > 0.0f ? inv_srate / decay[s] : srate;
+		rel = release[s] > 0.0f ? inv_srate / release[s] : srate;
+
+		gat = gate[s];
+		trg = trigger[s];
+		sus = f_clip(sustain[s], 0.0f, 1.0f);
+
+		/* Initialise delay phase if gate is opened and was closed, or
+		   we received a trigger */
+		if ((trg > 0.0f && !(last_trigger > 0.0f))
+		    || (gat > 0.0f && !(last_gate > 0.0f))) {
+			if (del < srate) {
+				state = DELAY;
+			} else if (att < srate) {
+				state = ATTACK;
+			} else {
+				state = hld < srate ? HOLD
+					: (dec < srate ? DECAY
+					   : (gat > 0.0f ? SUSTAIN
+						  : (rel < srate ? RELEASE
+							 : IDLE)));
+				level = 1.0f;
+			}
+			samples = 0;
+		}
+
+		/* Release if gate was open and now closed */
+		if (state != IDLE && state != RELEASE
+		    && last_gate > 0.0f && !(gat > 0.0f)) {
+			state   = rel < srate ? RELEASE : IDLE;
+			samples = 0;
+		}
+
+		if (samples == 0) {
+			from_level = level;
+		}
+
+		/* Calculate level of envelope from current state */
+		switch (state) {
+		case IDLE:
+			level = 0;
+			break;
+		case DELAY:
+			samples++;
+			elapsed = (float)samples * del;
+			if (elapsed > 1.0f) {
+				state = att < srate ? ATTACK
+					: (hld < srate ? HOLD
+					   : (dec < srate ? DECAY
+						  : (gat > 0.0f ? SUSTAIN
+							 : (rel < srate ? RELEASE
+								: IDLE))));
+				samples = 0;
+			}
+			break;
+		case ATTACK:
+			samples++;
+			elapsed = (float)samples * att;
+			if (elapsed > 1.0f) {
+				state = hld < srate ? HOLD
+					: (dec < srate ? DECAY
+					   : (gat > 0.0f ? SUSTAIN
+						  : (rel < srate ? RELEASE
+							 : IDLE)));
+				level   = 1.0f;
+				samples = 0;
+			} else {
+				level = from_level + elapsed * (1.0f - from_level);
+			}
+			break;
+		case HOLD:
+			samples++;
+			elapsed = (float)samples * hld;
+			if (elapsed > 1.0f) {
+				state = dec < srate ? DECAY
+					: (gat > 0.0f ? SUSTAIN
+					   : (rel < srate ? RELEASE
+						  : IDLE));
+				samples = 0;
+			}
+			break;
+		case DECAY:
+			samples++;
+			elapsed = (float)samples * dec;
+			if (elapsed > 1.0f) {
+				state = gat > 0.0f ? SUSTAIN
+					: (rel < srate ? RELEASE
+					   : IDLE);
+				level   = sus;
+				samples = 0;
+			} else {
+				level = from_level + elapsed * (sus - from_level);
+			}
+			break;
+		case SUSTAIN:
+			level = sus;
+			break;
+		case RELEASE:
+			samples++;
+			elapsed = (float)samples * rel;
+			if (elapsed > 1.0f) {
+				state   = IDLE;
+				level   = 0.0f;
+				samples = 0;
+			} else {
+				level = from_level - elapsed * from_level;
+			}
+			break;
+		default:
+			/* Should never happen */
+			level = 0.0f;
+		}
+
+		output[s] = level;
+
+		last_gate    = gate[s];
+		last_trigger = trigger[s];
+	}
+
+	plugin->last_gate    = last_gate;
+	plugin->last_trigger = last_trigger;
+	plugin->from_level   = from_level;
+	plugin->level        = level;
+	plugin->state        = state;
+	plugin->samples      = samples;
+}
+
+static void
+runDahdsr_Control(LV2_Handle instance,
+                  uint32_t   sample_count)
+{
+	Dahdsr* plugin = (Dahdsr*)instance;
+
+	/* Gate */
+	float* gate = plugin->gate;
+
+	/* Trigger */
+	float* trigger = plugin->trigger;
+
+	/* Delay Time (s) */
+	float delay = *(plugin->delay);
+
+	/* Attack Time (s) */
+	float attack = *(plugin->attack);
+
+	/* Hold Time (s) */
+	float hold = *(plugin->hold);
+
+	/* Decay Time (s) */
+	float decay = *(plugin->decay);
+
+	/* Sustain Level */
+	float sustain = *(plugin->sustain);
+
+	/* Release Time (s) */
+	float release = *(plugin->release);
+
+	/* Envelope Out */
+	float* output = plugin->output;
+
+	/* Instance Data */
+	float       srate        = plugin->srate;
+	float       inv_srate    = plugin->inv_srate;
+	float       last_gate    = plugin->last_gate;
+	float       last_trigger = plugin->last_trigger;
+	float       from_level   = plugin->from_level;
+	float       level        = plugin->level;
+	DAHDSRState state        = plugin->state;
+	uint32_t    samples      = plugin->samples;
+
+	float gat, trg, del, att, hld, dec, sus, rel;
+	float elapsed;
+
+	/* Convert times into rates */
+	del = delay > 0.0f ? inv_srate / delay : srate;
+	att = attack > 0.0f ? inv_srate / attack : srate;
+	hld = hold > 0.0f ? inv_srate / hold : srate;
+	dec = decay > 0.0f ? inv_srate / decay : srate;
+	rel = release > 0.0f ? inv_srate / release : srate;
+
+	sus = f_clip(sustain, 0.0f, 1.0f);
+
+	for (uint32_t s = 0; s < sample_count; ++s) {
+		gat = gate[s];
+		trg = trigger[s];
+
+		/* Initialise delay phase if gate is opened and was closed, or
+		   we received a trigger */
+		if ((trg > 0.0f && !(last_trigger > 0.0f))
+		    || (gat > 0.0f && !(last_gate > 0.0f))) {
+			if (del < srate) {
+				state = DELAY;
+			} else if (att < srate) {
+				state = ATTACK;
+			} else {
+				state = hld < srate ? HOLD
+					: (dec < srate ? DECAY
+					   : (gat > 0.0f ? SUSTAIN
+						  : (rel < srate ? RELEASE
+							 : IDLE)));
+				level = 1.0f;
+			}
+			samples = 0;
+		}
+
+		/* Release if gate was open and now closed */
+		if (state != IDLE && state != RELEASE
+		    && last_gate > 0.0f && !(gat > 0.0f)) {
+			state   = rel < srate ? RELEASE : IDLE;
+			samples = 0;
+		}
+
+		if (samples == 0) {
+			from_level = level;
+		}
+
+		/* Calculate level of envelope from current state */
+		switch (state) {
+		case IDLE:
+			level = 0;
+			break;
+		case DELAY:
+			samples++;
+			elapsed = (float)samples * del;
+			if (elapsed > 1.0f) {
+				state = att < srate ? ATTACK
+					: (hld < srate ? HOLD
+					   : (dec < srate ? DECAY
+						  : (gat > 0.0f ? SUSTAIN
+							 : (rel < srate ? RELEASE
+								: IDLE))));
+				samples = 0;
+			}
+			break;
+		case ATTACK:
+			samples++;
+			elapsed = (float)samples * att;
+			if (elapsed > 1.0f) {
+				state = hld < srate ? HOLD
+					: (dec < srate ? DECAY
+					   : (gat > 0.0f ? SUSTAIN
+						  : (rel < srate ? RELEASE
+							 : IDLE)));
+				level   = 1.0f;
+				samples = 0;
+			} else {
+				level = from_level + elapsed * (1.0f - from_level);
+			}
+			break;
+		case HOLD:
+			samples++;
+			elapsed = (float)samples * hld;
+			if (elapsed > 1.0f) {
+				state = dec < srate ? DECAY
+					: (gat > 0.0f ? SUSTAIN
+					   : (rel < srate ? RELEASE
+						  : IDLE));
+				samples = 0;
+			}
+			break;
+		case DECAY:
+			samples++;
+			elapsed = (float)samples * dec;
+			if (elapsed > 1.0f) {
+				state = gat > 0.0f ? SUSTAIN
+					: (rel < srate ? RELEASE
+					   : IDLE);
+				level   = sus;
+				samples = 0;
+			} else {
+				level = from_level + elapsed * (sus - from_level);
+			}
+			break;
+		case SUSTAIN:
+			level = sus;
+			break;
+		case RELEASE:
+			samples++;
+			elapsed = (float)samples * rel;
+			if (elapsed > 1.0f) {
+				state   = IDLE;
+				level   = 0.0f;
+				samples = 0;
+			} else {
+				level = from_level - elapsed * from_level;
+			}
+			break;
+		default:
+			/* Should never happen */
+			level = 0.0f;
+		}
+
+		output[s] = level;
+
+		last_gate    = gat;
+		last_trigger = trg;
+	}
+
+	plugin->last_gate    = last_gate;
+	plugin->last_trigger = last_trigger;
+	plugin->from_level   = from_level;
+	plugin->level        = level;
+	plugin->state        = state;
+	plugin->samples      = samples;
+}
+
+static void
+runDahdsr_CGT_Control(LV2_Handle instance,
+                      uint32_t   sample_count)
+{
+	Dahdsr* plugin = (Dahdsr*)instance;
+
+	/* Gate */
+	float gate = *(plugin->gate);
+
+	/* Trigger */
+	float trigger = *(plugin->trigger);
+
+	/* Delay Time (s) */
+	float delay = *(plugin->delay);
+
+	/* Attack Time (s) */
+	float attack = *(plugin->attack);
+
+	/* Hold Time (s) */
+	float hold = *(plugin->hold);
+
+	/* Decay Time (s) */
+	float decay = *(plugin->decay);
+
+	/* Sustain Level */
+	float sustain = *(plugin->sustain);
+
+	/* Release Time (s) */
+	float release = *(plugin->release);
+
+	/* Envelope Out */
+	float* output = plugin->output;
+
+	/* Instance Data */
+	float       srate        = plugin->srate;
+	float       inv_srate    = plugin->inv_srate;
+	float       last_gate    = plugin->last_gate;
+	float       last_trigger = plugin->last_trigger;
+	float       from_level   = plugin->from_level;
+	float       level        = plugin->level;
+	DAHDSRState state        = plugin->state;
+	uint32_t    samples      = plugin->samples;
+
+	float gat, trg, del, att, hld, dec, sus, rel;
+	float elapsed;
+
+	/* Convert times into rates */
+	del = delay > 0.0f ? inv_srate / delay : srate;
+	att = attack > 0.0f ? inv_srate / attack : srate;
+	hld = hold > 0.0f ? inv_srate / hold : srate;
+	dec = decay > 0.0f ? inv_srate / decay : srate;
+	rel = release > 0.0f ? inv_srate / release : srate;
+
+	gat = gate;
+	trg = trigger;
+	sus = f_clip(sustain, 0.0f, 1.0f);
+
+	/* Initialise delay phase if gate is opened and was closed, or
+	   we received a trigger */
+	if ((trg > 0.0f && !(last_trigger > 0.0f))
+	    || (gat > 0.0f && !(last_gate > 0.0f))) {
+		if (del < srate) {
+			state = DELAY;
+		} else if (att < srate) {
+			state = ATTACK;
+		} else {
+			state = hld < srate ? HOLD
+				: (dec < srate ? DECAY
+				   : (gat > 0.0f ? SUSTAIN
+					  : (rel < srate ? RELEASE
+						 : IDLE)));
+			level = 1.0f;
+		}
+		samples = 0;
+	}
+
+	/* Release if gate was open and now closed */
+	if (state != IDLE && state != RELEASE
+	    && last_gate > 0.0f && !(gat > 0.0f)) {
+		state   = rel < srate ? RELEASE : IDLE;
+		samples = 0;
+	}
+
+	for (uint32_t s = 0; s < sample_count; ++s) {
+		if (samples == 0) {
+			from_level = level;
+		}
+
+		/* Calculate level of envelope from current state */
+		switch (state) {
+		case IDLE:
+			level = 0;
+			break;
+		case DELAY:
+			samples++;
+			elapsed = (float)samples * del;
+			if (elapsed > 1.0f) {
+				state = att < srate ? ATTACK
+					: (hld < srate ? HOLD
+					   : (dec < srate ? DECAY
+						  : (gat > 0.0f ? SUSTAIN
+							 : (rel < srate ? RELEASE
+								: IDLE))));
+				samples = 0;
+			}
+			break;
+		case ATTACK:
+			samples++;
+			elapsed = (float)samples * att;
+			if (elapsed > 1.0f) {
+				state = hld < srate ? HOLD
+					: (dec < srate ? DECAY
+					   : (gat > 0.0f ? SUSTAIN
+						  : (rel < srate ? RELEASE
+							 : IDLE)));
+				level   = 1.0f;
+				samples = 0;
+			} else {
+				level = from_level + elapsed * (1.0f - from_level);
+			}
+			break;
+		case HOLD:
+			samples++;
+			elapsed = (float)samples * hld;
+			if (elapsed > 1.0f) {
+				state = dec < srate ? DECAY
+					: (gat > 0.0f ? SUSTAIN
+					   : (rel < srate ? RELEASE
+						  : IDLE));
+				samples = 0;
+			}
+			break;
+		case DECAY:
+			samples++;
+			elapsed = (float)samples * dec;
+			if (elapsed > 1.0f) {
+				state = gat > 0.0f ? SUSTAIN
+					: (rel < srate ? RELEASE
+					   : IDLE);
+				level   = sus;
+				samples = 0;
+			} else {
+				level = from_level + elapsed * (sus - from_level);
+			}
+			break;
+		case SUSTAIN:
+			level = sus;
+			break;
+		case RELEASE:
+			samples++;
+			elapsed = (float)samples * rel;
+			if (elapsed > 1.0f) {
+				state   = IDLE;
+				level   = 0.0f;
+				samples = 0;
+			} else {
+				level = from_level - elapsed * from_level;
+			}
+			break;
+		default:
+			/* Should never happen */
+			level = 0.0f;
+		}
+
+		output[s] = level;
+	}
+
+	plugin->last_gate    = gat;
+	plugin->last_trigger = trg;
+	plugin->from_level   = from_level;
+	plugin->level        = level;
+	plugin->state        = state;
+	plugin->samples      = samples;
+}
+
+static const LV2_Descriptor descriptor = {
+	"http://drobilla.net/plugins/blip/dahdsr",
+	instantiate,
+	connect_port,
+	activate,
+	runDahdsr_Control,
+	NULL,
+	cleanup,
+	NULL,
+};
+
+LV2_SYMBOL_EXPORT const LV2_Descriptor*
+lv2_descriptor(uint32_t index)
+{
+	switch (index) {
+	case 0:  return &descriptor;
+	default: return NULL;
+	}
+}