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., 59 Temple Place, Suite 330,
  19  * Boston, MA 02111-1307, 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 monosynth_audio_module::monosynth_audio_module()
  38 : inertia_cutoff(exponential_ramp(1))
  39 , inertia_pitchbend(exponential_ramp(1))
  40 {
  41 }
  42
  43 void monosynth_audio_module::activate() {
  44     running = false;
  45     output_pos = 0;
  46     queue_note_on = -1;
  47     stop_count = 0;
  48     inertia_pitchbend.set_now(1.f);
  49     lfo_bend = 1.0;
  50     modwheel_value = 0.f;
  51     modwheel_value_int = 0;
  52     inertia_cutoff.set_now(*params[par_cutoff]);
  53     filter.reset();
  54     filter2.reset();
  55     stack.clear();
  56 }
  57
  58 waveform_family<MONOSYNTH_WAVE_BITS> *monosynth_audio_module::waves;
  59
  60 void monosynth_audio_module::precalculate_waves(progress_report_iface *reporter)
  61 {
  62     float data[1 << MONOSYNTH_WAVE_BITS];
  63     bandlimiter<MONOSYNTH_WAVE_BITS> bl;
  64
  65     if (waves)
  66         return;
  67
  68     static waveform_family<MONOSYNTH_WAVE_BITS> waves_data[wave_count];
  69     waves = waves_data;
  70
  71     enum { S = 1 << MONOSYNTH_WAVE_BITS, HS = S / 2, QS = S / 4, QS3 = 3 * QS };
  72     float iQS = 1.0 / QS;
  73
  74     if (reporter)
  75         reporter->report_progress(0, "Precalculating waveforms");
  76
  77     // yes these waves don't have really perfect 1/x spectrum because of aliasing
  78     // (so what?)
  79     for (int i = 0 ; i < HS; i++)
  80         data[i] = (float)(i * 1.0 / HS),
  81         data[i + HS] = (float)(i * 1.0 / HS - 1.0f);
  82     waves[wave_saw].make(bl, data);
  83
  84     // this one is dummy, fake and sham, we're using a difference of two sawtooths for square wave due to PWM
  85     for (int i = 0 ; i < S; i++)
  86         data[i] = (float)(i < HS ? -1.f : 1.f);
  87     waves[wave_sqr].make(bl, data, 4);
  88
  89     for (int i = 0 ; i < S; i++)
  90         data[i] = (float)(i < (64 * S / 2048)? -1.f : 1.f);
  91     waves[wave_pulse].make(bl, data);
  92
  93     // XXXKF sure this is a waste of space, this will be fixed some day by better bandlimiter
  94     for (int i = 0 ; i < S; i++)
  95         data[i] = (float)sin(i * M_PI / HS);
  96     waves[wave_sine].make(bl, data);
  97
  98     for (int i = 0 ; i < QS; i++) {
  99         data[i] = i * iQS,
 100         data[i + QS] = 1 - i * iQS,
 101         data[i + HS] = - i * iQS,
 102         data[i + QS3] = -1 + i * iQS;
 103     }
 104     waves[wave_triangle].make(bl, data);
 105
 106     for (int i = 0, j = 1; i < S; i++) {
 107         data[i] = -1 + j * 1.0 / HS;
 108         if (i == j)
 109             j *= 2;
 110     }
 111     waves[wave_varistep].make(bl, data);
 112
 113     for (int i = 0; i < S; i++) {
 114         data[i] = (min(1.f, (float)(i / 64.f))) * (1.0 - i * 1.0 / S) * (-1 + fmod (i * i / 262144.0, 2.0));
 115     }
 116     waves[wave_skewsaw].make(bl, data);
 117     for (int i = 0; i < S; i++) {
 118         data[i] = (min(1.f, (float)(i / 64.f))) * (1.0 - i * 1.0 / S) * (fmod (i * i / 262144.0, 2.0) < 1.0 ? -1.0 : +1.0);
 119     }
 120     waves[wave_skewsqr].make(bl, data);
 121
 122     if (reporter)
 123         reporter->report_progress(50, "Precalculating waveforms");
 124
 125     for (int i = 0; i < S; i++) {
 126         if (i < QS3) {
 127             float p = i * 1.0 / QS3;
 128             data[i] = sin(M_PI * p * p * p);
 129         } else {
 130             float p = (i - QS3 * 1.0) / QS;
 131             data[i] = -0.5 * sin(3 * M_PI * p * p);
 132         }
 133     }
 134     waves[wave_test1].make(bl, data);
 135     for (int i = 0; i < S; i++) {
 136         data[i] = exp(-i * 1.0 / HS) * sin(i * M_PI / HS) * cos(2 * M_PI * i / HS);
 137     }
 138     normalize_waveform(data, S);
 139     waves[wave_test2].make(bl, data);
 140     for (int i = 0; i < S; i++) {
 141         //int ii = (i < HS) ? i : S - i;
 142         int ii = HS;
 143         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));
 144     }
 145     waves[wave_test3].make(bl, data);
 146     for (int i = 0; i < S; i++) {
 147         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)));
 148     }
 149     waves[wave_test4].make(bl, data);
 150     for (int i = 0; i < S; i++) {
 151         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));
 152     }
 153     waves[wave_test5].make(bl, data);
 154     for (int i = 0; i < S; i++) {
 155         if (i < HS)
 156             data[i] = sin(i * 2 * M_PI / HS);
 157         else
 158         if (i < 3 * S / 4)
 159             data[i] = sin(i * 4 * M_PI / HS);
 160         else
 161         if (i < 7 * S / 8)
 162             data[i] = sin(i * 8 * M_PI / HS);
 163         else
 164             data[i] = sin(i * 8 * M_PI / HS) * (S - i) / (S / 8);
 165     }
 166     waves[wave_test6].make(bl, data);
 167     for (int i = 0; i < S; i++) {
 168         int j = i >> (MONOSYNTH_WAVE_BITS - 11);
 169         data[i] = (j ^ 0x1D0) * 1.0 / HS - 1;
 170     }
 171     waves[wave_test7].make(bl, data);
 172     for (int i = 0; i < S; i++) {
 173         int j = i >> (MONOSYNTH_WAVE_BITS - 11);
 174         data[i] = -1 + 0.66 * (3 & ((j >> 8) ^ (j >> 10) ^ (j >> 6)));
 175     }
 176     waves[wave_test8].make(bl, data);
 177     if (reporter)
 178         reporter->report_progress(100, "");
 179
 180 }
 181
 182 bool monosynth_audio_module::get_static_graph(int index, int subindex, float value, float *data, int points, cairo_iface *context)
 183 {
 184     monosynth_audio_module::precalculate_waves(NULL);
 185     if (index == par_wave1 || index == par_wave2) {
 186         if (subindex)
 187             return false;
 188         enum { S = 1 << MONOSYNTH_WAVE_BITS };
 189         int wave = dsp::clip(dsp::fastf2i_drm(value), 0, (int)wave_count - 1);
 190
 191         float *waveform = waves[wave].original;
 192         for (int i = 0; i < points; i++)
 193             data[i] = waveform[i * S / points];
 194         return true;
 195     }
 196     return false;
 197 }
 198
 199 bool monosynth_audio_module::get_graph(int index, int subindex, float *data, int points, cairo_iface *context)
 200 {
 201     monosynth_audio_module::precalculate_waves(NULL);
 202     // printf("get_graph %d %p %d wave1=%d wave2=%d\n", index, data, points, wave1, wave2);
 203     if (index == par_filtertype) {
 204         if (!running)
 205             return false;
 206         if (subindex > (is_stereo_filter() ? 1 : 0))
 207             return false;
 208         for (int i = 0; i < points; i++)
 209         {
 210             typedef complex<double> cfloat;
 211             double freq = 20.0 * pow (20000.0 / 20.0, i * 1.0 / points);
 212
 213             dsp::biquad_d1_lerp<float> &f = subindex ? filter2 : filter;
 214             float level = f.freq_gain(freq, srate);
 215             if (!is_stereo_filter())
 216                 level *= filter2.freq_gain(freq, srate);
 217             level *= fgain;
 218
 219             data[i] = log(level) / log(1024.0) + 0.5;
 220         }
 221         return true;
 222     }
 223     return get_static_graph(index, subindex, *params[index], data, points, context);
 224 }
 225
 226 void monosynth_audio_module::calculate_buffer_oscs(float lfo)
 227 {
 228     uint32_t shift = (int32_t)(0x70000000 * last_lfov * *params[par_lfopw]);
 229     int flag1 = (wave1 == wave_sqr);
 230     int flag2 = (wave2 == wave_sqr);
 231     uint32_t shift_delta = (int32_t)(0x70000000 * (lfo - last_lfov) * *params[par_lfopw] * (1.0 / step_size));
 232
 233     uint32_t shift1 = (flag1 << 31) + shift;
 234     uint32_t shift2 = (flag2 << 31) + shift;
 235     float mix1 = 1 - 2 * flag1, mix2 = 1 - 2 * flag2;
 236
 237     for (uint32_t i = 0; i < step_size; i++)
 238     {
 239         float osc1val = osc1.get_phaseshifted(shift1, mix1);
 240         float osc2val = osc2.get_phaseshifted(shift2, mix2);
 241         float wave = osc1val + (osc2val - osc1val) * xfade;
 242         buffer[i] = wave;
 243         shift1 += shift_delta;
 244         shift2 += shift_delta;
 245     }
 246     last_lfov = lfo;
 247 }
 248
 249 void monosynth_audio_module::calculate_buffer_ser()
 250 {
 251     filter.big_step(1.0 / step_size);
 252     filter2.big_step(1.0 / step_size);
 253     for (uint32_t i = 0; i < step_size; i++)
 254     {
 255         float wave = buffer[i] * fgain;
 256         wave = filter.process(wave);
 257         wave = filter2.process(wave);
 258         buffer[i] = wave;
 259         fgain += fgain_delta;
 260     }
 261 }
 262
 263 void monosynth_audio_module::calculate_buffer_single()
 264 {
 265     filter.big_step(1.0 / step_size);
 266     for (uint32_t i = 0; i < step_size; i++)
 267     {
 268         float wave = buffer[i] * fgain;
 269         wave = filter.process(wave);
 270         buffer[i] = wave;
 271         fgain += fgain_delta;
 272     }
 273 }
 274
 275 void monosynth_audio_module::calculate_buffer_stereo()
 276 {
 277     filter.big_step(1.0 / step_size);
 278     filter2.big_step(1.0 / step_size);
 279     for (uint32_t i = 0; i < step_size; i++)
 280     {
 281         float wave1 = buffer[i] * fgain;
 282         float wave2 = phaseshifter.process_ap(wave1);
 283         buffer[i] = fgain * filter.process(wave1);
 284         buffer2[i] = fgain * filter2.process(wave2);
 285         fgain += fgain_delta;
 286     }
 287 }
 288
 289 void monosynth_audio_module::delayed_note_on()
 290 {
 291     force_fadeout = false;
 292     stop_count = 0;
 293     porta_time = 0.f;
 294     start_freq = freq;
 295     target_freq = freq = 440 * pow(2.0, (queue_note_on - 69) / 12.0);
 296     ampctl = 1.0 + (queue_vel - 1.0) * *params[par_vel2amp];
 297     fltctl = 1.0 + (queue_vel - 1.0) * *params[par_vel2filter];
 298     set_frequency();
 299     osc1.waveform = waves[wave1 == wave_sqr ? wave_saw : wave1].get_level(osc1.phasedelta);
 300     osc2.waveform = waves[wave2 == wave_sqr ? wave_saw : wave2].get_level(osc2.phasedelta);
 301     if (!osc1.waveform) osc1.waveform = silence;
 302     if (!osc2.waveform) osc2.waveform = silence;
 303     lfo_clock = 0.f;
 304
 305     if (!running)
 306     {
 307         if (legato >= 2)
 308             porta_time = -1.f;
 309         osc1.reset();
 310         osc2.reset();
 311         filter.reset();
 312         filter2.reset();
 313         lfo.reset();
 314         switch((int)*params[par_oscmode])
 315         {
 316         case 1:
 317             osc2.phase = 0x80000000;
 318             break;
 319         case 2:
 320             osc2.phase = 0x40000000;
 321             break;
 322         case 3:
 323             osc1.phase = osc2.phase = 0x40000000;
 324             break;
 325         case 4:
 326             osc1.phase = 0x40000000;
 327             osc2.phase = 0xC0000000;
 328             break;
 329         case 5:
 330             // rand() is crap, but I don't have any better RNG in Calf yet
 331             osc1.phase = rand() << 16;
 332             osc2.phase = rand() << 16;
 333             break;
 334         default:
 335             break;
 336         }
 337         envelope.note_on();
 338         running = true;
 339     }
 340     if (legato >= 2 && !gate)
 341         porta_time = -1.f;
 342     gate = true;
 343     stopping = false;
 344     if (!(legato & 1) || envelope.released()) {
 345         envelope.note_on();
 346     }
 347     envelope.advance();
 348     queue_note_on = -1;
 349 }
 350
 351 void monosynth_audio_module::set_sample_rate(uint32_t sr) {
 352     srate = sr;
 353     crate = sr / step_size;
 354     odcr = (float)(1.0 / crate);
 355     phaseshifter.set_ap(1000.f, sr);
 356     fgain = 0.f;
 357     fgain_delta = 0.f;
 358     inertia_cutoff.ramp.set_length(crate / 30); // 1/30s
 359     inertia_pitchbend.ramp.set_length(crate / 30); // 1/30s
 360 }
 361
 362 void monosynth_audio_module::calculate_step()
 363 {
 364     if (queue_note_on != -1)
 365         delayed_note_on();
 366     else if (stopping)
 367     {
 368         running = false;
 369         dsp::zero(buffer, step_size);
 370         if (is_stereo_filter())
 371             dsp::zero(buffer2, step_size);
 372         envelope.advance();
 373         return;
 374     }
 375     lfo.set_freq(*params[par_lforate], crate);
 376     float porta_total_time = *params[par_portamento] * 0.001f;
 377
 378     if (porta_total_time >= 0.00101f && porta_time >= 0) {
 379         // XXXKF this is criminal, optimize!
 380         float point = porta_time / porta_total_time;
 381         if (point >= 1.0f) {
 382             freq = target_freq;
 383             porta_time = -1;
 384         } else {
 385             freq = start_freq + (target_freq - start_freq) * point;
 386             // freq = start_freq * pow(target_freq / start_freq, point);
 387             porta_time += odcr;
 388         }
 389     }
 390     float lfov = lfo.get() * std::min(1.0f, lfo_clock / *params[par_lfodelay]);
 391     lfov = lfov * dsp::lerp(1.f, modwheel_value, *params[par_mwhl_lfo]);
 392     lfo_clock += odcr;
 393     if (fabs(*params[par_lfopitch]) > small_value<float>())
 394         lfo_bend = pow(2.0f, *params[par_lfopitch] * lfov * (1.f / 1200.0f));
 395     inertia_pitchbend.step();
 396     set_frequency();
 397     envelope.advance();
 398     float env = envelope.value;
 399     inertia_cutoff.set_inertia(*params[par_cutoff]);
 400     cutoff = inertia_cutoff.get() * pow(2.0f, (lfov * *params[par_lfofilter] + env * fltctl * *params[par_envmod]) * (1.f / 1200.f));
 401     if (*params[par_keyfollow] > 0.01f)
 402         cutoff *= pow(freq / 264.f, *params[par_keyfollow]);
 403     cutoff = dsp::clip(cutoff , 10.f, 18000.f);
 404     float resonance = *params[par_resonance];
 405     float e2r = *params[par_envtores];
 406     float e2a = *params[par_envtoamp];
 407     resonance = resonance * (1 - e2r) + (0.7 + (resonance - 0.7) * env * env) * e2r;
 408     float cutoff2 = dsp::clip(cutoff * separation, 10.f, 18000.f);
 409     float newfgain = 0.f;
 410     if (filter_type != last_filter_type)
 411     {
 412         filter.y2 = filter.y1 = filter.x2 = filter.x1 = filter.y1;
 413         filter2.y2 = filter2.y1 = filter2.x2 = filter2.x1 = filter2.y1;
 414         last_filter_type = filter_type;
 415     }
 416     switch(filter_type)
 417     {
 418     case flt_lp12:
 419         filter.set_lp_rbj(cutoff, resonance, srate);
 420         filter2.set_null();
 421         newfgain = min(0.7f, 0.7f / resonance) * ampctl;
 422         break;
 423     case flt_hp12:
 424         filter.set_hp_rbj(cutoff, resonance, srate);
 425         filter2.set_null();
 426         newfgain = min(0.7f, 0.7f / resonance) * ampctl;
 427         break;
 428     case flt_lp24:
 429         filter.set_lp_rbj(cutoff, resonance, srate);
 430         filter2.set_lp_rbj(cutoff2, resonance, srate);
 431         newfgain = min(0.5f, 0.5f / resonance) * ampctl;
 432         break;
 433     case flt_lpbr:
 434         filter.set_lp_rbj(cutoff, resonance, srate);
 435         filter2.set_br_rbj(cutoff2, 1.0 / resonance, srate);
 436         newfgain = min(0.5f, 0.5f / resonance) * ampctl;
 437         break;
 438     case flt_hpbr:
 439         filter.set_hp_rbj(cutoff, resonance, srate);
 440         filter2.set_br_rbj(cutoff2, 1.0 / resonance, srate);
 441         newfgain = min(0.5f, 0.5f / resonance) * ampctl;
 442         break;
 443     case flt_2lp12:
 444         filter.set_lp_rbj(cutoff, resonance, srate);
 445         filter2.set_lp_rbj(cutoff2, resonance, srate);
 446         newfgain = min(0.7f, 0.7f / resonance) * ampctl;
 447         break;
 448     case flt_bp6:
 449         filter.set_bp_rbj(cutoff, resonance, srate);
 450         filter2.set_null();
 451         newfgain = ampctl;
 452         break;
 453     case flt_2bp6:
 454         filter.set_bp_rbj(cutoff, resonance, srate);
 455         filter2.set_bp_rbj(cutoff2, resonance, srate);
 456         newfgain = ampctl;
 457         break;
 458     }
 459     float aenv = env;
 460     if (*params[par_envtoamp] > 0.f)
 461         newfgain *= 1.0 - (1.0 - aenv) * e2a;
 462     fgain_delta = (newfgain - fgain) * (1.0 / step_size);
 463     calculate_buffer_oscs(lfov);
 464     switch(filter_type)
 465     {
 466     case flt_lp24:
 467     case flt_lpbr:
 468     case flt_hpbr: // Oomek's wish
 469         calculate_buffer_ser();
 470         break;
 471     case flt_lp12:
 472     case flt_hp12:
 473     case flt_bp6:
 474         calculate_buffer_single();
 475         break;
 476     case flt_2lp12:
 477     case flt_2bp6:
 478         calculate_buffer_stereo();
 479         break;
 480     }
 481     if ((envelope.state == adsr::STOP && !gate) || force_fadeout || (envelope.state == adsr::RELEASE && *params[par_envtoamp] <= 0.f))
 482     {
 483         enum { ramp = step_size * 4 };
 484         for (int i = 0; i < step_size; i++)
 485             buffer[i] *= (ramp - i - stop_count) * (1.0f / ramp);
 486         if (is_stereo_filter())
 487             for (int i = 0; i < step_size; i++)
 488                 buffer2[i] *= (ramp - i - stop_count) * (1.0f / ramp);
 489         stop_count += step_size;
 490         if (stop_count >= ramp)
 491             stopping = true;
 492     }
 493 }
 494
 495 void monosynth_audio_module::note_on(int note, int vel)
 496 {
 497     queue_note_on = note;
 498     last_key = note;
 499     queue_vel = vel / 127.f;
 500     stack.push(note);
 501 }
 502
 503 void monosynth_audio_module::note_off(int note, int vel)
 504 {
 505     stack.pop(note);
 506     // If releasing the currently played note, try to get another one from note stack.
 507     if (note == last_key) {
 508         if (stack.count())
 509         {
 510             last_key = note = stack.nth(stack.count() - 1);
 511             start_freq = freq;
 512             target_freq = freq = dsp::note_to_hz(note);
 513             porta_time = 0;
 514             set_frequency();
 515             if (!(legato & 1)) {
 516                 envelope.note_on();
 517                 stopping = false;
 518                 running = true;
 519             }
 520             return;
 521         }
 522         gate = false;
 523         envelope.note_off();
 524     }
 525 }
 526
 527
 528 void monosynth_audio_module::control_change(int controller, int value)
 529 {
 530     switch(controller)
 531     {
 532         case 1:
 533             modwheel_value_int = (modwheel_value_int & 127) | (value << 7);
 534             modwheel_value = modwheel_value_int / 16383.0;
 535             break;
 536         case 33:
 537             modwheel_value_int = (modwheel_value_int & (127 << 7)) | value;
 538             modwheel_value = modwheel_value_int / 16383.0;
 539             break;
 540         case 120: // all sounds off
 541             force_fadeout = true;
 542             // fall through
 543         case 123: // all notes off
 544             gate = false;
 545             queue_note_on = -1;
 546             envelope.note_off();
 547             stack.clear();
 548             break;
 549     }
 550 }
 551
 552 void monosynth_audio_module::deactivate()
 553 {
 554     gate = false;
 555     running = false;
 556     stopping = false;
 557     envelope.reset();
 558     stack.clear();
 559 }