Attached is the new ADSR module. Features: - pretty fast - pretty stable, judging from first tests - should be easy to debug and maintain, thanks to clean structure - Attack, Decay, Release times settable from 0.4 ms to 25 s (log-scale) - Sustain level settable from 0 to 100% (of course) - nothing fancy here- Fade to 0% / 100% instead of Sustain- like in some popular hardware virtual analogues (cough cough) - settable cleanup time (delay before Synth Done signal is emitted, to account for additional delays/choruses/flangers/filters in synth output etc) - configurable behaviour for notes released before attack+decay ends (to avoid situations like when a long release starts from 100% instead of desired 10% just because someone released a key too early, before decay phase was over)
Of course you need to add it to Makefile / Makefile.plugins in order to get it to work. Sorry about that.
Any comments? -- Krzysztof Foltman
Index: bsemodernadsr.cc =================================================================== --- bsemodernadsr.cc (revision 0) +++ bsemodernadsr.cc (revision 0) @@ -0,0 +1,262 @@ +/* BSE - Bedevilled Sound Engine + * Copyright (C) 2003 Tim Janik + * Modern ADSR envelope + * Copyright (C) 2007 Krzysztof Foltman + * + * 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 library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * A copy of the GNU Lesser General Public License should ship along + * with this library; if not, see http://www.gnu.org/copyleft/. + */ +#include "bsemodernadsr.genidl.hh" +#include <bse/bseblockutils.hh> + +namespace Bse { + +#define LOTS 100000 + +class ModernADSR : public ModernADSRBase { + /* ModernADSR module implementation */ + class Module : public SynthesisModule { + /* coefficients: */ + enum State + { + NONE, + ATTACK, + DECAY, + DECAY_AUTOOFF, + SUSTAIN, + FADE0, + FADE100, + RELEASE, + CLEANUP, + }; + int attack, decay, release, decay_release, fade, cleanup; + float sustain; + ADSRAttackMode attack_mode, effective_attack_mode; + ADSRDecayMode decay_mode, effective_decay_mode; + ADSRFadeMode fade_mode; + /* state: */ + unsigned int count, total; + State state; + float start, step, prev; + public: + void + config (ModernADSRProperties *params) + { + double f = mix_freq() / 1000.0; + float time_dr = 1.0 / (1.0 / params->time_d + 1.0 / params->time_r); + attack = dtoi(params->time_a * f); + decay = dtoi(params->time_d * f); + sustain = params->level_s * 0.01; + fade = dtoi(params->time_f * f); + release = dtoi(params->time_r * f); + decay_release = dtoi(time_dr * f); + cleanup = dtoi(params->cleanup * f); + attack_mode = params->attack_mode; + decay_mode = params->decay_mode; + fade_mode = params->fade_mode; + if (decay_mode == ADSR_DECAY_AUTOMATIC) + effective_decay_mode = (decay < release) ? ADSR_DECAY_HOLD : ADSR_DECAY_PRIMITIVE; + else + effective_decay_mode = decay_mode; + if (attack_mode == ADSR_ATTACK_AUTOMATIC) + effective_attack_mode = (decay < release) ? ADSR_ATTACK_DTZ : ADSR_ATTACK_PRIMITIVE; + else + effective_attack_mode = attack_mode; + } + void + reset () + { + state = NONE; + count = total = 0; + start = step = 0.f; + prev = 0.f; + } + + inline void + start_state (State _state, int _length, float _end) + { + state = _state; + float cur = start + step * count; + if (!_length) + { + start = _end; + step = 0.f; + timeout(); + return; + } + count = 0; + total = _length; + start = cur; + step = (_end - start) / total; + } + + void + skip_state () + { + start += step * total; + } + + void + timeout() + { + switch (state) { + case NONE: + start_state (NONE, LOTS, 0.f); + break; + case ATTACK: + { + start_state (DECAY, decay, sustain); + break; + } + case DECAY: + { + if (fade_mode == ADSR_FADE_NONE) + start_state (SUSTAIN, LOTS, sustain); + else if (fade_mode == ADSR_FADE_TO0) + start_state (FADE0, fade, 0.f); + else if (fade_mode == ADSR_FADE_TO100) + start_state (FADE100, fade, 1.f); + break; + } + case DECAY_AUTOOFF: + start_state (RELEASE, release, 0.f); + break; + case SUSTAIN: + start_state (SUSTAIN, LOTS, sustain); + break; + case FADE100: + start_state (FADE100, LOTS, 1.f); + break; + case FADE0: + start_state (CLEANUP, cleanup, 0.f); + break; + case RELEASE: + start_state (CLEANUP, cleanup, 0.f); + break; + case CLEANUP: + start_state (NONE, LOTS, 0.f); + break; + } + } + + void + note_off() + { + switch (state) { + case NONE: + start_state (NONE, LOTS, 0.f); + break; + case ATTACK: + if (effective_attack_mode == ADSR_ATTACK_MIRROR) + start_state (RELEASE, count, 0.f); + else if (effective_attack_mode == ADSR_ATTACK_DTZ) + start_state (RELEASE, decay, 0.f); + else /* ADSR_ATTACK_PRIMITIVE */ + start_state (RELEASE, release, 0.f); + break; + case DECAY: + if (effective_decay_mode == ADSR_DECAY_HOLD) + state = DECAY_AUTOOFF; + else if (effective_decay_mode == ADSR_DECAY_DTZ) + start_state (RELEASE, total - count, 0.f); + else + start_state (RELEASE, release, 0.f); + break; + case SUSTAIN: + case FADE100: + case FADE0: + start_state (RELEASE, release, 0.f); + break; + case DECAY_AUTOOFF: + case RELEASE: + case CLEANUP: + break; + } + } + + unsigned int + process_wait (unsigned int remain, float *out, const float *in) + { + unsigned int i; + for (i = 0; i < remain; i++) { + if (G_UNLIKELY (in[i] > prev)) { + prev = in[i]; + start_state (ATTACK, attack, 1.f); + return i; + } + prev = in[i]; + out[i] = 0.f; + } + return i; + } + + unsigned int + process_state (unsigned int remain, float *out, const float *in) + { + unsigned int i, c = count; + for (i = 0; i < remain; i++) { + if (G_UNLIKELY (in[i] < prev)) { + prev = in[i]; + note_off(); + return i; + } + prev = in[i]; + out[i] = start + c++ * step; + } + return i; + } + + void + process (unsigned int n_values) + { + const IStream &istr_gate = istream (ICHANNEL_GATE_IN); + const OStream &ostr_ctrl = ostream (OCHANNEL_CTRL_OUT); + const float *in_gate = istr_gate.values; + float *out_ctrl = ostr_ctrl.values; + unsigned int i = 0; + bool input_active = istr_gate.connected && istr_gate.values != const_values (0); + bool generated = false; + if (input_active || state != NONE) + { + while (i < n_values) + { + unsigned int remain = n_values - i; + if (state == NONE) + { + remain = process_wait (remain, out_ctrl + i, in_gate + i); + } else { + if (remain > (total - count)) + remain = total - count; + generated = true; + remain = process_state (remain, out_ctrl + i, in_gate + i); + count += remain; + if (count >= total) + timeout(); + } + i += remain; + } + } + if (!generated) + ostream_set (OCHANNEL_CTRL_OUT, const_values (0)); + ostream_set (OCHANNEL_DONE_OUT, const_values (generated ? 0.f : 1.f)); + } + }; +public: + /* implement creation and config methods for synthesis Module */ + BSE_EFFECT_INTEGRATE_MODULE (ModernADSR, Module, ModernADSRProperties); +}; + +BSE_CXX_DEFINE_EXPORTS(); +BSE_CXX_REGISTER_ALL_TYPES_FROM_BSEMODERNADSR_IDL(); + +} // Bse Index: bsemodernadsr.idl =================================================================== --- bsemodernadsr.idl (revision 0) +++ bsemodernadsr.idl (revision 0) @@ -0,0 +1,67 @@ +/* BseModernADSR - Configurable ADSR Envelope + * Copyright (c) 2007 Krzysztof Foltman + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307, USA. + */ +#include <bse/bse.idl> + +namespace Bse { + +choice ADSRAttackMode { + ADSR_ATTACK_AUTOMATIC = (_("Automatic"), _("Try to select most 'musically useful' behaviour")), + ADSR_ATTACK_MIRROR = (_("Mirror"), _("Use note length to date as release time (release = mirror of attack)")), + ADSR_ATTACK_DTZ = (_("Decay to zero"), _("Use decay time as release time")), + ADSR_ATTACK_PRIMITIVE = (_("Primitive"), _("Use normal release time starting from current level")), +}; + +choice ADSRDecayMode { + ADSR_DECAY_AUTOMATIC = (_("Automatic"), _("Try to select most 'musically useful' behaviour")), + ADSR_DECAY_HOLD = (_("Hold decay"), _("Do not interrupt the decay stage on key release")), + ADSR_DECAY_DTZ = (_("Decay to zero"), _("Use remaining decay time as release time")), + ADSR_DECAY_PRIMITIVE = (_("Primitive"), _("Use normal release time immediately from current level (like SF2)")), +}; + +choice ADSRFadeMode { + ADSR_FADE_NONE = (_("No fade"), _("Keep the constant sustain level")), + ADSR_FADE_TO0 = (_("Fade to 0%"), _("Fade to 0% for specified time")), + ADSR_FADE_TO100 = (_("Fade to 100%"), _("Fade to 100% for specified time")), +}; + +class ModernADSR : Effect { + Info icon = "icons/madsr.png"; + Info authors = "Krzysztof Foltman"; + Info license = _("GNU Lesser General Public License"); + Info category = _("Other Sources/Modern ADSR"); + Info blurb = _("ADSR envelope with added fade time parameter"); + IStream gate_in = (_("Gate In"), _("Gate input (activates/deactivates envelope)")); + OStream ctrl_out = (_("Ctrl Out"), _("Envelope output")); + OStream done_out = (_("Done Out"), _("This signal goes high after the release phase has completed")); + group _("Parameters") { + Real time_a = LogScale (_("Attack [ms]"), _("Attack time (zero to 100%)"), 0.4, 0, 25000.0, 10, 100.0, 250.0, 1, ":scale" STANDARD); + Real time_d = LogScale (_("Decay [ms]"), _("Decay time (100% to sustain)"), 100, 0, 25000.0, 10, 100.0, 250.0, 1, ":scale" STANDARD); + Real level_s = Perc (_("Sustain level (%)"), _("Sustain level"), 30, ":scale" STANDARD); + Real time_r = LogScale (_("Release [ms]"), _("Release time (sustain to 0%)"), 1000, 0, 25000.0, 10, 100.0, 250.0, 1, ":scale" STANDARD); + }; + group _("Advanced") { + ADSRAttackMode attack_mode = Choice (_("Attack Mode"), _("What to do when a key is released during attack phase"), ADSR_ATTACK_AUTOMATIC, STANDARD); + ADSRDecayMode decay_mode = Choice (_("Decay Mode"), _("What to do when a key is released during decay phase"), ADSR_DECAY_AUTOMATIC, STANDARD); + ADSRFadeMode fade_mode = Choice (_("Fade Mode"), _("What happens during sustain phase"), ADSR_FADE_NONE, STANDARD); + Real time_f = LogScale (_("Fade [ms]"), _("Fade time (sustain to 0% or sustain to 100%)"), 0, 0, 25000.0, 10, 100.0, 250.0, 1, ":scale" STANDARD); + Real cleanup = Real (_("Cleanup [ms]"), _("Delay before Done signal is activated"), 0, 0, 100, 100, ":scale" STANDARD); + }; +}; + +} // Bse Index: icons/madsr.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: icons/madsr.png ___________________________________________________________________ Name: svn:mime-type + application/octet-stream
Attachment:
madsr.png
Description: PNG image
