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