src/monosynth.cpp

   1 /* Calf DSP Library
   2  * Example audio modules - monosynth
   3  *
   4  * Copyright (C) 2001-2007 Krzysztof Foltman
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA  02110-1301  USA
  20  */
  21 #include <assert.h>
  22 #include <memory.h>
  23 #include <config.h>
  24 #include <complex>
  25 #if USE_JACK
  26 #include <jack/jack.h>
  27 #endif
  28 #include <calf/giface.h>
  29 #include <calf/modules_synths.h>
  30
  31 using namespace dsp;
  32 using namespace calf_plugins;
  33 using namespace std;
  34
  35 float silence[4097];
  36
  37 static const char *monosynth_mod_src_names[] = {
  38     "None",
  39     "Velocity",
  40     "Pressure",
  41     "ModWheel",
  42     "Envelope",
  43     "LFO",
  44     NULL
  45 };
  46
  47 static const char *monosynth_mod_dest_names[] = {
  48     "None",
  49     "Attenuation",
  50     "Osc Mix Ratio (%)",
  51     "Cutoff [ct]",
  52     "Resonance",
  53     "O1: Detune [ct]",
  54     "O2: Detune [ct]",
  55     "O1: PW (%)",
  56     "O2: PW (%)",
  57     NULL
  58 };
  59
  60 monosynth_audio_module::monosynth_audio_module()
  61 : mod_matrix(mod_matrix_data, mod_matrix_slots, monosynth_mod_src_names, monosynth_mod_dest_names)
  62 , inertia_cutoff(1)
  63 , inertia_pitchbend(1)
  64 , inertia_pressure(64)
  65 {
  66 }
  67
  68 void monosynth_audio_module::activate() {
  69     running = false;
  70     output_pos = 0;
  71     queue_note_on = -1;
  72     stop_count = 0;
  73     inertia_pitchbend.set_now(1.f);
  74     lfo_bend = 1.0;
  75     modwheel_value = 0.f;
  76     modwheel_value_int = 0;
  77     inertia_cutoff.set_now(*params[par_cutoff]);
  78     inertia_pressure.set_now(0);
  79     filter.reset();
  80     filter2.reset();
  81     stack.clear();
  82     last_pwshift1 = last_pwshift2 = 0;
  83 }
  84
  85 waveform_family<MONOSYNTH_WAVE_BITS> *monosynth_audio_module::waves;
  86
  87 void monosynth_audio_module::precalculate_waves(progress_report_iface *reporter)
  88 {
  89     float data[1 << MONOSYNTH_WAVE_BITS];
  90     bandlimiter<MONOSYNTH_WAVE_BITS> bl;
  91
  92     if (waves)
  93         return;
  94
  95     static waveform_family<MONOSYNTH_WAVE_BITS> waves_data[wave_count];
  96     waves = waves_data;
  97
  98     enum { S = 1 << MONOSYNTH_WAVE_BITS, HS = S / 2, QS = S / 4, QS3 = 3 * QS };
  99     float iQS = 1.0 / QS;
 100
 101     if (reporter)
 102         reporter->report_progress(0, "Precalculating waveforms");
 103
 104     // yes these waves don't have really perfect 1/x spectrum because of aliasing
 105     // (so what?)
 106     for (int i = 0 ; i < HS; i++)
 107         data[i] = (float)(i * 1.0 / HS),
 108         data[i + HS] = (float)(i * 1.0 / HS - 1.0f);
 109     waves[wave_saw].make(bl, data);
 110
 111     // this one is dummy, fake and sham, we're using a difference of two sawtooths for square wave due to PWM
 112     for (int i = 0 ; i < S; i++)
 113         data[i] = (float)(i < HS ? -1.f : 1.f);
 114     waves[wave_sqr].make(bl, data, 4);
 115
 116     for (int i = 0 ; i < S; i++)
 117         data[i] = (float)(i < (64 * S / 2048)? -1.f : 1.f);
 118     waves[wave_pulse].make(bl, data);
 119
 120     for (int i = 0 ; i < S; i++)
 121         data[i] = (float)sin(i * M_PI / HS);
 122     waves[wave_sine].make(bl, data);
 123
 124     for (int i = 0 ; i < QS; i++) {
 125         data[i] = i * iQS,
 126         data[i + QS] = 1 - i * iQS,
 127         data[i + HS] = - i * iQS,
 128         data[i + QS3] = -1 + i * iQS;
 129     }
 130     waves[wave_triangle].make(bl, data);
 131
 132     for (int i = 0, j = 1; i < S; i++) {
 133         data[i] = -1 + j * 1.0 / HS;
 134         if (i == j)
 135             j *= 2;
 136     }
 137     waves[wave_varistep].make(bl, data);
 138
 139     for (int i = 0; i < S; i++) {
 140         data[i] = (min(1.f, (float)(i / 64.f))) * (1.0 - i * 1.0 / S) * (-1 + fmod (i * i * 8/ (S * S * 1.0), 2.0));
 141     }
 142     waves[wave_skewsaw].make(bl, data);
 143     for (int i = 0; i < S; i++) {
 144         data[i] = (min(1.f, (float)(i / 64.f))) * (1.0 - i * 1.0 / S) * (fmod (i * i * 8/ (S * S * 1.0), 2.0) < 1.0 ? -1.0 : +1.0);
 145     }
 146     waves[wave_skewsqr].make(bl, data);
 147
 148     if (reporter)
 149         reporter->report_progress(50, "Precalculating waveforms");
 150
 151     for (int i = 0; i < S; i++) {
 152         if (i < QS3) {
 153             float p = i * 1.0 / QS3;
 154             data[i] = sin(M_PI * p * p * p);
 155         } else {
 156             float p = (i - QS3 * 1.0) / QS;
 157             data[i] = -0.5 * sin(3 * M_PI * p * p);
 158         }
 159     }
 160     waves[wave_test1].make(bl, data);
 161     for (int i = 0; i < S; i++) {
 162         data[i] = exp(-i * 1.0 / HS) * sin(i * M_PI / HS) * cos(2 * M_PI * i / HS);
 163     }
 164     normalize_waveform(data, S);
 165     waves[wave_test2].make(bl, data);
 166     for (int i = 0; i < S; i++) {
 167         //int ii = (i < HS) ? i : S - i;
 168         int ii = HS;
 169         data[i] = (ii * 1.0 / HS) * sin(i * 3 * M_PI / HS + 2 * M_PI * sin(M_PI / 4 + i * 4 * M_PI / HS)) * sin(i * 5 * M_PI / HS + 2 * M_PI * sin(M_PI / 8 + i * 6 * M_PI / HS));
 170     }
 171     waves[wave_test3].make(bl, data);
 172     for (int i = 0; i < S; i++) {
 173         data[i] = sin(i * 2 * M_PI / HS + sin(i * 2 * M_PI / HS + 0.5 * M_PI * sin(i * 18 * M_PI / HS)) * sin(i * 1 * M_PI / HS + 0.5 * M_PI * sin(i * 11 * M_PI / HS)));
 174     }
 175     waves[wave_test4].make(bl, data);
 176     for (int i = 0; i < S; i++) {
 177         data[i] = sin(i * 2 * M_PI / HS + 0.2 * M_PI * sin(i * 13 * M_PI / HS) + 0.1 * M_PI * sin(i * 37 * M_PI / HS)) * sin(i * M_PI / HS + 0.2 * M_PI * sin(i * 15 * M_PI / HS));
 178     }
 179     waves[wave_test5].make(bl, data);
 180     for (int i = 0; i < S; i++) {
 181         if (i < HS)
 182             data[i] = sin(i * 2 * M_PI / HS);
 183         else
 184         if (i < 3 * S / 4)
 185             data[i] = sin(i * 4 * M_PI / HS);
 186         else
 187         if (i < 7 * S / 8)
 188             data[i] = sin(i * 8 * M_PI / HS);
 189         else
 190             data[i] = sin(i * 8 * M_PI / HS) * (S - i) / (S / 8);
 191     }
 192     waves[wave_test6].make(bl, data);
 193     for (int i = 0; i < S; i++) {
 194         int j = i >> (MONOSYNTH_WAVE_BITS - 11);
 195         data[i] = (j ^ 0x1D0) * 1.0 / HS - 1;
 196     }
 197     waves[wave_test7].make(bl, data);
 198     for (int i = 0; i < S; i++) {
 199         int j = i >> (MONOSYNTH_WAVE_BITS - 11);
 200         data[i] = -1 + 0.66 * (3 & ((j >> 8) ^ (j >> 10) ^ (j >> 6)));
 201     }
 202     waves[wave_test8].make(bl, data);
 203     if (reporter)
 204         reporter->report_progress(100, "");
 205
 206 }
 207
 208 bool monosynth_audio_module::get_graph(int index, int subindex, float *data, int points, cairo_iface *context)
 209 {
 210     monosynth_audio_module::precalculate_waves(NULL);
 211     // printf("get_graph %d %p %d wave1=%d wave2=%d\n", index, data, points, wave1, wave2);
 212     if (index == par_wave1 || index == par_wave2) {
 213         if (subindex)
 214             return false;
 215         enum { S = 1 << MONOSYNTH_WAVE_BITS };
 216         float value = *params[index];
 217         int wave = dsp::clip(dsp::fastf2i_drm(value), 0, (int)wave_count - 1);
 218
 219         uint32_t shift = index == par_wave1 ? last_pwshift1 : last_pwshift2;
 220         if (!running)
 221             shift = (int32_t)(0x78000000 * (*params[index == par_wave1 ? par_pw1 : par_pw2]));
 222         int flag = (wave == wave_sqr);
 223
 224         shift = (flag ? S/2 : 0) + (shift >> (32 - MONOSYNTH_WAVE_BITS));
 225         int sign = flag ? -1 : 1;
 226         if (wave == wave_sqr)
 227             wave = wave_saw;
 228         float *waveform = waves[wave].original;
 229         for (int i = 0; i < points; i++)
 230             data[i] = (sign * waveform[i * S / points] + waveform[(i * S / points + shift) & (S - 1)]) / (sign == -1 ? 1 : 2);
 231         return true;
 232     }
 233     if (index == par_filtertype) {
 234         if (!running)
 235             return false;
 236         if (subindex > (is_stereo_filter() ? 1 : 0))
 237             return false;
 238         for (int i = 0; i < points; i++)
 239         {
 240             typedef complex<double> cfloat;
 241             double freq = 20.0 * pow (20000.0 / 20.0, i * 1.0 / points);
 242
 243             dsp::biquad_d1_lerp<float> &f = subindex ? filter2 : filter;
 244             float level = f.freq_gain(freq, srate);
 245             if (!is_stereo_filter())
 246                 level *= filter2.freq_gain(freq, srate);
 247             level *= fgain;
 248
 249             data[i] = log(level) / log(1024.0) + 0.5;
 250         }
 251         return true;
 252     }
 253     return get_static_graph(index, subindex, *params[index], data, points, context);
 254 }
 255
 256 void monosynth_audio_module::calculate_buffer_oscs(float lfo)
 257 {
 258     int flag1 = (wave1 == wave_sqr);
 259     int flag2 = (wave2 == wave_sqr);
 260     int32_t shift1 = last_pwshift1;
 261     int32_t shift2 = last_pwshift2;
 262     int32_t shift_target1 = (int32_t)(0x78000000 * dsp::clip11(*params[par_pw1] + lfo * *params[par_lfopw] + 0.01f * moddest[moddest_o1pw]));
 263     int32_t shift_target2 = (int32_t)(0x78000000 * dsp::clip11(*params[par_pw2] + lfo * *params[par_lfopw] + 0.01f * moddest[moddest_o2pw]));
 264     int32_t shift_delta1 = ((shift_target1 >> 1) - (last_pwshift1 >> 1)) >> (step_shift - 1);
 265     int32_t shift_delta2 = ((shift_target2 >> 1) - (last_pwshift2 >> 1)) >> (step_shift - 1);
 266     last_lfov = lfo;
 267     last_pwshift1 = shift_target1;
 268     last_pwshift2 = shift_target2;
 269
 270     shift1 += (flag1 << 31);
 271     shift2 += (flag2 << 31);
 272     float mix1 = 1 - 2 * flag1, mix2 = 1 - 2 * flag2;
 273
 274     float new_xfade = dsp::clip<float>(xfade + 0.01f * moddest[moddest_oscmix], 0.f, 1.f);
 275     float cur_xfade = last_xfade;
 276     float xfade_step = (new_xfade - cur_xfade) * (1.0 / step_size);
 277
 278     for (uint32_t i = 0; i < step_size; i++)
 279     {
 280         float osc1val = osc1.get_phaseshifted(shift1, mix1);
 281         float osc2val = osc2.get_phaseshifted(shift2, mix2);
 282         float wave = osc1val + (osc2val - osc1val) * cur_xfade;
 283         buffer[i] = wave;
 284         shift1 += shift_delta1;
 285         shift2 += shift_delta2;
 286         cur_xfade += xfade_step;
 287     }
 288     last_xfade = new_xfade;
 289 }
 290
 291 void monosynth_audio_module::calculate_buffer_ser()
 292 {
 293     filter.big_step(1.0 / step_size);
 294     filter2.big_step(1.0 / step_size);
 295     for (uint32_t i = 0; i < step_size; i++)
 296     {
 297         float wave = buffer[i] * fgain;
 298         wave = filter.process(wave);
 299         wave = filter2.process(wave);
 300         buffer[i] = wave;
 301         fgain += fgain_delta;
 302     }
 303 }
 304
 305 void monosynth_audio_module::calculate_buffer_single()
 306 {
 307     filter.big_step(1.0 / step_size);
 308     for (uint32_t i = 0; i < step_size; i++)
 309     {
 310         float wave = buffer[i] * fgain;
 311         wave = filter.process(wave);
 312         buffer[i] = wave;
 313         fgain += fgain_delta;
 314     }
 315 }
 316
 317 void monosynth_audio_module::calculate_buffer_stereo()
 318 {
 319     filter.big_step(1.0 / step_size);
 320     filter2.big_step(1.0 / step_size);
 321     for (uint32_t i = 0; i < step_size; i++)
 322     {
 323         float wave1 = buffer[i] * fgain;
 324         float wave2 = phaseshifter.process_ap(wave1);
 325         buffer[i] = fgain * filter.process(wave1);
 326         buffer2[i] = fgain * filter2.process(wave2);
 327         fgain += fgain_delta;
 328     }
 329 }
 330
 331 void monosynth_audio_module::lookup_waveforms()
 332 {
 333     osc1.waveform = waves[wave1 == wave_sqr ? wave_saw : wave1].get_level(osc1.phasedelta);
 334     osc2.waveform = waves[wave2 == wave_sqr ? wave_saw : wave2].get_level(osc2.phasedelta);
 335     if (!osc1.waveform) osc1.waveform = silence;
 336     if (!osc2.waveform) osc2.waveform = silence;
 337     prev_wave1 = wave1;
 338     prev_wave2 = wave2;
 339 }
 340
 341 void monosynth_audio_module::delayed_note_on()
 342 {
 343     force_fadeout = false;
 344     stop_count = 0;
 345     porta_time = 0.f;
 346     start_freq = freq;
 347     target_freq = freq = 440 * pow(2.0, (queue_note_on - 69) / 12.0);
 348     velocity = queue_vel;
 349     ampctl = 1.0 + (queue_vel - 1.0) * *params[par_vel2amp];
 350     fltctl = 1.0 + (queue_vel - 1.0) * *params[par_vel2filter];
 351     set_frequency();
 352     lookup_waveforms();
 353     lfo_clock = 0.f;
 354
 355     if (!running)
 356     {
 357         if (legato >= 2)
 358             porta_time = -1.f;
 359         last_xfade = xfade;
 360         osc1.reset();
 361         osc2.reset();
 362         filter.reset();
 363         filter2.reset();
 364         lfo.reset();
 365         switch((int)*params[par_oscmode])
 366         {
 367         case 1:
 368             osc2.phase = 0x80000000;
 369             break;
 370         case 2:
 371             osc2.phase = 0x40000000;
 372             break;
 373         case 3:
 374             osc1.phase = osc2.phase = 0x40000000;
 375             break;
 376         case 4:
 377             osc1.phase = 0x40000000;
 378             osc2.phase = 0xC0000000;
 379             break;
 380         case 5:
 381             // rand() is crap, but I don't have any better RNG in Calf yet
 382             osc1.phase = rand() << 16;
 383             osc2.phase = rand() << 16;
 384             break;
 385         default:
 386             break;
 387         }
 388         envelope.note_on();
 389         running = true;
 390     }
 391     if (legato >= 2 && !gate)
 392         porta_time = -1.f;
 393     gate = true;
 394     stopping = false;
 395     if (!(legato & 1) || envelope.released()) {
 396         envelope.note_on();
 397     }
 398     envelope.advance();
 399     queue_note_on = -1;
 400     float modsrc[modsrc_count] = { 1, velocity, inertia_pressure.get_last(), modwheel_value, 0, 0.5+0.5*last_lfov};
 401     calculate_modmatrix(moddest, moddest_count, modsrc);
 402 }
 403
 404 void monosynth_audio_module::set_sample_rate(uint32_t sr) {
 405     srate = sr;
 406     crate = sr / step_size;
 407     odcr = (float)(1.0 / crate);
 408     phaseshifter.set_ap(1000.f, sr);
 409     fgain = 0.f;
 410     fgain_delta = 0.f;
 411     inertia_cutoff.ramp.set_length(crate / 30); // 1/30s
 412     inertia_pitchbend.ramp.set_length(crate / 30); // 1/30s
 413 }
 414
 415 void monosynth_audio_module::calculate_step()
 416 {
 417     if (queue_note_on != -1)
 418         delayed_note_on();
 419     else if (stopping)
 420     {
 421         running = false;
 422         dsp::zero(buffer, step_size);
 423         if (is_stereo_filter())
 424             dsp::zero(buffer2, step_size);
 425         envelope.advance();
 426         return;
 427     }
 428     lfo.set_freq(*params[par_lforate], crate);
 429     float porta_total_time = *params[par_portamento] * 0.001f;
 430
 431     if (porta_total_time >= 0.00101f && porta_time >= 0) {
 432         // XXXKF this is criminal, optimize!
 433         float point = porta_time / porta_total_time;
 434         if (point >= 1.0f) {
 435             freq = target_freq;
 436             porta_time = -1;
 437         } else {
 438             freq = start_freq + (target_freq - start_freq) * point;
 439             // freq = start_freq * pow(target_freq / start_freq, point);
 440             porta_time += odcr;
 441         }
 442     }
 443     float lfov = lfo.get() * std::min(1.0f, lfo_clock / *params[par_lfodelay]);
 444     lfov = lfov * dsp::lerp(1.f, modwheel_value, *params[par_mwhl_lfo]);
 445     lfo_clock += odcr;
 446     if (fabs(*params[par_lfopitch]) > small_value<float>())
 447         lfo_bend = pow(2.0f, *params[par_lfopitch] * lfov * (1.f / 1200.0f));
 448     inertia_pitchbend.step();
 449     set_frequency();
 450     envelope.advance();
 451     float env = envelope.value;
 452
 453     // mod matrix
 454     // this should be optimized heavily; I think I'll do it when MIDI in Ardour 3 gets stable :>
 455     float modsrc[modsrc_count] = { 1, velocity, inertia_pressure.get(), modwheel_value, env, 0.5+0.5*lfov};
 456     calculate_modmatrix(moddest, moddest_count, modsrc);
 457
 458     inertia_cutoff.set_inertia(*params[par_cutoff]);
 459     cutoff = inertia_cutoff.get() * pow(2.0f, (lfov * *params[par_lfofilter] + env * fltctl * *params[par_envmod] + moddest[moddest_cutoff]) * (1.f / 1200.f));
 460     if (*params[par_keyfollow] > 0.01f)
 461         cutoff *= pow(freq / 264.f, *params[par_keyfollow]);
 462     cutoff = dsp::clip(cutoff , 10.f, 18000.f);
 463     float resonance = *params[par_resonance];
 464     float e2r = *params[par_envtores];
 465     float e2a = *params[par_envtoamp];
 466     resonance = resonance * (1 - e2r) + (0.7 + (resonance - 0.7) * env * env) * e2r + moddest[moddest_resonance];
 467     float cutoff2 = dsp::clip(cutoff * separation, 10.f, 18000.f);
 468     float newfgain = 0.f;
 469     if (filter_type != last_filter_type)
 470     {
 471         filter.y2 = filter.y1 = filter.x2 = filter.x1 = filter.y1;
 472         filter2.y2 = filter2.y1 = filter2.x2 = filter2.x1 = filter2.y1;
 473         last_filter_type = filter_type;
 474     }
 475     switch(filter_type)
 476     {
 477     case flt_lp12:
 478         filter.set_lp_rbj(cutoff, resonance, srate);
 479         filter2.set_null();
 480         newfgain = min(0.7f, 0.7f / resonance) * ampctl;
 481         break;
 482     case flt_hp12:
 483         filter.set_hp_rbj(cutoff, resonance, srate);
 484         filter2.set_null();
 485         newfgain = min(0.7f, 0.7f / resonance) * ampctl;
 486         break;
 487     case flt_lp24:
 488         filter.set_lp_rbj(cutoff, resonance, srate);
 489         filter2.set_lp_rbj(cutoff2, resonance, srate);
 490         newfgain = min(0.5f, 0.5f / resonance) * ampctl;
 491         break;
 492     case flt_lpbr:
 493         filter.set_lp_rbj(cutoff, resonance, srate);
 494         filter2.set_br_rbj(cutoff2, 1.0 / resonance, srate);
 495         newfgain = min(0.5f, 0.5f / resonance) * ampctl;
 496         break;
 497     case flt_hpbr:
 498         filter.set_hp_rbj(cutoff, resonance, srate);
 499         filter2.set_br_rbj(cutoff2, 1.0 / resonance, srate);
 500         newfgain = min(0.5f, 0.5f / resonance) * ampctl;
 501         break;
 502     case flt_2lp12:
 503         filter.set_lp_rbj(cutoff, resonance, srate);
 504         filter2.set_lp_rbj(cutoff2, resonance, srate);
 505         newfgain = min(0.7f, 0.7f / resonance) * ampctl;
 506         break;
 507     case flt_bp6:
 508         filter.set_bp_rbj(cutoff, resonance, srate);
 509         filter2.set_null();
 510         newfgain = ampctl;
 511         break;
 512     case flt_2bp6:
 513         filter.set_bp_rbj(cutoff, resonance, srate);
 514         filter2.set_bp_rbj(cutoff2, resonance, srate);
 515         newfgain = ampctl;
 516         break;
 517     }
 518     float aenv = env;
 519     if (*params[par_envtoamp] > 0.f)
 520         newfgain *= 1.0 - (1.0 - aenv) * e2a;
 521     if (moddest[moddest_attenuation] != 0.f)
 522         newfgain *= dsp::clip<float>(1 - moddest[moddest_attenuation] * moddest[moddest_attenuation], 0.f, 1.f);
 523     fgain_delta = (newfgain - fgain) * (1.0 / step_size);
 524     calculate_buffer_oscs(lfov);
 525     switch(filter_type)
 526     {
 527     case flt_lp24:
 528     case flt_lpbr:
 529     case flt_hpbr: // Oomek's wish
 530         calculate_buffer_ser();
 531         break;
 532     case flt_lp12:
 533     case flt_hp12:
 534     case flt_bp6:
 535         calculate_buffer_single();
 536         break;
 537     case flt_2lp12:
 538     case flt_2bp6:
 539         calculate_buffer_stereo();
 540         break;
 541     }
 542     if ((envelope.state == adsr::STOP && !gate) || force_fadeout || (envelope.state == adsr::RELEASE && *params[par_envtoamp] <= 0.f))
 543     {
 544         enum { ramp = step_size * 4 };
 545         for (int i = 0; i < step_size; i++)
 546             buffer[i] *= (ramp - i - stop_count) * (1.0f / ramp);
 547         if (is_stereo_filter())
 548             for (int i = 0; i < step_size; i++)
 549                 buffer2[i] *= (ramp - i - stop_count) * (1.0f / ramp);
 550         stop_count += step_size;
 551         if (stop_count >= ramp)
 552             stopping = true;
 553     }
 554 }
 555
 556 void monosynth_audio_module::note_on(int note, int vel)
 557 {
 558     queue_note_on = note;
 559     last_key = note;
 560     queue_vel = vel / 127.f;
 561     stack.push(note);
 562 }
 563
 564 void monosynth_audio_module::note_off(int note, int vel)
 565 {
 566     stack.pop(note);
 567     // If releasing the currently played note, try to get another one from note stack.
 568     if (note == last_key) {
 569         if (stack.count())
 570         {
 571             last_key = note = stack.nth(stack.count() - 1);
 572             start_freq = freq;
 573             target_freq = freq = dsp::note_to_hz(note);
 574             porta_time = 0;
 575             set_frequency();
 576             if (!(legato & 1)) {
 577                 envelope.note_on();
 578                 stopping = false;
 579                 running = true;
 580             }
 581             return;
 582         }
 583         gate = false;
 584         envelope.note_off();
 585     }
 586 }
 587
 588 void monosynth_audio_module::channel_pressure(int value)
 589 {
 590     inertia_pressure.set_inertia(value * (1.0 / 127.0));
 591 }
 592
 593 void monosynth_audio_module::control_change(int controller, int value)
 594 {
 595     switch(controller)
 596     {
 597         case 1:
 598             modwheel_value_int = (modwheel_value_int & 127) | (value << 7);
 599             modwheel_value = modwheel_value_int / 16383.0;
 600             break;
 601         case 33:
 602             modwheel_value_int = (modwheel_value_int & (127 << 7)) | value;
 603             modwheel_value = modwheel_value_int / 16383.0;
 604             break;
 605         case 120: // all sounds off
 606             force_fadeout = true;
 607             // fall through
 608         case 123: // all notes off
 609             gate = false;
 610             queue_note_on = -1;
 611             envelope.note_off();
 612             stack.clear();
 613             break;
 614     }
 615 }
 616
 617 void monosynth_audio_module::deactivate()
 618 {
 619     gate = false;
 620     running = false;
 621     stopping = false;
 622     envelope.reset();
 623     stack.clear();
 624 }
 625
 626 void monosynth_audio_module::set_frequency()
 627 {
 628     float detune_scaled = (detune - 1); // * log(freq / 440);
 629     if (*params[par_scaledetune] > 0)
 630         detune_scaled *= pow(20.0 / freq, (double)*params[par_scaledetune]);
 631     float p1 = 1, p2 = 1;
 632     if (moddest[moddest_o1detune] != 0)
 633         p1 = pow(2.0, moddest[moddest_o1detune] * (1.0 / 1200.0));
 634     if (moddest[moddest_o2detune] != 0)
 635         p2 = pow(2.0, moddest[moddest_o2detune] * (1.0 / 1200.0));
 636     osc1.set_freq(freq * (1 - detune_scaled) * p1 * inertia_pitchbend.get_last() * lfo_bend, srate);
 637     osc2.set_freq(freq * (1 + detune_scaled) * p2 * inertia_pitchbend.get_last() * lfo_bend * xpose, srate);
 638 }
 639
 640
 641 void monosynth_audio_module::params_changed()
 642 {
 643     float sf = 0.001f;
 644     envelope.set(*params[par_attack] * sf, *params[par_decay] * sf, std::min(0.999f, *params[par_sustain]), *params[par_release] * sf, srate / step_size, *params[par_fade] * sf);
 645     filter_type = dsp::fastf2i_drm(*params[par_filtertype]);
 646     decay_factor = odcr * 1000.0 / *params[par_decay];
 647     separation = pow(2.0, *params[par_cutoffsep] / 1200.0);
 648     wave1 = dsp::clip(dsp::fastf2i_drm(*params[par_wave1]), 0, (int)wave_count - 1);
 649     wave2 = dsp::clip(dsp::fastf2i_drm(*params[par_wave2]), 0, (int)wave_count - 1);
 650     detune = pow(2.0, *params[par_detune] / 1200.0);
 651     xpose = pow(2.0, *params[par_osc2xpose] / 12.0);
 652     xfade = *params[par_oscmix];
 653     legato = dsp::fastf2i_drm(*params[par_legato]);
 654     master.set_inertia(*params[par_master]);
 655     set_frequency();
 656     if (wave1 != prev_wave1 || wave2 != prev_wave2)
 657         lookup_waveforms();
 658 }
 659
 660
 661 uint32_t monosynth_audio_module::process(uint32_t offset, uint32_t nsamples, uint32_t inputs_mask, uint32_t outputs_mask)
 662 {
 663     if (!running && queue_note_on == -1) {
 664         for (uint32_t i = 0; i < nsamples / step_size; i++)
 665             envelope.advance();
 666         return 0;
 667     }
 668     uint32_t op = offset;
 669     uint32_t op_end = offset + nsamples;
 670     while(op < op_end) {
 671         if (output_pos == 0) {
 672             if (running || queue_note_on != -1)
 673                 calculate_step();
 674             else {
 675                 envelope.advance();
 676                 dsp::zero(buffer, step_size);
 677             }
 678         }
 679         if(op < op_end) {
 680             uint32_t ip = output_pos;
 681             uint32_t len = std::min(step_size - output_pos, op_end - op);
 682             if (is_stereo_filter())
 683                 for(uint32_t i = 0 ; i < len; i++) {
 684                     float vol = master.get();
 685                     outs[0][op + i] = buffer[ip + i] * vol,
 686                     outs[1][op + i] = buffer2[ip + i] * vol;
 687                 }
 688             else
 689                 for(uint32_t i = 0 ; i < len; i++)
 690                     outs[0][op + i] = outs[1][op + i] = buffer[ip + i] * master.get();
 691             op += len;
 692             output_pos += len;
 693             if (output_pos == step_size)
 694                 output_pos = 0;
 695         }
 696     }
 697
 698     return 3;
 699 }
 700