src/organ.cpp

   1 /* Calf DSP Library
   2  * Example audio modules - organ
   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 <config.h>
  22
  23 #include <assert.h>
  24 #include <memory.h>
  25 #include <complex>
  26 #if USE_JACK
  27 #include <jack/jack.h>
  28 #endif
  29 #include <calf/giface.h>
  30 #include <calf/modules_synths.h>
  31 #include <iostream>
  32
  33 using namespace std;
  34 using namespace dsp;
  35 using namespace calf_plugins;
  36
  37 //////////////////////////////////////////////////////////////////////////////////////////////////////////
  38
  39 bool organ_audio_module::get_graph(int index, int subindex, float *data, int points, cairo_iface *context)
  40 {
  41     if (index == par_master) {
  42         organ_voice_base::precalculate_waves(progress_report);
  43         if (subindex)
  44             return false;
  45         float *waveforms[9];
  46         int S[9], S2[9];
  47         enum { small_waves = organ_voice_base::wave_count_small};
  48         for (int i = 0; i < 9; i++)
  49         {
  50             int wave = dsp::clip((int)(parameters->waveforms[i]), 0, (int)organ_voice_base::wave_count - 1);
  51             if (wave >= small_waves)
  52             {
  53                 waveforms[i] = organ_voice_base::get_big_wave(wave - small_waves).original;
  54                 S[i] = ORGAN_BIG_WAVE_SIZE;
  55                 S2[i] = ORGAN_WAVE_SIZE / 64;
  56             }
  57             else
  58             {
  59                 waveforms[i] = organ_voice_base::get_wave(wave).original;
  60                 S[i] = S2[i] = ORGAN_WAVE_SIZE;
  61             }
  62         }
  63         for (int i = 0; i < points; i++)
  64         {
  65             float sum = 0.f;
  66             for (int j = 0; j < 9; j++)
  67             {
  68                 float shift = parameters->phase[j] * S[j] / 360.0;
  69                 sum += parameters->drawbars[j] * waveforms[j][int(parameters->harmonics[j] * i * S2[j] / points + shift) & (S[j] - 1)];
  70             }
  71             data[i] = sum * 2 / (9 * 8);
  72         }
  73         return true;
  74     }
  75     return false;
  76 }
  77
  78 ////////////////////////////////////////////////////////////////////////////
  79
  80 organ_voice_base::small_wave_family (*organ_voice_base::waves)[organ_voice_base::wave_count_small];
  81 organ_voice_base::big_wave_family (*organ_voice_base::big_waves)[organ_voice_base::wave_count_big];
  82
  83 static void smoothen(bandlimiter<ORGAN_WAVE_BITS> &bl, float tmp[ORGAN_WAVE_SIZE])
  84 {
  85     bl.compute_spectrum(tmp);
  86     for (int i = 1; i <= ORGAN_WAVE_SIZE / 2; i++) {
  87         bl.spectrum[i] *= 1.0 / sqrt(i);
  88         bl.spectrum[ORGAN_WAVE_SIZE - i] *= 1.0 / sqrt(i);
  89     }
  90     bl.compute_waveform(tmp);
  91     normalize_waveform(tmp, ORGAN_WAVE_SIZE);
  92 }
  93
  94 static void phaseshift(bandlimiter<ORGAN_WAVE_BITS> &bl, float tmp[ORGAN_WAVE_SIZE])
  95 {
  96     bl.compute_spectrum(tmp);
  97     for (int i = 1; i <= ORGAN_WAVE_SIZE / 2; i++) {
  98         float frac = i * 2.0 / ORGAN_WAVE_SIZE;
  99         float phase = M_PI / sqrt(frac) ;
 100         complex<float> shift = complex<float>(cos(phase), sin(phase));
 101         bl.spectrum[i] *= shift;
 102         bl.spectrum[ORGAN_WAVE_SIZE - i] *= conj(shift);
 103     }
 104     bl.compute_waveform(tmp);
 105     normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 106 }
 107
 108 static void padsynth(bandlimiter<ORGAN_WAVE_BITS> blSrc, bandlimiter<ORGAN_BIG_WAVE_BITS> &blDest, organ_voice_base::big_wave_family &result, int bwscale = 20, float bell_factor = 0, bool foldover = false)
 109 {
 110     // kept in a vector to avoid putting large arrays on stack
 111     vector<complex<float> >orig_spectrum;
 112     orig_spectrum.resize(ORGAN_WAVE_SIZE / 2);
 113     for (int i = 0; i < ORGAN_WAVE_SIZE / 2; i++)
 114     {
 115         orig_spectrum[i] = blSrc.spectrum[i];
 116 //        printf("@%d = %f\n", i, abs(orig_spectrum[i]));
 117     }
 118
 119     int periods = (1 << ORGAN_BIG_WAVE_SHIFT) * ORGAN_BIG_WAVE_SIZE / ORGAN_WAVE_SIZE;
 120     for (int i = 0; i <= ORGAN_BIG_WAVE_SIZE / 2; i++) {
 121         blDest.spectrum[i] = 0;
 122     }
 123     int MAXHARM = (ORGAN_WAVE_SIZE >> (1 + ORGAN_BIG_WAVE_SHIFT));
 124     for (int i = 1; i <= MAXHARM; i++) {
 125         //float esc = 0.25 * (1 + 0.5 * log(i));
 126         float esc = 0.5;
 127         float amp = abs(blSrc.spectrum[i]);
 128         // fade out starting from half
 129         if (i >= MAXHARM / 2) {
 130             float pos = (i - MAXHARM/2) * 1.0 / (MAXHARM / 2);
 131             amp *= 1.0 - pos;
 132             amp *= 1.0 - pos;
 133         }
 134         int bw = 1 + 20 * i;
 135         float sum = 1;
 136         int delta = 1;
 137         if (bw > 20) delta = bw / 20;
 138         for (int j = delta; j <= bw; j+=delta)
 139         {
 140             float p = j * 1.0 / bw;
 141             sum += 2 * exp(-p * p * esc);
 142         }
 143         if (sum < 0.0001)
 144             continue;
 145         amp *= (ORGAN_BIG_WAVE_SIZE / ORGAN_WAVE_SIZE);
 146         amp /= sum;
 147         int orig = i * periods + bell_factor * cos(i);
 148         if (orig > 0 && orig < ORGAN_BIG_WAVE_SIZE / 2)
 149             blDest.spectrum[orig] += amp;
 150         for (int j = delta; j <= bw; j += delta)
 151         {
 152             float p = j * 1.0 / bw;
 153             float val = amp * exp(-p * p * esc);
 154             int dist = j * bwscale / 40;
 155             int pos = orig + dist;
 156             if (pos < 1 || pos >= ORGAN_BIG_WAVE_SIZE / 2)
 157                 continue;
 158             int pos2 = orig - dist;
 159             if (pos2 < 1 || pos2 >= ORGAN_BIG_WAVE_SIZE / 2)
 160                 continue;
 161             blDest.spectrum[pos] += val;
 162             if (j)
 163                 blDest.spectrum[pos2] += val;
 164         }
 165     }
 166     for (int i = 1; i <= ORGAN_BIG_WAVE_SIZE / 2; i++) {
 167         float phase = M_PI * 2 * (rand() & 255) / 256;
 168         complex<float> shift = complex<float>(cos(phase), sin(phase));
 169         blDest.spectrum[i] *= shift;
 170 //      printf("@%d = %f\n", i, abs(blDest.spectrum[i]));
 171
 172         blDest.spectrum[ORGAN_BIG_WAVE_SIZE - i] = conj(blDest.spectrum[i]);
 173     }
 174     // same as above - put large array on heap to avoid stack overflow in ingen
 175     vector<float> tmp;
 176     tmp.resize(ORGAN_BIG_WAVE_SIZE);
 177     blDest.compute_waveform(tmp.data());
 178     normalize_waveform(tmp.data(), ORGAN_BIG_WAVE_SIZE);
 179     blDest.compute_spectrum(tmp.data());
 180
 181     // limit is 1/2 of the number of harmonics of the original wave
 182     result.make_from_spectrum(blDest, foldover, ORGAN_WAVE_SIZE >> (1 + ORGAN_BIG_WAVE_SHIFT));
 183     memcpy(result.original, result.begin()->second, sizeof(result.original));
 184     #if 0
 185     blDest.compute_waveform(result);
 186     normalize_waveform(result, ORGAN_BIG_WAVE_SIZE);
 187     result[ORGAN_BIG_WAVE_SIZE] = result[0];
 188     for (int i =0 ; i<ORGAN_BIG_WAVE_SIZE + 1; i++)
 189         printf("%f\n", result[i]);
 190     #endif
 191 }
 192
 193 #define LARGE_WAVEFORM_PROGRESS() do { if (reporter) { progress += 100; reporter->report_progress(floor(progress / totalwaves), "Precalculating large waveforms"); } } while(0)
 194
 195
 196 void organ_voice_base::precalculate_waves(progress_report_iface *reporter)
 197 {
 198     static bool inited = false;
 199     if (!inited)
 200     {
 201         static organ_voice_base::small_wave_family waves[organ_voice_base::wave_count_small];
 202         static organ_voice_base::big_wave_family big_waves[organ_voice_base::wave_count_big];
 203         organ_voice_base::waves = &waves;
 204         organ_voice_base::big_waves = &big_waves;
 205
 206         float progress = 0.0;
 207         int totalwaves = 1 + wave_count_big;
 208         if (reporter)
 209             reporter->report_progress(0, "Precalculating small waveforms");
 210         float tmp[ORGAN_WAVE_SIZE];
 211         static bandlimiter<ORGAN_WAVE_BITS> bl;
 212         static bandlimiter<ORGAN_BIG_WAVE_BITS> blBig;
 213         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 214             tmp[i] = sin(i * 2 * M_PI / ORGAN_WAVE_SIZE);
 215         waves[wave_sine].make(bl, tmp);
 216         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 217             tmp[i] = (i < (ORGAN_WAVE_SIZE / 16)) ? 1 : 0;
 218         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 219         waves[wave_pulse].make(bl, tmp);
 220         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 221             tmp[i] = i < (ORGAN_WAVE_SIZE / 2) ? sin(i * 2 * 2 * M_PI / ORGAN_WAVE_SIZE) : 0;
 222         waves[wave_sinepl1].make(bl, tmp);
 223         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 224             tmp[i] = i < (ORGAN_WAVE_SIZE / 3) ? sin(i * 3 * 2 * M_PI / ORGAN_WAVE_SIZE) : 0;
 225         waves[wave_sinepl2].make(bl, tmp);
 226         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 227             tmp[i] = i < (ORGAN_WAVE_SIZE / 4) ? sin(i * 4 * 2 * M_PI / ORGAN_WAVE_SIZE) : 0;
 228         waves[wave_sinepl3].make(bl, tmp);
 229         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 230             tmp[i] = (i < (ORGAN_WAVE_SIZE / 2)) ? 1 : -1;
 231         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 232         waves[wave_sqr].make(bl, tmp);
 233         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 234             tmp[i] = -1 + (i * 2.0 / ORGAN_WAVE_SIZE);
 235         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 236         waves[wave_saw].make(bl, tmp);
 237
 238         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 239             tmp[i] = (i < (ORGAN_WAVE_SIZE / 2)) ? 1 : -1;
 240         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 241         smoothen(bl, tmp);
 242         waves[wave_ssqr].make(bl, tmp);
 243
 244         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 245             tmp[i] = -1 + (i * 2.0 / ORGAN_WAVE_SIZE);
 246         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 247         smoothen(bl, tmp);
 248         waves[wave_ssaw].make(bl, tmp);
 249
 250         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 251             tmp[i] = (i < (ORGAN_WAVE_SIZE / 16)) ? 1 : 0;
 252         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 253         smoothen(bl, tmp);
 254         waves[wave_spls].make(bl, tmp);
 255         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 256             tmp[i] = i < (ORGAN_WAVE_SIZE / 1.5) ? sin(i * 1.5 * 2 * M_PI / ORGAN_WAVE_SIZE) : 0;
 257         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 258         waves[wave_sinepl05].make(bl, tmp);
 259         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 260             tmp[i] = i < (ORGAN_WAVE_SIZE / 1.5) ? (i < ORGAN_WAVE_SIZE / 3 ? -1 : +1) : 0;
 261         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 262         waves[wave_sqr05].make(bl, tmp);
 263         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 264             tmp[i] = sin(i * M_PI / ORGAN_WAVE_SIZE);
 265         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 266         waves[wave_halfsin].make(bl, tmp);
 267         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 268             tmp[i] = sin(i * 3 * M_PI / ORGAN_WAVE_SIZE);
 269         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 270         waves[wave_clvg].make(bl, tmp);
 271         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 272         {
 273             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 274             float fm = 0.3 * sin(6*ph) + 0.2 * sin(11*ph) + 0.2 * cos(17*ph) - 0.2 * cos(19*ph);
 275             tmp[i] = sin(5*ph + fm) + 0.7 * cos(7*ph - fm);
 276         }
 277         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 278         waves[wave_bell].make(bl, tmp, true);
 279         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 280         {
 281             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 282             float fm = 0.3 * sin(3*ph) + 0.3 * sin(11*ph) + 0.3 * cos(17*ph) - 0.3 * cos(19*ph)  + 0.3 * cos(25*ph)  - 0.3 * cos(31*ph) + 0.3 * cos(37*ph);
 283             tmp[i] = sin(3*ph + fm) + cos(7*ph - fm);
 284         }
 285         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 286         waves[wave_bell2].make(bl, tmp, true);
 287         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 288         {
 289             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 290             float fm = 0.5 * sin(3*ph) + 0.3 * sin(5*ph) + 0.3 * cos(6*ph) - 0.3 * cos(9*ph);
 291             tmp[i] = sin(4*ph + fm) + cos(ph - fm);
 292         }
 293         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 294         waves[wave_w1].make(bl, tmp);
 295         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 296         {
 297             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 298             tmp[i] = sin(ph) * sin(2 * ph) * sin(4 * ph) * sin(8 * ph);
 299         }
 300         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 301         waves[wave_w2].make(bl, tmp);
 302         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 303         {
 304             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 305             tmp[i] = sin(ph) * sin(3 * ph) * sin(5 * ph) * sin(7 * ph) * sin(9 * ph);
 306         }
 307         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 308         waves[wave_w3].make(bl, tmp);
 309         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 310         {
 311             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 312             tmp[i] = sin(ph + 2 * sin(ph + 2 * sin(ph)));
 313         }
 314         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 315         waves[wave_w4].make(bl, tmp);
 316         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 317         {
 318             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 319             tmp[i] = ph * sin(ph);
 320         }
 321         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 322         waves[wave_w5].make(bl, tmp);
 323         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 324         {
 325             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 326             tmp[i] = ph * sin(ph) + (2 * M_PI - ph) * sin(2 * ph);
 327         }
 328         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 329         waves[wave_w6].make(bl, tmp);
 330         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 331         {
 332             float ph = i * 1.0 / ORGAN_WAVE_SIZE;
 333             tmp[i] = exp(-ph * ph);
 334         }
 335         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 336         waves[wave_w7].make(bl, tmp);
 337         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 338         {
 339             float ph = i * 1.0 / ORGAN_WAVE_SIZE;
 340             tmp[i] = exp(-ph * sin(2 * M_PI * ph));
 341         }
 342         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 343         waves[wave_w8].make(bl, tmp);
 344         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 345         {
 346             float ph = i * 1.0 / ORGAN_WAVE_SIZE;
 347             tmp[i] = sin(2 * M_PI * ph * ph);
 348         }
 349         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 350         waves[wave_w9].make(bl, tmp);
 351
 352         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 353             tmp[i] = -1 + (i * 2.0 / ORGAN_WAVE_SIZE);
 354         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 355         phaseshift(bl, tmp);
 356         waves[wave_dsaw].make(bl, tmp);
 357
 358         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 359             tmp[i] = (i < (ORGAN_WAVE_SIZE / 2)) ? 1 : -1;
 360         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 361         phaseshift(bl, tmp);
 362         waves[wave_dsqr].make(bl, tmp);
 363
 364         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 365             tmp[i] = (i < (ORGAN_WAVE_SIZE / 16)) ? 1 : 0;
 366         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 367         phaseshift(bl, tmp);
 368         waves[wave_dpls].make(bl, tmp);
 369
 370         LARGE_WAVEFORM_PROGRESS();
 371         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 372             tmp[i] = -1 + (i * 2.0 / ORGAN_WAVE_SIZE);
 373         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 374         bl.compute_spectrum(tmp);
 375         padsynth(bl, blBig, big_waves[wave_strings - wave_count_small], 15);
 376
 377         LARGE_WAVEFORM_PROGRESS();
 378         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 379             tmp[i] = -1 + (i * 2.0 / ORGAN_WAVE_SIZE);
 380         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 381         bl.compute_spectrum(tmp);
 382         padsynth(bl, blBig, big_waves[wave_strings2 - wave_count_small], 40);
 383
 384         LARGE_WAVEFORM_PROGRESS();
 385         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 386             tmp[i] = sin(i * 2 * M_PI / ORGAN_WAVE_SIZE);
 387         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 388         bl.compute_spectrum(tmp);
 389         padsynth(bl, blBig, big_waves[wave_sinepad - wave_count_small], 20);
 390
 391         LARGE_WAVEFORM_PROGRESS();
 392         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 393         {
 394             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 395             float fm = 0.3 * sin(6*ph) + 0.2 * sin(11*ph) + 0.2 * cos(17*ph) - 0.2 * cos(19*ph);
 396             tmp[i] = sin(5*ph + fm) + 0.7 * cos(7*ph - fm);
 397         }
 398         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 399         bl.compute_spectrum(tmp);
 400         padsynth(bl, blBig, big_waves[wave_bellpad - wave_count_small], 30, 30, true);
 401
 402         LARGE_WAVEFORM_PROGRESS();
 403         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 404         {
 405             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 406             float fm = 0.3 * sin(3*ph) + 0.2 * sin(4*ph) + 0.2 * cos(5*ph) - 0.2 * cos(6*ph);
 407             tmp[i] = sin(2*ph + fm) + 0.7 * cos(3*ph - fm);
 408         }
 409         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 410         bl.compute_spectrum(tmp);
 411         padsynth(bl, blBig, big_waves[wave_space - wave_count_small], 30, 30);
 412
 413         LARGE_WAVEFORM_PROGRESS();
 414         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 415         {
 416             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 417             float fm = 0.5 * sin(ph) + 0.5 * sin(2*ph) + 0.5 * sin(3*ph);
 418             tmp[i] = sin(ph + fm) + 0.5 * cos(7*ph - 2 * fm) + 0.25 * cos(13*ph - 4 * fm);
 419         }
 420         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 421         bl.compute_spectrum(tmp);
 422         padsynth(bl, blBig, big_waves[wave_choir - wave_count_small], 50, 10);
 423
 424         LARGE_WAVEFORM_PROGRESS();
 425         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 426         {
 427             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 428             float fm = sin(ph) ;
 429             tmp[i] = sin(ph + fm) + 0.25 * cos(11*ph - 2 * fm) + 0.125 * cos(23*ph - 2 * fm) + 0.0625 * cos(49*ph - 2 * fm);
 430         }
 431         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 432         bl.compute_spectrum(tmp);
 433         padsynth(bl, blBig, big_waves[wave_choir2 - wave_count_small], 50, 10);
 434
 435         LARGE_WAVEFORM_PROGRESS();
 436         for (int i = 0; i < ORGAN_WAVE_SIZE; i++)
 437         {
 438             float ph = i * 2 * M_PI / ORGAN_WAVE_SIZE;
 439             float fm = sin(ph) ;
 440             tmp[i] = sin(ph + 4 * fm) + 0.5 * sin(2 * ph + 4 * ph);
 441         }
 442         normalize_waveform(tmp, ORGAN_WAVE_SIZE);
 443         bl.compute_spectrum(tmp);
 444         padsynth(bl, blBig, big_waves[wave_choir3 - wave_count_small], 50, 10);
 445         LARGE_WAVEFORM_PROGRESS();
 446
 447         inited = true;
 448     }
 449 }
 450
 451 organ_voice_base::organ_voice_base(organ_parameters *_parameters, int &_sample_rate_ref, bool &_released_ref)
 452 : parameters(_parameters)
 453 , sample_rate_ref(_sample_rate_ref)
 454 , released_ref(_released_ref)
 455 {
 456     note = -1;
 457 }
 458
 459 void organ_voice_base::render_percussion_to(float (*buf)[2], int nsamples)
 460 {
 461     if (note == -1)
 462         return;
 463
 464     if (!pamp.get_active())
 465         return;
 466     if (parameters->percussion_level < small_value<float>())
 467         return;
 468     float level = parameters->percussion_level * 9;
 469     static float zeros[ORGAN_WAVE_SIZE];
 470     // XXXKF the decay needs work!
 471     double age_const = parameters->perc_decay_const;
 472     double fm_age_const = parameters->perc_fm_decay_const;
 473     int timbre = parameters->get_percussion_wave();
 474     if (timbre < 0 || timbre >= wave_count_small)
 475         return;
 476     int timbre2 = parameters->get_percussion_fm_wave();
 477     if (timbre2 < 0 || timbre2 >= wave_count_small)
 478         timbre2 = wave_sine;
 479     float *fmdata = (*waves)[timbre2].get_level(moddphase.get());
 480     if (!fmdata)
 481         fmdata = zeros;
 482     float *data = (*waves)[timbre].get_level(dpphase.get());
 483     if (!data) {
 484         pamp.deactivate();
 485         return;
 486     }
 487     float s = parameters->percussion_stereo * ORGAN_WAVE_SIZE * (0.5 / 360.0);
 488     for (int i = 0; i < nsamples; i++) {
 489         float fm = wave(fmdata, modphase);
 490         fm *= ORGAN_WAVE_SIZE * parameters->percussion_fm_depth * fm_amp.get();
 491         modphase += moddphase;
 492         fm_amp.age_exp(fm_age_const, 1.0 / 32768.0);
 493
 494         float lamp = level * pamp.get();
 495         buf[i][0] += lamp * wave(data, pphase + dsp::fixed_point<int64_t, 52>(fm - s));
 496         buf[i][1] += lamp * wave(data, pphase + dsp::fixed_point<int64_t, 52>(fm + s));
 497         if (released_ref)
 498             pamp.age_lin(rel_age_const,0.0);
 499         else
 500             pamp.age_exp(age_const, 1.0 / 32768.0);
 501         pphase += dpphase;
 502     }
 503 }
 504
 505 void organ_vibrato::reset()
 506 {
 507     for (int i = 0; i < VibratoSize; i++)
 508         vibrato_x1[i][0] = vibrato_y1[i][0] = vibrato_x1[i][1] = vibrato_y1[i][1] = 0.f;
 509     lfo_phase = 0.f;
 510 }
 511
 512 void organ_vibrato::process(organ_parameters *parameters, float (*data)[2], unsigned int len, float sample_rate)
 513 {
 514     float lfo1 = lfo_phase < 0.5 ? 2 * lfo_phase : 2 - 2 * lfo_phase;
 515     float lfo_phase2 = lfo_phase + parameters->lfo_phase * (1.0 / 360.0);
 516     if (lfo_phase2 >= 1.0)
 517         lfo_phase2 -= 1.0;
 518     float lfo2 = lfo_phase2 < 0.5 ? 2 * lfo_phase2 : 2 - 2 * lfo_phase2;
 519     lfo_phase += parameters->lfo_rate * len / sample_rate;
 520     if (lfo_phase >= 1.0)
 521         lfo_phase -= 1.0;
 522     if (!len)
 523         return;
 524     float olda0[2] = {vibrato[0].a0, vibrato[1].a0};
 525     vibrato[0].set_ap(3000 + 7000 * parameters->lfo_amt * lfo1 * lfo1, sample_rate);
 526     vibrato[1].set_ap(3000 + 7000 * parameters->lfo_amt * lfo2 * lfo2, sample_rate);
 527     float ilen = 1.0 / len;
 528     float deltaa0[2] = {(vibrato[0].a0 - olda0[0])*ilen, (vibrato[1].a0 - olda0[1])*ilen};
 529
 530     float vib_wet = parameters->lfo_wet;
 531     for (int c = 0; c < 2; c++)
 532     {
 533         for (unsigned int i = 0; i < len; i++)
 534         {
 535             float v = data[i][c];
 536             float v0 = v;
 537             float coeff = olda0[c] + deltaa0[c] * i;
 538             for (int t = 0; t < VibratoSize; t++)
 539                 v = vibrato[c].process_ap(v, vibrato_x1[t][c], vibrato_y1[t][c], coeff);
 540
 541             data[i][c] += (v - v0) * vib_wet;
 542         }
 543         for (int t = 0; t < VibratoSize; t++)
 544         {
 545             sanitize(vibrato_x1[t][c]);
 546             sanitize(vibrato_y1[t][c]);
 547         }
 548     }
 549 }
 550
 551 void organ_voice::update_pitch()
 552 {
 553     organ_voice_base::update_pitch();
 554     dphase.set(dsp::midi_note_to_phase(note, 100 * parameters->global_transpose + parameters->global_detune, sample_rate) * parameters->pitch_bend);
 555 }
 556
 557 void organ_voice::render_block() {
 558     if (note == -1)
 559         return;
 560
 561     dsp::zero(&output_buffer[0][0], Channels * BlockSize);
 562     dsp::zero(&aux_buffers[1][0][0], 2 * Channels * BlockSize);
 563     if (!amp.get_active())
 564     {
 565         if (use_percussion())
 566             render_percussion_to(output_buffer, BlockSize);
 567         return;
 568     }
 569
 570     update_pitch();
 571     dsp::fixed_point<int, 20> tphase, tdphase;
 572     unsigned int foldvalue = parameters->foldvalue;
 573     int vibrato_mode = fastf2i_drm(parameters->lfo_mode);
 574     for (int h = 0; h < 9; h++)
 575     {
 576         float amp = parameters->drawbars[h];
 577         if (amp < small_value<float>())
 578             continue;
 579         float *data;
 580         dsp::fixed_point<int, 24> hm = dsp::fixed_point<int, 24>(parameters->multiplier[h]);
 581         int waveid = (int)parameters->waveforms[h];
 582         if (waveid < 0 || waveid >= wave_count)
 583             waveid = 0;
 584
 585         uint32_t rate = (dphase * hm).get();
 586         if (waveid >= wave_count_small)
 587         {
 588             float *data = (*big_waves)[waveid - wave_count_small].get_level(rate >> (ORGAN_BIG_WAVE_BITS - ORGAN_WAVE_BITS + ORGAN_BIG_WAVE_SHIFT));
 589             if (!data)
 590                 continue;
 591             hm.set(hm.get() >> ORGAN_BIG_WAVE_SHIFT);
 592             dsp::fixed_point<int64_t, 20> tphase, tdphase;
 593             tphase.set(((phase * hm).get()) + parameters->phaseshift[h]);
 594             tdphase.set(rate >> ORGAN_BIG_WAVE_SHIFT);
 595             float ampl = amp * 0.5f * (1 - parameters->pan[h]);
 596             float ampr = amp * 0.5f * (1 + parameters->pan[h]);
 597             float (*out)[Channels] = aux_buffers[dsp::fastf2i_drm(parameters->routing[h])];
 598
 599             for (int i=0; i < (int)BlockSize; i++) {
 600                 float wv = big_wave(data, tphase);
 601                 out[i][0] += wv * ampl;
 602                 out[i][1] += wv * ampr;
 603                 tphase += tdphase;
 604             }
 605         }
 606         else
 607         {
 608             unsigned int foldback = 0;
 609             while (rate > foldvalue)
 610             {
 611                 rate >>= 1;
 612                 foldback++;
 613             }
 614             hm.set(hm.get() >> foldback);
 615             data = (*waves)[waveid].get_level(rate);
 616             if (!data)
 617                 continue;
 618             tphase.set((uint32_t)((phase * hm).get()) + parameters->phaseshift[h]);
 619             tdphase.set((uint32_t)rate);
 620             float ampl = amp * 0.5f * (1 - parameters->pan[h]);
 621             float ampr = amp * 0.5f * (1 + parameters->pan[h]);
 622             float (*out)[Channels] = aux_buffers[dsp::fastf2i_drm(parameters->routing[h])];
 623
 624             for (int i=0; i < (int)BlockSize; i++) {
 625                 float wv = wave(data, tphase);
 626                 out[i][0] += wv * ampl;
 627                 out[i][1] += wv * ampr;
 628                 tphase += tdphase;
 629             }
 630         }
 631     }
 632     expression.set_inertia(parameters->cutoff);
 633     phase += dphase * BlockSize;
 634     float escl[EnvCount], eval[EnvCount];
 635     for (int i = 0; i < EnvCount; i++)
 636         escl[i] = (1.f + parameters->envs[i].velscale * (velocity - 1.f));
 637
 638     for (int i = 0; i < EnvCount; i++)
 639         eval[i] = envs[i].value * escl[i];
 640     for (int i = 0; i < FilterCount; i++)
 641     {
 642         float mod = parameters->filters[i].envmod[0] * eval[0] ;
 643         mod += parameters->filters[i].keyf * 100 * (note - 60);
 644         for (int j = 1; j < EnvCount; j++)
 645         {
 646             mod += parameters->filters[i].envmod[j] * eval[j];
 647         }
 648         if (i) mod += expression.get() * 1200 * 4;
 649         float fc = parameters->filters[i].cutoff * pow(2.0f, mod * (1.f / 1200.f));
 650         filterL[i].set_lp_rbj(dsp::clip<float>(fc, 10, 18000), parameters->filters[i].resonance, sample_rate);
 651         filterR[i].copy_coeffs(filterL[i]);
 652     }
 653     float amp_pre[ampctl_count - 1], amp_post[ampctl_count - 1];
 654     for (int i = 0; i < ampctl_count - 1; i++)
 655     {
 656         amp_pre[i] = 1.f;
 657         amp_post[i] = 1.f;
 658     }
 659     bool any_running = false;
 660     for (int i = 0; i < EnvCount; i++)
 661     {
 662         float pre = eval[i];
 663         envs[i].advance();
 664         int mode = fastf2i_drm(parameters->envs[i].ampctl);
 665         if (!envs[i].stopped())
 666             any_running = true;
 667         if (mode == ampctl_none)
 668             continue;
 669         float post = envs[i].value * escl[i];
 670         amp_pre[mode - 1] *= pre;
 671         amp_post[mode - 1] *= post;
 672     }
 673     if (vibrato_mode >= lfomode_direct && vibrato_mode <= lfomode_filter2)
 674         vibrato.process(parameters, aux_buffers[vibrato_mode - lfomode_direct], BlockSize, sample_rate);
 675     if (!any_running)
 676         finishing = true;
 677     // calculate delta from pre and post
 678     for (int i = 0; i < ampctl_count - 1; i++)
 679         amp_post[i] = (amp_post[i] - amp_pre[i]) * (1.0 / BlockSize);
 680     float a0 = amp_pre[0], a1 = amp_pre[1], a2 = amp_pre[2], a3 = amp_pre[3];
 681     float d0 = amp_post[0], d1 = amp_post[1], d2 = amp_post[2], d3 = amp_post[3];
 682     if (parameters->filter_chain >= 0.5f)
 683     {
 684         for (int i=0; i < (int) BlockSize; i++) {
 685             output_buffer[i][0] = a3 * (a0 * output_buffer[i][0] + a2 * filterL[1].process(a1 * filterL[0].process(aux_buffers[1][i][0]) + aux_buffers[2][i][0]));
 686             output_buffer[i][1] = a3 * (a0 * output_buffer[i][1] + a2 * filterR[1].process(a1 * filterR[0].process(aux_buffers[1][i][1]) + aux_buffers[2][i][1]));
 687             a0 += d0, a1 += d1, a2 += d2, a3 += d3;
 688         }
 689     }
 690     else
 691     {
 692         for (int i=0; i < (int) BlockSize; i++) {
 693             output_buffer[i][0] = a3 * (a0 * output_buffer[i][0] + a1 * filterL[0].process(aux_buffers[1][i][0]) + a2 * filterL[1].process(aux_buffers[2][i][0]));
 694             output_buffer[i][1] = a3 * (a0 * output_buffer[i][1] + a1 * filterR[0].process(aux_buffers[1][i][1]) + a2 * filterR[1].process(aux_buffers[2][i][1]));
 695             a0 += d0, a1 += d1, a2 += d2, a3 += d3;
 696         }
 697     }
 698     filterL[0].sanitize();
 699     filterR[0].sanitize();
 700     filterL[1].sanitize();
 701     filterR[1].sanitize();
 702     if (vibrato_mode == lfomode_voice)
 703         vibrato.process(parameters, output_buffer, BlockSize, sample_rate);
 704
 705     if (finishing)
 706     {
 707         for (int i = 0; i < (int) BlockSize; i++) {
 708             output_buffer[i][0] *= amp.get();
 709             output_buffer[i][1] *= amp.get();
 710             amp.age_lin((1.0/44100.0)/0.03,0.0);
 711         }
 712     }
 713
 714     if (use_percussion())
 715         render_percussion_to(output_buffer, BlockSize);
 716 }
 717
 718 void drawbar_organ::update_params()
 719 {
 720     parameters->perc_decay_const = dsp::decay::calc_exp_constant(1.0 / 1024.0, 0.001 * parameters->percussion_time * sample_rate);
 721     parameters->perc_fm_decay_const = dsp::decay::calc_exp_constant(1.0 / 1024.0, 0.001 * parameters->percussion_fm_time * sample_rate);
 722     for (int i = 0; i < 9; i++)
 723     {
 724         parameters->multiplier[i] = parameters->harmonics[i] * pow(2.0, parameters->detune[i] * (1.0 / 1200.0));
 725         parameters->phaseshift[i] = int(parameters->phase[i] * 65536 / 360) << 16;
 726     }
 727     double dphase = dsp::midi_note_to_phase((int)parameters->foldover, 0, sample_rate);
 728     parameters->foldvalue = (int)(dphase);
 729 }
 730
 731 void drawbar_organ::pitch_bend(int amt)
 732 {
 733     parameters->pitch_bend = pow(2.0, amt * 2 / (12.0 * 8192));
 734     for (list<voice *>::iterator i = active_voices.begin(); i != active_voices.end(); i++)
 735     {
 736         organ_voice *v = dynamic_cast<organ_voice *>(*i);
 737         v->update_pitch();
 738     }
 739     percussion.update_pitch();
 740 }
 741
 742 void organ_audio_module::execute(int cmd_no)
 743 {
 744     switch(cmd_no)
 745     {
 746         case 0:
 747             panic_flag = true;
 748             break;
 749     }
 750 }
 751
 752 void organ_voice_base::perc_note_on(int note, int vel)
 753 {
 754     perc_reset();
 755     released_ref = false;
 756     this->note = note;
 757     pamp.set(1.0f + (vel - 127) * parameters->percussion_vel2amp / 127.0);
 758     update_pitch();
 759     float (*kt)[2] = parameters->percussion_keytrack;
 760     // assume last point (will be put there by padding)
 761     fm_keytrack = kt[ORGAN_KEYTRACK_POINTS - 1][1];
 762     // yes binary search would be nice if we had more than those crappy 4 points
 763     for (int i = 0; i < ORGAN_KEYTRACK_POINTS - 1; i++)
 764     {
 765         float &lower = kt[i][0], upper = kt[i + 1][0];
 766         if (note >= lower && note < upper)
 767         {
 768             fm_keytrack = kt[i][1] + (note - lower) * (kt[i + 1][1] - kt[i][1]) / (upper - lower);
 769             break;
 770         }
 771     }
 772     fm_amp.set(fm_keytrack * (1.0f + (vel - 127) * parameters->percussion_vel2fm / 127.0));
 773 }
 774
 775 char *organ_audio_module::configure(const char *key, const char *value)
 776 {
 777     if (!strcmp(key, "map_curve"))
 778     {
 779         var_map_curve = value;
 780         stringstream ss(value);
 781         int i = 0;
 782         float x = 0, y = 1;
 783         if (*value)
 784         {
 785             int points;
 786             ss >> points;
 787             for (i = 0; i < points; i++)
 788             {
 789                 static const int whites[] = { 0, 2, 4, 5, 7, 9, 11 };
 790                 ss >> x >> y;
 791                 int wkey = (int)(x * 71);
 792                 x = whites[wkey % 7] + 12 * (wkey / 7);
 793                 parameters->percussion_keytrack[i][0] = x;
 794                 parameters->percussion_keytrack[i][1] = y;
 795                 // cout << "(" << x << ", " << y << ")" << endl;
 796             }
 797         }
 798         // pad with constant Y
 799         for (; i < ORGAN_KEYTRACK_POINTS; i++) {
 800             parameters->percussion_keytrack[i][0] = x;
 801             parameters->percussion_keytrack[i][1] = y;
 802         }
 803         return NULL;
 804     }
 805     cout << "Set unknown configure value " << key << " to " << value << endl;
 806     return NULL;
 807 }
 808
 809 void organ_audio_module::send_configures(send_configure_iface *sci)
 810 {
 811     sci->send_configure("map_curve", var_map_curve.c_str());
 812 }
 813
 814 void organ_audio_module::deactivate()
 815 {
 816
 817 }