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 <calf/giface.h>
22 #include <calf/modules_synths.h>
23
24 using namespace dsp;
25 using namespace calf_plugins;
26 using namespace std;
27
28 float silence[4097];
29
FORWARD_DECLARE_METADATA(monosynth)30 FORWARD_DECLARE_METADATA(monosynth)
31
32 monosynth_audio_module::monosynth_audio_module()
33 : mod_matrix_impl(mod_matrix_data, &mm_metadata)
34 , inertia_cutoff(1)
35 , inertia_pitchbend(1)
36 , inertia_pressure(64)
37 {
38 }
39
reset()40 void monosynth_audio_module::reset()
41 {
42 last_stretch1 = 0;
43 stopping = false;
44 running = false;
45 output_pos = 0;
46 queue_note_on = -1;
47 inertia_pitchbend.set_now(1.f);
48 lfo_bend = 1.0;
49 modwheel_value = 0.f;
50 modwheel_value_int = 0;
51 inertia_cutoff.set_now(*params[par_cutoff]);
52 inertia_pressure.set_now(0);
53 osc1.phasedelta = 0;
54 osc2.phasedelta = 0;
55 filter.reset();
56 filter2.reset();
57 stack.clear();
58 last_pwshift1 = last_pwshift2 = 0;
59 last_stretch1 = 65536;
60 last_xfade = 0;
61 last_unison = 0.0;
62 queue_note_on_and_off = false;
63 prev_wave1 = -1;
64 prev_wave2 = -1;
65 wave1 = -1;
66 wave2 = -1;
67 queue_note_on = -1;
68 last_filter_type = -1;
69 lfo_clock = 0.f;
70 }
71
activate()72 void monosynth_audio_module::activate()
73 {
74 reset();
75 }
76
77 waveform_family<MONOSYNTH_WAVE_BITS> *monosynth_audio_module::waves;
78
precalculate_waves(progress_report_iface * reporter)79 void monosynth_audio_module::precalculate_waves(progress_report_iface *reporter)
80 {
81 float data[1 << MONOSYNTH_WAVE_BITS];
82 bandlimiter<MONOSYNTH_WAVE_BITS> bl;
83
84 if (waves)
85 return;
86
87 static waveform_family<MONOSYNTH_WAVE_BITS> waves_data[wave_count];
88 waves = waves_data;
89
90 enum { S = 1 << MONOSYNTH_WAVE_BITS, HS = S / 2, QS = S / 4, QS3 = 3 * QS };
91 float iQS = 1.0 / QS;
92
93 if (reporter)
94 reporter->report_progress(0, "Precalculating waveforms");
95
96 // yes these waves don't have really perfect 1/x spectrum because of aliasing
97 // (so what?)
98 for (int i = 0 ; i < HS; i++)
99 data[i] = (float)(i * 1.0 / HS),
100 data[i + HS] = (float)(i * 1.0 / HS - 1.0f);
101 waves[wave_saw].make(bl, data);
102
103 // this one is dummy, fake and sham, we're using a difference of two sawtooths for square wave due to PWM
104 for (int i = 0 ; i < S; i++)
105 data[i] = (float)(i < HS ? -1.f : 1.f);
106 waves[wave_sqr].make(bl, data, 4);
107
108 for (int i = 0 ; i < S; i++)
109 data[i] = (float)(i < (64 * S / 2048)? -1.f : 1.f);
110 waves[wave_pulse].make(bl, data);
111
112 for (int i = 0 ; i < S; i++)
113 data[i] = (float)sin(i * M_PI / HS);
114 waves[wave_sine].make(bl, data);
115
116 for (int i = 0 ; i < QS; i++) {
117 data[i] = i * iQS,
118 data[i + QS] = 1 - i * iQS,
119 data[i + HS] = - i * iQS,
120 data[i + QS3] = -1 + i * iQS;
121 }
122 waves[wave_triangle].make(bl, data);
123
124 for (int i = 0, j = 1; i < S; i++) {
125 data[i] = -1 + j * 1.0 / HS;
126 if (i == j)
127 j *= 2;
128 }
129 waves[wave_varistep].make(bl, data);
130
131 for (int i = 0; i < S; i++) {
132 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));
133 }
134 normalize_waveform(data, S);
135 waves[wave_skewsaw].make(bl, data);
136 for (int i = 0; i < S; i++) {
137 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);
138 }
139 normalize_waveform(data, S);
140 waves[wave_skewsqr].make(bl, data);
141
142 if (reporter)
143 reporter->report_progress(50, "Precalculating waveforms");
144
145 for (int i = 0; i < S; i++) {
146 if (i < QS3) {
147 float p = i * 1.0 / QS3;
148 data[i] = sin(M_PI * p * p * p);
149 } else {
150 float p = (i - QS3 * 1.0) / QS;
151 data[i] = -0.5 * sin(3 * M_PI * p * p);
152 }
153 }
154 normalize_waveform(data, S);
155 waves[wave_test1].make(bl, data);
156 for (int i = 0; i < S; i++) {
157 data[i] = exp(-i * 1.0 / HS) * sin(i * M_PI / HS) * cos(2 * M_PI * i / HS);
158 }
159 normalize_waveform(data, S);
160 waves[wave_test2].make(bl, data);
161 for (int i = 0; i < S; i++) {
162 //int ii = (i < HS) ? i : S - i;
163 int ii = HS;
164 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));
165 }
166 normalize_waveform(data, S);
167 waves[wave_test3].make(bl, data);
168 for (int i = 0; i < S; i++) {
169 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)));
170 }
171 normalize_waveform(data, S);
172 waves[wave_test4].make(bl, data);
173 for (int i = 0; i < S; i++) {
174 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));
175 }
176 normalize_waveform(data, S);
177 waves[wave_test5].make(bl, data);
178 for (int i = 0; i < S; i++) {
179 if (i < HS)
180 data[i] = sin(i * 2 * M_PI / HS);
181 else
182 if (i < 3 * S / 4)
183 data[i] = sin(i * 4 * M_PI / HS);
184 else
185 if (i < 7 * S / 8)
186 data[i] = sin(i * 8 * M_PI / HS);
187 else
188 data[i] = sin(i * 8 * M_PI / HS) * (S - i) / (S / 8);
189 }
190 normalize_waveform(data, S);
191 waves[wave_test6].make(bl, data);
192 for (int i = 0; i < S; i++) {
193 int j = i >> (MONOSYNTH_WAVE_BITS - 11);
194 data[i] = (j ^ 0x1D0) * 1.0 / HS - 1;
195 }
196 normalize_waveform(data, S);
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 normalize_waveform(data, S);
203 waves[wave_test8].make(bl, data);
204 if (reporter)
205 reporter->report_progress(100, "");
206
207 }
208
get_graph(int index,int subindex,int phase,float * data,int points,cairo_iface * context,int * mode) const209 bool monosynth_audio_module::get_graph(int index, int subindex, int phase, float *data, int points, cairo_iface *context, int *mode) const
210 {
211 if (!phase)
212 return false;
213 monosynth_audio_module::precalculate_waves(NULL);
214 // printf("get_graph %d %p %d wave1=%d wave2=%d\n", index, data, points, wave1, wave2);
215 if (index == par_wave1 || index == par_wave2) {
216 if (subindex)
217 return false;
218 enum { S = 1 << MONOSYNTH_WAVE_BITS };
219 float value = *params[index];
220 int wave = dsp::clip(dsp::fastf2i_drm(value), 0, (int)wave_count - 1);
221
222 uint32_t shift = index == par_wave1 ? last_pwshift1 : last_pwshift2;
223 if (!running)
224 shift = (int32_t)(0x78000000 * (*params[index == par_wave1 ? par_pw1 : par_pw2]));
225 int flag = (wave == wave_sqr);
226
227 shift = (flag ? S/2 : 0) + (shift >> (32 - MONOSYNTH_WAVE_BITS));
228 int sign = flag ? -1 : 1;
229 if (wave == wave_sqr)
230 wave = wave_saw;
231 float *waveform = waves[wave].original;
232 float rnd_start = 1 - *params[par_window1] * 0.5f;
233 float scl = rnd_start < 1.0 ? 1.f / (1 - rnd_start) : 0.f;
234 for (int i = 0; i < points; i++)
235 {
236 int pos = i * S / points;
237 float r = 1;
238 if (index == par_wave1)
239 {
240 float ph = i * 1.0 / points;
241 if (ph < 0.5f)
242 ph = 1.f - ph;
243 ph = (ph - rnd_start) * scl;
244 if (ph < 0)
245 ph = 0;
246 r = 1.0 - ph * ph;
247 pos = int(pos * 1.0 * last_stretch1 / 65536.0 ) % S;
248 }
249 data[i] = r * (sign * waveform[pos] + waveform[(pos + shift) & (S - 1)]) / (sign == -1 ? 1 : 2);
250 }
251 return true;
252 }
253 if (index == par_filtertype) {
254 if (!running)
255 return false;
256 if (subindex > (is_stereo_filter() ? 1 : 0))
257 return false;
258 for (int i = 0; i < points; i++)
259 {
260 double freq = 20.0 * pow (20000.0 / 20.0, i * 1.0 / points);
261
262 const dsp::biquad_d1_lerp &f = subindex ? filter2 : filter;
263 float level = f.freq_gain(freq, srate);
264 if (!is_stereo_filter())
265 level *= filter2.freq_gain(freq, srate);
266 else
267 set_channel_color(context, subindex);
268 level *= fgain;
269
270 data[i] = log(level) / log(1024.0) + 0.5;
271 }
272 return true;
273 }
274 return false;
275 }
276
calculate_buffer_oscs(float lfo1)277 void monosynth_audio_module::calculate_buffer_oscs(float lfo1)
278 {
279 int flag1 = (wave1 == wave_sqr);
280 int flag2 = (wave2 == wave_sqr);
281
282 int32_t shift1 = last_pwshift1;
283 int32_t shift2 = last_pwshift2;
284 int32_t stretch1 = last_stretch1;
285 int32_t shift_target1 = (int32_t)(0x78000000 * dsp::clip11(*params[par_pw1] + lfo1 * *params[par_lfopw] + 0.01f * moddest[moddest_o1pw]));
286 int32_t shift_target2 = (int32_t)(0x78000000 * dsp::clip11(*params[par_pw2] + lfo1 * *params[par_lfopw] + 0.01f * moddest[moddest_o2pw]));
287 int32_t stretch_target1 = (int32_t)(65536 * dsp::clip(*params[par_stretch1] + 0.01f * moddest[moddest_o1stretch], 1.f, 16.f));
288 int32_t shift_delta1 = ((shift_target1 >> 1) - (last_pwshift1 >> 1)) >> (step_shift - 1);
289 int32_t shift_delta2 = ((shift_target2 >> 1) - (last_pwshift2 >> 1)) >> (step_shift - 1);
290 int32_t stretch_delta1 = ((stretch_target1 >> 1) - (last_stretch1 >> 1)) >> (step_shift - 1);
291 last_pwshift1 = shift_target1;
292 last_pwshift2 = shift_target2;
293 last_stretch1 = stretch_target1;
294 lookup_waveforms();
295
296 shift1 += (flag1 << 31);
297 shift2 += (flag2 << 31);
298 float mix1 = 1 - 2 * flag1, mix2 = 1 - 2 * flag2;
299
300 float new_xfade = dsp::clip<float>(xfade + 0.01f * moddest[moddest_oscmix], 0.f, 1.f);
301 float cur_xfade = last_xfade;
302 float xfade_step = (new_xfade - cur_xfade) * (1.0 / step_size);
303
304 float rnd_start = 1 - *params[par_window1] * 0.5f;
305 float scl = rnd_start < 1.0 ? 1.f / (1 - rnd_start) : 0.f;
306
307 static const int muls[8] = { 33, -47, 53, -67, 87, -101, 121, -139 };
308 float unison = *params[par_o2unison] + moddest[moddest_o2unisonamp] * 0.01;
309 float unison_scale = 1.0, unison_delta = 0.0, last_unison_scale = 1.0, unison_scale_delta = 0.0;
310 if (unison > 0)
311 {
312 float freq = fabs(*params[par_o2unisonfrq] / muls[7]);
313 if (moddest[moddest_o2unisondetune] != 0)
314 freq *= pow(2.0, moddest[moddest_o2unisondetune]);
315 unison_osc.set_freq(freq, srate);
316 last_unison_scale = 1.0 / (1.0 + 2 * last_unison);
317 unison_scale = 1.0 / (1.0 + 2 * unison);
318 unison_delta = (unison - last_unison) * (1.0 / step_size);
319 unison_scale_delta = (unison_scale - last_unison_scale) * (1.0 / step_size);
320 }
321 for (uint32_t i = 0; i < step_size; i++)
322 {
323 //buffer[i] = lerp(osc1.get_phaseshifted(shift1, mix1), osc2.get_phaseshifted(shift2, mix2), cur_xfade);
324 float o1phase = osc1.phase / (65536.0 * 65536.0);
325 if (o1phase < 0.5)
326 o1phase = 1 - o1phase;
327 o1phase = (o1phase - rnd_start) * scl;
328 if (o1phase < 0)
329 o1phase = 0;
330 float r = 1.0 - o1phase * o1phase;
331 float osc1val = osc1.get_phasedist(stretch1, shift1, mix1);
332 float osc2val = osc2.get_phaseshifted(shift2, mix2);
333 if (unison > 0 || last_unison > 0)
334 {
335 for (int j = 0; j < 8; j++)
336 osc2val += last_unison * osc2.get_phaseshifted2(shift2, unison_osc.phase * muls[j], mix2);
337 osc2val *= last_unison_scale;
338
339 unison_osc.step();
340 last_unison += unison_delta;
341 last_unison_scale += unison_scale_delta;
342 }
343 buffer[i] = lerp(r * osc1val, osc2val, cur_xfade);
344 osc1.advance();
345 osc2.advance();
346 shift1 += shift_delta1;
347 shift2 += shift_delta2;
348 stretch1 += stretch_delta1;
349 cur_xfade += xfade_step;
350 }
351 last_xfade = new_xfade;
352 last_unison = unison;
353 }
354
calculate_buffer_ser()355 void monosynth_audio_module::calculate_buffer_ser()
356 {
357 filter.big_step(1.0 / step_size);
358 filter2.big_step(1.0 / step_size);
359 for (uint32_t i = 0; i < step_size; i++)
360 {
361 float wave = buffer[i] * fgain;
362 wave = filter.process(wave);
363 wave = filter2.process(wave);
364 buffer[i] = wave;
365 fgain += fgain_delta;
366 }
367 }
368
calculate_buffer_single()369 void monosynth_audio_module::calculate_buffer_single()
370 {
371 filter.big_step(1.0 / step_size);
372 for (uint32_t i = 0; i < step_size; i++)
373 {
374 float wave = buffer[i] * fgain;
375 wave = filter.process(wave);
376 buffer[i] = wave;
377 fgain += fgain_delta;
378 }
379 }
380
calculate_buffer_stereo()381 void monosynth_audio_module::calculate_buffer_stereo()
382 {
383 filter.big_step(1.0 / step_size);
384 filter2.big_step(1.0 / step_size);
385 for (uint32_t i = 0; i < step_size; i++)
386 {
387 float wave1 = buffer[i] * fgain;
388 buffer[i] = fgain * filter.process(wave1);
389 buffer2[i] = fgain * filter2.process(wave1);
390 fgain += fgain_delta;
391 }
392 }
393
lookup_waveforms()394 void monosynth_audio_module::lookup_waveforms()
395 {
396 osc1.waveform = waves[wave1 == wave_sqr ? wave_saw : wave1].get_level((uint32_t)(((uint64_t)osc1.phasedelta) * last_stretch1 >> 16));
397 osc2.waveform = waves[wave2 == wave_sqr ? wave_saw : wave2].get_level(osc2.phasedelta);
398 if (!osc1.waveform) osc1.waveform = silence;
399 if (!osc2.waveform) osc2.waveform = silence;
400 prev_wave1 = wave1;
401 prev_wave2 = wave2;
402 }
403
delayed_note_on()404 void monosynth_audio_module::delayed_note_on()
405 {
406 force_fadeout = false;
407 fadeout.reset_soft();
408 fadeout2.reset_soft();
409 porta_time = 0.f;
410 start_freq = freq;
411 target_freq = freq = 440 * pow(2.0, (queue_note_on - 69) / 12.0);
412 velocity = queue_vel;
413 ampctl = 1.0 + (queue_vel - 1.0) * *params[par_vel2amp];
414 fltctl = 1.0 + (queue_vel - 1.0) * *params[par_vel2filter];
415 bool starting = false;
416
417 if (!running)
418 {
419 starting = true;
420 if (legato >= 2)
421 porta_time = -1.f;
422 last_xfade = xfade;
423 unison_osc.phase = rand() << 16;
424 osc1.reset();
425 osc2.reset();
426 filter.reset();
427 filter2.reset();
428 if (*params[par_lfo1trig] <= 0)
429 lfo1.reset();
430 if (*params[par_lfo2trig] <= 0)
431 lfo2.reset();
432 switch((int)*params[par_oscmode])
433 {
434 case 1:
435 osc2.phase = 0x80000000;
436 break;
437 case 2:
438 osc2.phase = 0x40000000;
439 break;
440 case 3:
441 osc1.phase = osc2.phase = 0x40000000;
442 break;
443 case 4:
444 osc1.phase = 0x40000000;
445 osc2.phase = 0xC0000000;
446 break;
447 case 5:
448 // rand() is crap, but I don't have any better RNG in Calf yet
449 osc1.phase = rand() << 16;
450 osc2.phase = rand() << 16;
451 break;
452 default:
453 break;
454 }
455 running = true;
456 }
457 if (legato >= 2 && !gate)
458 porta_time = -1.f;
459 gate = true;
460 stopping = false;
461 if (starting || !(legato & 1) || envelope1.released())
462 envelope1.note_on();
463 if (starting || !(legato & 1) || envelope2.released())
464 envelope2.note_on();
465 if (!running || !(legato & 1))
466 lfo_clock = 0.f;
467 envelope1.advance();
468 envelope2.advance();
469 queue_note_on = -1;
470 float modsrc[modsrc_count] = { 1.f, velocity, (float)inertia_pressure.get_last(), modwheel_value, (float)envelope1.value, (float)envelope2.value, 0.5f+0.5f*lfo1.last, 0.5f+0.5f*lfo2.last};
471 calculate_modmatrix(moddest, moddest_count, modsrc);
472 set_frequency();
473 lookup_waveforms();
474
475 if (queue_note_on_and_off)
476 {
477 end_note();
478 queue_note_on_and_off = false;
479 }
480 }
481
set_sample_rate(uint32_t sr)482 void monosynth_audio_module::set_sample_rate(uint32_t sr) {
483 srate = sr;
484 crate = sr / step_size;
485 odcr = (float)(1.0 / crate);
486 fgain = 0.f;
487 fgain_delta = 0.f;
488 inertia_cutoff.ramp.set_length(crate / 30); // 1/30s
489 inertia_pitchbend.ramp.set_length(crate / 30); // 1/30s
490 master.set_sample_rate(sr);
491 }
492
get_lfo(dsp::triangle_lfo & lfo,int param)493 float monosynth_audio_module::get_lfo(dsp::triangle_lfo &lfo, int param)
494 {
495 if (*params[param] <= 0)
496 return lfo.get();
497 float pt = lfo_clock / *params[param];
498 return lfo.get() * std::min(1.0f, pt);
499 }
500
calculate_step()501 void monosynth_audio_module::calculate_step()
502 {
503 if (queue_note_on != -1)
504 delayed_note_on();
505 else
506 if (stopping || !running)
507 {
508 running = false;
509 envelope1.advance();
510 envelope2.advance();
511 lfo1.get();
512 lfo2.get();
513 float modsrc[modsrc_count] = { 1.f, velocity, inertia_pressure.get_last(), modwheel_value, (float)envelope1.value, (float)envelope2.value, 0.5f+0.5f*lfo1.last, 0.5f+0.5f*lfo2.last};
514 calculate_modmatrix(moddest, moddest_count, modsrc);
515 last_stretch1 = (int32_t)(65536 * dsp::clip(*params[par_stretch1] + 0.01f * moddest[moddest_o1stretch], 1.f, 16.f));
516 return;
517 }
518 lfo1.set_freq(*params[par_lforate], crate);
519 lfo2.set_freq(*params[par_lfo2rate], crate);
520 float porta_total_time = *params[par_portamento] * 0.001f;
521
522 if (porta_total_time >= 0.00101f && porta_time >= 0) {
523 // XXXKF this is criminal, optimize!
524 float point = porta_time / porta_total_time;
525 if (point >= 1.0f) {
526 freq = target_freq;
527 porta_time = -1;
528 } else {
529 freq = start_freq + (target_freq - start_freq) * point;
530 // freq = start_freq * pow(target_freq / start_freq, point);
531 porta_time += odcr;
532 }
533 }
534 float lfov1 = get_lfo(lfo1, par_lfodelay);
535 lfov1 = lfov1 * dsp::lerp(1.f, modwheel_value, *params[par_mwhl_lfo]);
536 float lfov2 = get_lfo(lfo2, par_lfodelay);
537 lfo_clock += odcr;
538 if (fabs(*params[par_lfopitch]) > small_value<float>())
539 lfo_bend = pow(2.0f, *params[par_lfopitch] * lfov1 * (1.f / 1200.0f));
540 inertia_pitchbend.step();
541 envelope1.advance();
542 envelope2.advance();
543 float env1 = envelope1.value, env2 = envelope2.value;
544 float aenv1 = envelope1.get_amp_value(), aenv2 = envelope2.get_amp_value();
545
546 // mod matrix
547 // this should be optimized heavily; I think I'll do it when MIDI in Ardour 3 gets stable :>
548 float modsrc[modsrc_count] = { 1.f, velocity, inertia_pressure.get(), modwheel_value, env1, env2, 0.5f+0.5f*lfov1, 0.5f+0.5f*lfov2};
549 calculate_modmatrix(moddest, moddest_count, modsrc);
550
551 set_frequency();
552 inertia_cutoff.set_inertia(*params[par_cutoff]);
553 cutoff = inertia_cutoff.get() * pow(2.0f, (lfov1 * *params[par_lfofilter] + env1 * fltctl * *params[par_env1tocutoff] + env2 * fltctl * *params[par_env2tocutoff] + moddest[moddest_cutoff]) * (1.f / 1200.f));
554 if (*params[par_keyfollow] > 0.01f)
555 cutoff *= pow(freq / 264.f, *params[par_keyfollow]);
556 cutoff = dsp::clip(cutoff , 10.f, 18000.f);
557 float resonance = *params[par_resonance];
558 float e2r1 = *params[par_env1tores];
559 resonance = resonance * (1 - e2r1) + (0.7 + (resonance - 0.7) * env1 * env1) * e2r1;
560 float e2r2 = *params[par_env2tores];
561 resonance = resonance * (1 - e2r2) + (0.7 + (resonance - 0.7) * env2 * env2) * e2r2 + moddest[moddest_resonance];
562 float cutoff2 = dsp::clip(cutoff * separation, 10.f, 18000.f);
563 float newfgain = 0.f;
564 if (filter_type != last_filter_type)
565 {
566 filter.y2 = filter.y1 = filter.x2 = filter.x1 = filter.y1;
567 filter2.y2 = filter2.y1 = filter2.x2 = filter2.x1 = filter2.y1;
568 last_filter_type = filter_type;
569 }
570 switch(filter_type)
571 {
572 case flt_lp12:
573 filter.set_lp_rbj(cutoff, resonance, srate);
574 filter2.set_null();
575 newfgain = min(0.7f, 0.7f / resonance) * ampctl;
576 break;
577 case flt_hp12:
578 filter.set_hp_rbj(cutoff, resonance, srate);
579 filter2.set_null();
580 newfgain = min(0.7f, 0.7f / resonance) * ampctl;
581 break;
582 case flt_lp24:
583 filter.set_lp_rbj(cutoff, resonance, srate);
584 filter2.set_lp_rbj(cutoff2, resonance, srate);
585 newfgain = min(0.5f, 0.5f / resonance) * ampctl;
586 break;
587 case flt_lpbr:
588 filter.set_lp_rbj(cutoff, resonance, srate);
589 filter2.set_br_rbj(cutoff2, 1.0 / resonance, srate);
590 newfgain = min(0.5f, 0.5f / resonance) * ampctl;
591 break;
592 case flt_hpbr:
593 filter.set_hp_rbj(cutoff, resonance, srate);
594 filter2.set_br_rbj(cutoff2, 1.0 / resonance, srate);
595 newfgain = min(0.5f, 0.5f / resonance) * ampctl;
596 break;
597 case flt_2lp12:
598 filter.set_lp_rbj(cutoff, resonance, srate);
599 filter2.set_lp_rbj(cutoff2, resonance, srate);
600 newfgain = min(0.7f, 0.7f / resonance) * ampctl;
601 break;
602 case flt_bp6:
603 filter.set_bp_rbj(cutoff, resonance, srate);
604 filter2.set_null();
605 newfgain = ampctl;
606 break;
607 case flt_2bp6:
608 filter.set_bp_rbj(cutoff, resonance, srate);
609 filter2.set_bp_rbj(cutoff2, resonance, srate);
610 newfgain = ampctl;
611 break;
612 }
613 float e2a1 = *params[par_env1toamp];
614 float e2a2 = *params[par_env2toamp];
615 if (e2a1 > 0.f)
616 newfgain *= aenv1;
617 if (e2a2 > 0.f)
618 newfgain *= aenv2;
619 if (moddest[moddest_attenuation] != 0.f)
620 newfgain *= dsp::clip<float>(1 - moddest[moddest_attenuation] * moddest[moddest_attenuation], 0.f, 1.f);
621 fgain_delta = (newfgain - fgain) * (1.0 / step_size);
622 calculate_buffer_oscs(lfov1);
623 lfo1.last = lfov1;
624 lfo2.last = lfov2;
625 switch(filter_type)
626 {
627 case flt_lp24:
628 case flt_lpbr:
629 case flt_hpbr: // Oomek's wish
630 calculate_buffer_ser();
631 break;
632 case flt_lp12:
633 case flt_hp12:
634 case flt_bp6:
635 calculate_buffer_single();
636 break;
637 case flt_2lp12:
638 case flt_2bp6:
639 calculate_buffer_stereo();
640 break;
641 }
642 apply_fadeout();
643 }
644
apply_fadeout()645 void monosynth_audio_module::apply_fadeout()
646 {
647 if (fadeout.undoing)
648 {
649 fadeout.process(buffer2, step_size);
650 if (is_stereo_filter())
651 fadeout2.process(buffer2, step_size);
652 }
653 else
654 {
655 // stop the sound if the amplitude envelope is not running (if there's any)
656 bool aenv1_on = *params[par_env1toamp] > 0.f, aenv2_on = *params[par_env2toamp] > 0.f;
657
658 bool do_fadeout = force_fadeout;
659
660 // if there's no amplitude envelope at all, the fadeout starts at key release
661 if (!aenv1_on && !aenv2_on && !gate)
662 do_fadeout = true;
663 // if ENV1 modulates amplitude, the fadeout will start on ENV1 end too
664 if (aenv1_on && envelope1.state == adsr::STOP)
665 do_fadeout = true;
666 // if ENV2 modulates amplitude, the fadeout will start on ENV2 end too
667 if (aenv2_on && envelope2.state == adsr::STOP)
668 do_fadeout = true;
669
670 if (do_fadeout || fadeout.undoing || fadeout2.undoing)
671 {
672 fadeout.process(buffer, step_size);
673 if (is_stereo_filter())
674 fadeout2.process(buffer2, step_size);
675 if (fadeout.done)
676 stopping = true;
677 }
678 }
679 }
680
note_on(int channel,int note,int vel)681 void monosynth_audio_module::note_on(int channel, int note, int vel)
682 {
683 if (*params[par_midi] && channel != *params[par_midi]) return;
684 queue_note_on = note;
685 queue_note_on_and_off = false;
686 last_key = note;
687 queue_vel = vel / 127.f;
688 stack.push(note);
689 }
690
note_off(int channel,int note,int vel)691 void monosynth_audio_module::note_off(int channel, int note, int vel)
692 {
693 if (*params[par_midi] && channel != *params[par_midi]) return;
694 stack.pop(note);
695 if (note == queue_note_on)
696 {
697 queue_note_on_and_off = true;
698 return;
699 }
700 // If releasing the currently played note, try to get another one from note stack.
701 if (note == last_key) {
702 end_note();
703 }
704 }
705
end_note()706 void monosynth_audio_module::end_note()
707 {
708 if (stack.count())
709 {
710 int note;
711 last_key = note = stack.nth(stack.count() - 1);
712 start_freq = freq;
713 target_freq = freq = dsp::note_to_hz(note);
714 porta_time = 0;
715 set_frequency();
716 if (!(legato & 1)) {
717 envelope1.note_on();
718 envelope2.note_on();
719 stopping = false;
720 running = true;
721 }
722 return;
723 }
724 gate = false;
725 envelope1.note_off();
726 envelope2.note_off();
727 }
728
channel_pressure(int channel,int value)729 void monosynth_audio_module::channel_pressure(int channel, int value)
730 {
731 if (*params[par_midi] && channel != *params[par_midi]) return;
732 inertia_pressure.set_inertia(value * (1.0 / 127.0));
733 }
734
control_change(int channel,int controller,int value)735 void monosynth_audio_module::control_change(int channel, int controller, int value)
736 {
737 if (*params[par_midi] && channel != *params[par_midi]) return;
738 switch(controller)
739 {
740 case 1:
741 modwheel_value_int = (modwheel_value_int & 127) | (value << 7);
742 modwheel_value = modwheel_value_int / 16383.0;
743 break;
744 case 33:
745 modwheel_value_int = (modwheel_value_int & (127 << 7)) | value;
746 modwheel_value = modwheel_value_int / 16383.0;
747 break;
748 case 120: // all sounds off
749 force_fadeout = true;
750 // fall through
751 case 123: // all notes off
752 gate = false;
753 queue_note_on = -1;
754 envelope1.note_off();
755 envelope2.note_off();
756 stack.clear();
757 break;
758 }
759 }
760
deactivate()761 void monosynth_audio_module::deactivate()
762 {
763 gate = false;
764 running = false;
765 stopping = false;
766 envelope1.reset();
767 envelope2.reset();
768 stack.clear();
769 }
770
set_frequency()771 void monosynth_audio_module::set_frequency()
772 {
773 float detune_scaled = (detune - 1); // * log(freq / 440);
774 if (*params[par_scaledetune] > 0)
775 detune_scaled *= pow(20.0 / freq, (double)*params[par_scaledetune]);
776 float p1 = 1, p2 = 1;
777 if (moddest[moddest_o1detune] != 0)
778 p1 = pow(2.0, moddest[moddest_o1detune] * (1.0 / 1200.0));
779 if (moddest[moddest_o2detune] != 0)
780 p2 = pow(2.0, moddest[moddest_o2detune] * (1.0 / 1200.0));
781 osc1.set_freq(freq * (1 - detune_scaled) * p1 * inertia_pitchbend.get_last() * lfo_bend * xpose1, srate);
782 osc2.set_freq(freq * (1 + detune_scaled) * p2 * inertia_pitchbend.get_last() * lfo_bend * xpose2, srate);
783 }
784
785
params_changed()786 void monosynth_audio_module::params_changed()
787 {
788 float sf = 0.001f;
789 envelope1.set(*params[par_env1attack] * sf, *params[par_env1decay] * sf, std::min(0.999f, *params[par_env1sustain]), *params[par_env1release] * sf, srate / step_size, *params[par_env1fade] * sf);
790 envelope2.set(*params[par_env2attack] * sf, *params[par_env2decay] * sf, std::min(0.999f, *params[par_env2sustain]), *params[par_env2release] * sf, srate / step_size, *params[par_env2fade] * sf);
791 filter_type = dsp::fastf2i_drm(*params[par_filtertype]);
792 separation = pow(2.0, *params[par_cutoffsep] / 1200.0);
793 wave1 = dsp::clip(dsp::fastf2i_drm(*params[par_wave1]), 0, (int)wave_count - 1);
794 wave2 = dsp::clip(dsp::fastf2i_drm(*params[par_wave2]), 0, (int)wave_count - 1);
795 detune = pow(2.0, *params[par_detune] / 1200.0);
796 xpose1 = pow(2.0, *params[par_osc1xpose] / 12.0);
797 xpose2 = pow(2.0, *params[par_osc2xpose] / 12.0);
798 xfade = *params[par_oscmix];
799 legato = dsp::fastf2i_drm(*params[par_legato]);
800 master.set_inertia(*params[par_master]);
801 if (running)
802 set_frequency();
803 if (wave1 != prev_wave1 || wave2 != prev_wave2)
804 lookup_waveforms();
805 }
806
807
process(uint32_t offset,uint32_t nsamples,uint32_t inputs_mask,uint32_t outputs_mask)808 uint32_t monosynth_audio_module::process(uint32_t offset, uint32_t nsamples, uint32_t inputs_mask, uint32_t outputs_mask)
809 {
810 uint32_t op = offset;
811 uint32_t op_end = offset + nsamples;
812 int had_data = 0;
813 while(op < op_end) {
814 if (output_pos == 0)
815 calculate_step();
816 if(op < op_end) {
817 uint32_t ip = output_pos;
818 uint32_t len = std::min(step_size - output_pos, op_end - op);
819 if (running)
820 {
821 had_data = 3;
822 if (is_stereo_filter())
823 for(uint32_t i = 0 ; i < len; i++) {
824 float vol = master.get();
825 outs[0][op + i] = buffer[ip + i] * vol;
826 outs[1][op + i] = buffer2[ip + i] * vol;
827 }
828 else
829 for(uint32_t i = 0 ; i < len; i++)
830 outs[0][op + i] = outs[1][op + i] = buffer[ip + i] * master.get();
831 }
832 else
833 {
834 dsp::zero(&outs[0][op], len);
835 dsp::zero(&outs[1][op], len);
836 }
837 op += len;
838 output_pos += len;
839 if (output_pos == step_size)
840 output_pos = 0;
841 }
842 }
843
844 return had_data;
845 }
846