1 /* Calf DSP plugin pack
2 * Assorted plugins
3 *
4 * Copyright (C) 2001-2010 Krzysztof Foltman, Markus Schmidt, Thor Harald Johansen
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 <limits.h>
22 #include <memory.h>
23 #include <math.h>
24 #include <calf/giface.h>
25 #include <calf/modules_tools.h>
26 #include <calf/modules_dev.h>
27 #include <calf/utils.h>
28 #ifndef _MSC_VER
29 #include <sys/time.h>
30 #endif
31
32 using namespace dsp;
33 using namespace calf_plugins;
34
35 FORWARD_DECLARE_METADATA(stereo)
FORWARD_DECLARE_METADATA(mono)36 FORWARD_DECLARE_METADATA(mono)
37 FORWARD_DECLARE_METADATA(multispread)
38 FORWARD_DECLARE_METADATA(multibandenhancer)
39 FORWARD_DECLARE_METADATA(analyzer)
40 FORWARD_DECLARE_METADATA(widgets)
41
42 #define SET_IF_CONNECTED(name) if (params[AM::param_##name] != NULL) *params[AM::param_##name] = name;
43 #define sinc(x) (!x) ? 1 : sin(M_PI * x)/(M_PI * x);
44
45 /**********************************************************************
46 * STEREO TOOLS by Markus Schmidt
47 **********************************************************************/
48
49 stereo_audio_module::stereo_audio_module() {
50 active = false;
51 _phase = -1;
52 buffer = NULL;
53 }
~stereo_audio_module()54 stereo_audio_module::~stereo_audio_module() {
55 free(buffer);
56 }
activate()57 void stereo_audio_module::activate() {
58 active = true;
59 }
60
deactivate()61 void stereo_audio_module::deactivate() {
62 active = false;
63 }
64
params_changed()65 void stereo_audio_module::params_changed() {
66 if(*params[param_stereo_phase] != _phase) {
67 _phase = *params[param_stereo_phase];
68 _phase_cos_coef = cos(_phase / 180 * M_PI);
69 _phase_sin_coef = sin(_phase / 180 * M_PI);
70 }
71 if(*params[param_sc_level] != _sc_level) {
72 _sc_level = *params[param_sc_level];
73 _inv_atan_shape = 1.0 / atan(_sc_level);
74 }
75 }
76
process(uint32_t offset,uint32_t numsamples,uint32_t inputs_mask,uint32_t outputs_mask)77 uint32_t stereo_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
78 bool bypassed = bypass.update(*params[param_bypass] > 0.5f, numsamples);
79 uint32_t orig_offset = offset;
80 for(uint32_t i = offset; i < offset + numsamples; i++) {
81 if(bypassed) {
82 outs[0][i] = ins[0][i];
83 outs[1][i] = ins[1][i];
84 meter_inL = 0.f;
85 meter_inR = 0.f;
86 meter_outL = 0.f;
87 meter_outR = 0.f;
88 } else {
89 meter_inL = 0.f;
90 meter_inR = 0.f;
91 meter_outL = 0.f;
92 meter_outR = 0.f;
93
94 float L = ins[0][i];
95 float R = ins[1][i];
96
97 // levels in
98 L *= *params[param_level_in];
99 R *= *params[param_level_in];
100
101 // balance in
102 L *= (1.f - std::max(0.f, *params[param_balance_in]));
103 R *= (1.f + std::min(0.f, *params[param_balance_in]));
104
105 // softclip
106 if(*params[param_softclip]) {
107 R = _inv_atan_shape * atan(R * _sc_level);
108 L = _inv_atan_shape * atan(L * _sc_level);
109 }
110
111 // GUI stuff
112 meter_inL = L;
113 meter_inR = R;
114
115 // modes
116 float slev = *params[param_slev]; // slev - stereo level ( -2 -> 2 )
117 float sbal = 1 + *params[param_sbal]; // sbal - stereo balance ( 0 -> 2 )
118 float mlev = *params[param_mlev]; // mlev - mono level ( 0 -> 2 )
119 float mpan = (1 + *params[param_mpan]); // mpan - mono pan ( 0 -> 1 )
120
121 float l, r, m, s;
122
123 switch((int)*params[param_mode])
124 {
125 case 0:
126 // LR > LR
127 m = (L + R) * 0.5;
128 s = (L - R) * 0.5;
129 l = m * mlev * std::min(1.f, 2.f - mpan) + s * slev * std::min(1.f, 2.f - sbal);
130 r = m * mlev * std::min(1.f, mpan) - s * slev * std::min(1.f, sbal);
131 L = l;
132 R = r;
133 break;
134 case 1:
135 // LR > MS
136 l = L * std::min(1.f, 2.f - sbal);
137 r = R * std::min(1.f, sbal);
138 L = 0.5 * (l + r) * mlev;
139 R = 0.5 * (l - r) * slev;
140 break;
141 case 2:
142 // MS > LR
143 l = L * mlev * std::min(1.f, 2.f - mpan) + R * slev * std::min(1.f, 2.f - sbal);
144 r = L * mlev * std::min(1.f, mpan) - R * slev * std::min(1.f, sbal);
145 L = l;
146 R = r;
147 break;
148 case 3:
149 // LR > LL
150 R = L;
151 break;
152 case 4:
153 // LR > RR
154 L = R;
155 break;
156 case 5:
157 // LR > L+R
158 L = (L + R) / 2;
159 R = L;
160 break;
161 case 6:
162 // LR > RL
163 l = L;
164 L = R;
165 R = l;
166 m = (L + R) * 0.5;
167 s = (L - R) * 0.5;
168 l = m * mlev * std::min(1.f, 2.f - mpan) + s * slev * std::min(1.f, 2.f - sbal);
169 r = m * mlev * std::min(1.f, mpan) - s * slev * std::min(1.f, sbal);
170 L = l;
171 R = r;
172 break;
173 }
174
175 // mute
176 L *= (1 - floor(*params[param_mute_l] + 0.5));
177 R *= (1 - floor(*params[param_mute_r] + 0.5));
178
179 // phase
180 L *= (2 * (1 - floor(*params[param_phase_l] + 0.5))) - 1;
181 R *= (2 * (1 - floor(*params[param_phase_r] + 0.5))) - 1;
182
183 // delay
184 buffer[pos] = L;
185 buffer[pos + 1] = R;
186
187 int nbuf = srate * (fabs(*params[param_delay]) / 1000.f);
188 nbuf -= nbuf % 2;
189 if(*params[param_delay] > 0.f) {
190 R = buffer[(pos - (int)nbuf + 1 + buffer_size) % buffer_size];
191 } else if (*params[param_delay] < 0.f) {
192 L = buffer[(pos - (int)nbuf + buffer_size) % buffer_size];
193 }
194
195 // stereo base
196 float _sb = *params[param_stereo_base];
197 if(_sb < 0) _sb *= 0.5;
198
199 float __l = L + _sb * L - _sb * R;
200 float __r = R + _sb * R - _sb * L;
201
202 L = __l;
203 R = __r;
204
205 // stereo phase
206 __l = L * _phase_cos_coef - R * _phase_sin_coef;
207 __r = L * _phase_sin_coef + R * _phase_cos_coef;
208
209 L = __l;
210 R = __r;
211
212 pos = (pos + 2) % buffer_size;
213
214 // balance out
215 L *= (1.f - std::max(0.f, *params[param_balance_out]));
216 R *= (1.f + std::min(0.f, *params[param_balance_out]));
217
218 // level
219 L *= *params[param_level_out];
220 R *= *params[param_level_out];
221
222 //output
223 outs[0][i] = L;
224 outs[1][i] = R;
225
226 meter_outL = L;
227 meter_outR = R;
228
229 // phase meter
230 if(fabs(L) > 0.001 && fabs(R) > 0.001) {
231 meter_phase = fabs(fabs(L+R) > 0.000000001 ? sin(fabs((L-R)/(L+R))) : 0.f);
232 } else {
233 meter_phase = 0.f;
234 }
235 }
236 float values[] = {meter_inL, meter_inR, meter_outL, meter_outR};
237 meters.process(values);
238 }
239 if (!bypassed)
240 bypass.crossfade(ins, outs, 2, orig_offset, numsamples);
241 meters.fall(numsamples);
242 return outputs_mask;
243 }
244
set_sample_rate(uint32_t sr)245 void stereo_audio_module::set_sample_rate(uint32_t sr)
246 {
247 srate = sr;
248 // rebuild buffer
249 buffer_size = (int)(srate * 0.05 * 2.f); // buffer size attack rate multiplied by 2 channels
250 buffer = (float*) calloc(buffer_size, sizeof(float));
251 pos = 0;
252 int meter[] = {param_meter_inL, param_meter_inR, param_meter_outL, param_meter_outR};
253 int clip[] = {param_clip_inL, param_clip_inR, param_clip_outL, param_clip_outR};
254 meters.init(params, meter, clip, 4, sr);
255 }
256
257 /**********************************************************************
258 * MONO INPUT by Markus Schmidt
259 **********************************************************************/
260
mono_audio_module()261 mono_audio_module::mono_audio_module() {
262 active = false;
263 meter_in = 0.f;
264 meter_outL = 0.f;
265 meter_outR = 0.f;
266 _phase = -1.f;
267 _sc_level = 0.f;
268 buffer = NULL;
269 }
~mono_audio_module()270 mono_audio_module::~mono_audio_module() {
271 free(buffer);
272 }
activate()273 void mono_audio_module::activate() {
274 active = true;
275 }
276
deactivate()277 void mono_audio_module::deactivate() {
278 active = false;
279 }
280
params_changed()281 void mono_audio_module::params_changed() {
282 if(*params[param_sc_level] != _sc_level) {
283 _sc_level = *params[param_sc_level];
284 _inv_atan_shape = 1.0 / atan(_sc_level);
285 }
286 if(*params[param_stereo_phase] != _phase) {
287 _phase = *params[param_stereo_phase];
288 _phase_cos_coef = cos(_phase / 180 * M_PI);
289 _phase_sin_coef = sin(_phase / 180 * M_PI);
290 }
291 }
292
process(uint32_t offset,uint32_t numsamples,uint32_t inputs_mask,uint32_t outputs_mask)293 uint32_t mono_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
294 bool bypassed = bypass.update(*params[param_bypass] > 0.5f, numsamples);
295 uint32_t orig_offset = offset;
296 for(uint32_t i = offset; i < offset + numsamples; i++) {
297 if(bypassed) {
298 outs[0][i] = ins[0][i];
299 outs[1][i] = ins[0][i];
300 meter_in = 0.f;
301 meter_outL = 0.f;
302 meter_outR = 0.f;
303 } else {
304 meter_in = 0.f;
305 meter_outL = 0.f;
306 meter_outR = 0.f;
307
308 float L = ins[0][i];
309
310 // levels in
311 L *= *params[param_level_in];
312
313 // softclip
314 if(*params[param_softclip]) {
315 //int ph = L / fabs(L);
316 //L = L > 0.63 ? ph * (0.63 + 0.36 * (1 - pow(MATH_E, (1.f / 3) * (0.63 + L * ph)))) : L;
317 L = _inv_atan_shape * atan(L * _sc_level);
318 }
319
320 // GUI stuff
321 meter_in = L;
322
323 float R = L;
324
325 // mute
326 L *= (1 - floor(*params[param_mute_l] + 0.5));
327 R *= (1 - floor(*params[param_mute_r] + 0.5));
328
329 // phase
330 L *= (2 * (1 - floor(*params[param_phase_l] + 0.5))) - 1;
331 R *= (2 * (1 - floor(*params[param_phase_r] + 0.5))) - 1;
332
333 // delay
334 buffer[pos] = L;
335 buffer[pos + 1] = R;
336
337 int nbuf = srate * (fabs(*params[param_delay]) / 1000.f);
338 nbuf -= nbuf % 2;
339 if(*params[param_delay] > 0.f) {
340 R = buffer[(pos - (int)nbuf + 1 + buffer_size) % buffer_size];
341 } else if (*params[param_delay] < 0.f) {
342 L = buffer[(pos - (int)nbuf + buffer_size) % buffer_size];
343 }
344
345 // stereo base
346 float _sb = *params[param_stereo_base];
347 if(_sb < 0) _sb *= 0.5;
348
349 float __l = L +_sb * L - _sb * R;
350 float __r = R + _sb * R - _sb * L;
351
352 L = __l;
353 R = __r;
354
355 // stereo phase
356 __l = L * _phase_cos_coef - R * _phase_sin_coef;
357 __r = L * _phase_sin_coef + R * _phase_cos_coef;
358
359 L = __l;
360 R = __r;
361
362 pos = (pos + 2) % buffer_size;
363
364 // balance out
365 L *= (1.f - std::max(0.f, *params[param_balance_out]));
366 R *= (1.f + std::min(0.f, *params[param_balance_out]));
367
368 // level
369 L *= *params[param_level_out];
370 R *= *params[param_level_out];
371
372 //output
373 outs[0][i] = L;
374 outs[1][i] = R;
375
376 meter_outL = L;
377 meter_outR = R;
378 }
379 float values[] = {meter_in, meter_outL, meter_outR};
380 meters.process(values);
381 }
382 if (!bypassed)
383 bypass.crossfade(ins, outs, 2, orig_offset, numsamples);
384 meters.fall(numsamples);
385 return outputs_mask;
386 }
387
set_sample_rate(uint32_t sr)388 void mono_audio_module::set_sample_rate(uint32_t sr)
389 {
390 srate = sr;
391 // rebuild buffer
392 buffer_size = (int)srate * 0.05 * 2; // delay buffer size multiplied by 2 channels
393 buffer = (float*) calloc(buffer_size, sizeof(float));
394 pos = 0;
395 int meter[] = {param_meter_in, param_meter_outL, param_meter_outR};
396 int clip[] = {param_clip_in, param_clip_outL, param_clip_outR};
397 meters.init(params, meter, clip, 3, sr);
398 }
399
400 /**********************************************************************
401 * ANALYZER by Markus Schmidt and Christian Holschuh
402 **********************************************************************/
403
analyzer_audio_module()404 analyzer_audio_module::analyzer_audio_module() {
405
406 active = false;
407 clip_L = 0.f;
408 clip_R = 0.f;
409 meter_L = 0.f;
410 meter_R = 0.f;
411 envelope = 0.f;
412 ppos = 0;
413 plength = 0;
414 phase_buffer = (float*) calloc(max_phase_buffer_size, sizeof(float));
415 }
~analyzer_audio_module()416 analyzer_audio_module::~analyzer_audio_module() {
417 free(phase_buffer);
418 }
activate()419 void analyzer_audio_module::activate() {
420 active = true;
421 }
422
deactivate()423 void analyzer_audio_module::deactivate() {
424 active = false;
425 }
426
params_changed()427 void analyzer_audio_module::params_changed() {
428 float resolution, offset;
429 switch((int)*params[param_analyzer_mode]) {
430 case 0:
431 case 1:
432 case 2:
433 case 3:
434 default:
435 // analyzer
436 resolution = pow(64, *params[param_analyzer_level]);
437 offset = 0.75;
438 break;
439 case 4:
440 // we want to draw Stereo Image
441 resolution = pow(64, *params[param_analyzer_level] * 1.75);
442 offset = 1.f;
443 break;
444 case 5:
445 // We want to draw Stereo Difference
446 offset = *params[param_analyzer_level] > 1
447 ? 1 + (*params[param_analyzer_level] - 1) / 4
448 : *params[param_analyzer_level];
449 resolution = pow(64, 2 * offset);
450 break;
451 }
452
453 _analyzer.set_params(
454 resolution,
455 offset,
456 *params[param_analyzer_accuracy],
457 *params[param_analyzer_hold],
458 *params[param_analyzer_smoothing],
459 *params[param_analyzer_mode],
460 *params[param_analyzer_scale],
461 *params[param_analyzer_post],
462 *params[param_analyzer_speed],
463 *params[param_analyzer_windowing],
464 *params[param_analyzer_view],
465 *params[param_analyzer_freeze]
466 );
467 }
468
process(uint32_t offset,uint32_t numsamples,uint32_t inputs_mask,uint32_t outputs_mask)469 uint32_t analyzer_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
470 for(uint32_t i = offset; i < offset + numsamples; i++) {
471 // let meters fall a bit
472 clip_L -= std::min(clip_L, numsamples);
473 clip_R -= std::min(clip_R, numsamples);
474 meter_L = 0.f;
475 meter_R = 0.f;
476
477 float L = ins[0][i];
478 float R = ins[1][i];
479
480 // GUI stuff
481 if(L > 1.f) clip_L = srate >> 3;
482 if(R > 1.f) clip_R = srate >> 3;
483
484 // goniometer
485 //the goniometer tries to show the signal in maximum
486 //size. therefor an envelope with fast attack and slow
487 //release is calculated with the max value of left and right.
488 //Multiplied envelope by sqrt(2) to push the boundary to the corners
489 //of the square (for example (L,R) = (1,1) is sqrt(2) distance to center).
490 float lemax = fabs(L) > fabs(R) ? fabs(L)*sqrt(2) : fabs(R)*sqrt(2);
491 if( lemax > envelope)
492 envelope = lemax; //attack_coef * (envelope - lemax) + lemax;
493 else
494 envelope = (release_coef * (envelope - lemax) + lemax);
495
496 //use the envelope to bring biggest signal to 1. the biggest
497 //enlargement of the signal is 4.
498
499 phase_buffer[ppos] = L / std::max(0.25f, (envelope));
500 phase_buffer[ppos + 1] = R / std::max(0.25f, (envelope));
501
502
503 plength = std::min(phase_buffer_size, plength + 2);
504 ppos += 2;
505 ppos %= (phase_buffer_size - 2);
506
507 // analyzer
508 _analyzer.process(L, R);
509
510 // meter
511 meter_L = L;
512 meter_R = R;
513
514 //output
515 outs[0][i] = L;
516 outs[1][i] = R;
517 }
518 // draw meters
519 SET_IF_CONNECTED(clip_L);
520 SET_IF_CONNECTED(clip_R);
521 SET_IF_CONNECTED(meter_L);
522 SET_IF_CONNECTED(meter_R);
523 return outputs_mask;
524 }
525
set_sample_rate(uint32_t sr)526 void analyzer_audio_module::set_sample_rate(uint32_t sr)
527 {
528 srate = sr;
529 phase_buffer_size = srate / 30 * 2;
530 phase_buffer_size -= phase_buffer_size % 2;
531 phase_buffer_size = std::min(phase_buffer_size, (int)max_phase_buffer_size);
532 _analyzer.set_sample_rate(sr);
533 attack_coef = exp(log(0.01)/(0.01 * srate * 0.001));
534 release_coef = exp(log(0.01)/(2000 * srate * 0.001));
535 }
536
get_phase_graph(int index,float ** _buffer,int * _length,int * _mode,bool * _use_fade,float * _fade,int * _accuracy,bool * _display) const537 bool analyzer_audio_module::get_phase_graph(int index, float ** _buffer, int *_length, int * _mode, bool * _use_fade, float * _fade, int * _accuracy, bool * _display) const {
538 *_buffer = &phase_buffer[0];
539 *_length = plength;
540 *_use_fade = *params[param_gonio_use_fade];
541 *_fade = 0.6;
542 *_mode = *params[param_gonio_mode];
543 *_accuracy = *params[param_gonio_accuracy];
544 *_display = *params[param_gonio_display];
545 return false;
546 }
547
get_graph(int index,int subindex,int phase,float * data,int points,cairo_iface * context,int * mode) const548 bool analyzer_audio_module::get_graph(int index, int subindex, int phase, float *data, int points, cairo_iface *context, int *mode) const
549 {
550 if (*params[param_analyzer_display])
551 return _analyzer.get_graph(subindex, phase, data, points, context, mode);
552 return false;
553 }
get_moving(int index,int subindex,int & direction,float * data,int x,int y,int & offset,uint32_t & color) const554 bool analyzer_audio_module::get_moving(int index, int subindex, int &direction, float *data, int x, int y, int &offset, uint32_t &color) const
555 {
556 if (*params[param_analyzer_display])
557 return _analyzer.get_moving(subindex, direction, data, x, y, offset, color);
558 return false;
559 }
get_gridline(int index,int subindex,int phase,float & pos,bool & vertical,std::string & legend,cairo_iface * context) const560 bool analyzer_audio_module::get_gridline(int index, int subindex, int phase, float &pos, bool &vertical, std::string &legend, cairo_iface *context) const
561 {
562 return _analyzer.get_gridline(subindex, phase, pos, vertical, legend, context);
563 }
get_layers(int index,int generation,unsigned int & layers) const564 bool analyzer_audio_module::get_layers(int index, int generation, unsigned int &layers) const
565 {
566 return _analyzer.get_layers(generation, layers);
567 }
568
569
570 /**********************************************************************
571 * MULTIBAND ENHANCER by Markus Schmidt
572 **********************************************************************/
573
multibandenhancer_audio_module()574 multibandenhancer_audio_module::multibandenhancer_audio_module()
575 {
576 srate = 0;
577 _mode = -1;
578 channels = 2;
579 is_active = false;
580 ppos = 0;
581 plength = 0;
582 for (int i = 0; i < strips; i++) {
583 phase_buffer[i] = (float*) calloc(max_phase_buffer_size, sizeof(float));
584 envelope[i] = 0;
585 }
586 crossover.init(channels, strips, 44100);
587 }
~multibandenhancer_audio_module()588 multibandenhancer_audio_module::~multibandenhancer_audio_module()
589 {
590 for (int i = 0; i < strips; i++)
591 free(phase_buffer[i]);
592 }
activate()593 void multibandenhancer_audio_module::activate()
594 {
595 is_active = true;
596 for (int i = 0; i < strips; i++) {
597 for (int j = 0; j < channels; j++) {
598 dist[i][j].activate();
599 }
600 }
601 }
602
deactivate()603 void multibandenhancer_audio_module::deactivate()
604 {
605 is_active = false;
606 for (int i = 0; i < strips; i++) {
607 for (int j = 0; j < channels; j++) {
608 dist[i][j].deactivate();
609 }
610 }
611 }
612
params_changed()613 void multibandenhancer_audio_module::params_changed()
614 {
615 // determine mute/solo states
616 solo[0] = *params[param_solo0] > 0.f ? true : false;
617 solo[1] = *params[param_solo1] > 0.f ? true : false;
618 solo[2] = *params[param_solo2] > 0.f ? true : false;
619 solo[3] = *params[param_solo3] > 0.f ? true : false;
620 no_solo = (*params[param_solo0] > 0.f ||
621 *params[param_solo1] > 0.f ||
622 *params[param_solo2] > 0.f ||
623 *params[param_solo3] > 0.f) ? false : true;
624
625 int m = *params[param_mode];
626 if (m != _mode) {
627 _mode = *params[param_mode];
628 }
629
630 crossover.set_mode(_mode + 1);
631 crossover.set_filter(0, *params[param_freq0]);
632 crossover.set_filter(1, *params[param_freq1]);
633 crossover.set_filter(2, *params[param_freq2]);
634
635 // set the params of all strips
636 for (int i = 0; i < strips; i++) {
637 for (int j = 0; j < channels; j++) {
638 dist[i][j].set_params(*params[param_blend0 + i], *params[param_drive0 + i]);
639 }
640 }
641 }
642
set_sample_rate(uint32_t sr)643 void multibandenhancer_audio_module::set_sample_rate(uint32_t sr)
644 {
645 srate = sr;
646 int meter[] = {param_meter_inL, param_meter_inR, param_meter_outL, param_meter_outR};
647 int clip[] = {param_clip_inL, param_clip_inR, param_clip_outL, param_clip_outR};
648 meters.init(params, meter, clip, 4, srate);
649 crossover.set_sample_rate(srate);
650 for (int i = 0; i < strips; i++) {
651 for (int j = 0; j < channels; j++) {
652 dist[i][j].set_sample_rate(srate);
653 }
654 }
655 attack_coef = exp(log(0.01)/(0.01 * srate * 0.001));
656 release_coef = exp(log(0.01)/(2000 * srate * 0.001));
657 phase_buffer_size = srate / 30 * 2;
658 phase_buffer_size -= phase_buffer_size % 2;
659 phase_buffer_size = std::min(phase_buffer_size, (int)max_phase_buffer_size);
660 }
661
process(uint32_t offset,uint32_t numsamples,uint32_t inputs_mask,uint32_t outputs_mask)662 uint32_t multibandenhancer_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask)
663 {
664 bool bypassed = bypass.update(*params[param_bypass] > 0.5f, numsamples);
665 uint32_t orig_numsamples = numsamples;
666 uint32_t orig_offset = offset;
667 numsamples += offset;
668 if(bypassed) {
669 // everything bypassed
670 while(offset < numsamples) {
671 for (int i = 0; i < strips; i ++) {
672 phase_buffer[i][ppos] = 0;
673 phase_buffer[i][ppos + 1] = 0;
674 }
675 // phase buffer handling
676 plength = std::min(phase_buffer_size, plength + 2);
677 ppos += 2;
678 ppos %= (phase_buffer_size - 2);
679
680 outs[0][offset] = ins[0][offset];
681 outs[1][offset] = ins[1][offset];
682 float values[] = {0, 0, 0, 0};
683 meters.process(values);
684 ++offset;
685 }
686 } else {
687 // process all strips
688 while(offset < numsamples) {
689 float inL = ins[0][offset]; // input
690 float inR = ins[1][offset];
691 float outL = 0.f; // final output
692 float outR = 0.f;
693 float tmpL = 0.f; // used for temporary purposes
694 float tmpR = 0.f;
695
696 // in level
697 inR *= *params[param_level_in];
698 inL *= *params[param_level_in];
699
700 // process crossover
701 float xin[] = {inL, inR};
702 crossover.process(xin);
703
704 for (int i = 0; i < strips; i ++) {
705 // cycle trough strips
706 float L = crossover.get_value(0, i);
707 float R = crossover.get_value(1, i);
708 // stereo base
709 tmpL = L;
710 tmpR = R;
711 float _sb = *params[param_base0 + i];
712 if (_sb != 0) {
713 if(_sb < 0) _sb *= 0.5;
714 tmpL = L + _sb * L - _sb * R;
715 tmpR = R + _sb * R - _sb * L;
716 // compensate loudness
717 float f = (_sb + 1) / 2 + 0.5;
718 tmpL /= f;
719 tmpR /= f;
720 }
721 L = tmpL;
722 R = tmpR;
723 if (solo[i] || no_solo) {
724 // process harmonics
725 if (*params[param_drive0 + i]) {
726 L = dist[i][0].process(tmpL);
727 R = dist[i][1].process(tmpR);
728 }
729 // compensate saturation
730 L /= (1 + *params[param_drive0 + i] * 0.075);
731 R /= (1 + *params[param_drive0 + i] * 0.075);
732 // sum up output
733 outL += L;
734 outR += R;
735 }
736 // goniometer
737 float lemax = fabs(L) > fabs(R) ? fabs(L) : fabs(R);
738 if( lemax > envelope[i])
739 envelope[i] = lemax; //attack_coef * (envelope[i] - lemax) + lemax;
740 else
741 envelope[i] = release_coef * (envelope[i] - lemax) + lemax;
742 phase_buffer[i][ppos] = L / std::max(0.25f, (envelope[i]));
743 phase_buffer[i][ppos + 1] = R / std::max(0.25f, (envelope[i]));
744 }
745 // phase buffer handling
746 plength = std::min(phase_buffer_size, plength + 2);
747 ppos += 2;
748 ppos %= (phase_buffer_size - 2);
749
750 // out level
751 outL *= *params[param_level_out];
752 outR *= *params[param_level_out];
753
754 // send to output
755 outs[0][offset] = outL;
756 outs[1][offset] = outR;
757
758 // next sample
759 ++offset;
760
761 float values[] = {inL, inR, outL, outR};
762 meters.process(values);
763 } // cycle trough samples
764 bypass.crossfade(ins, outs, 2, orig_offset, orig_numsamples);
765 } // process (no bypass)
766 meters.fall(numsamples);
767 return outputs_mask;
768 }
get_phase_graph(int index,float ** _buffer,int * _length,int * _mode,bool * _use_fade,float * _fade,int * _accuracy,bool * _display) const769 bool multibandenhancer_audio_module::get_phase_graph(int index, float ** _buffer, int *_length, int * _mode, bool * _use_fade, float * _fade, int * _accuracy, bool * _display) const {
770 int i = index - param_base0;
771 *_buffer = &phase_buffer[i][0];
772 *_length = plength;
773 *_use_fade = 1;
774 *_fade = 0.6;
775 *_mode = 0;
776 *_accuracy = 3;
777 *_display = solo[i] || no_solo;
778 return false;
779 }
get_graph(int index,int subindex,int phase,float * data,int points,cairo_iface * context,int * mode) const780 bool multibandenhancer_audio_module::get_graph(int index, int subindex, int phase, float *data, int points, cairo_iface *context, int *mode) const
781 {
782 return crossover.get_graph(subindex, phase, data, points, context, mode);
783 }
get_layers(int index,int generation,unsigned int & layers) const784 bool multibandenhancer_audio_module::get_layers(int index, int generation, unsigned int &layers) const
785 {
786 return crossover.get_layers(index, generation, layers);
787 }
788
789
790 /**********************************************************************
791 * MULTIBAND SPREAD by Markus Schmidt
792 **********************************************************************/
793
multispread_audio_module()794 multispread_audio_module::multispread_audio_module()
795 {
796 srate = 0;
797 is_active = false;
798 redraw_graph = true;
799 fcoeff = log10(20.f);
800 ppos = 0;
801 plength = 0;
802 phase_buffer = (float*) calloc(max_phase_buffer_size, sizeof(float));
803 envelope = 0;
804 }
~multispread_audio_module()805 multispread_audio_module::~multispread_audio_module()
806 {
807 free(phase_buffer);
808 }
activate()809 void multispread_audio_module::activate()
810 {
811 is_active = true;
812 }
813
deactivate()814 void multispread_audio_module::deactivate()
815 {
816 is_active = false;
817 }
818
params_changed()819 void multispread_audio_module::params_changed()
820 {
821 if (*params[param_amount0] != amount0
822 || *params[param_amount1] != amount1
823 || *params[param_amount2] != amount2
824 || *params[param_amount3] != amount3
825 || *params[param_intensity] != intensity
826 || *params[param_filters] != filters) {
827 redraw_graph = true;
828 amount0 = *params[param_amount0];
829 amount1 = *params[param_amount1];
830 amount2 = *params[param_amount2];
831 amount3 = *params[param_amount3];
832 filters = *params[param_filters];
833 int amount = filters * 4;
834 float q = filters / 3.;
835 float gain1, gain2;
836 float j = 1. + pow(1 - *params[param_intensity], 4) * 99;
837 for (int i = 0; i < amount; i++) {
838 float f = pow(*params[param_amount0 + int(i / filters)], 1. / j);
839 gain1 = f;
840 gain2 = 1. / f;
841 L[i].set_peakeq_rbj(pow(10, fcoeff + (0.5f + (float)i) * 3.f / (float)amount), q, (i % 2) ? gain1 : gain2, (double)srate);
842 R[i].set_peakeq_rbj(pow(10, fcoeff + (0.5f + (float)i) * 3.f / (float)amount), q, (i % 2) ? gain2 : gain1, (double)srate);
843 }
844 }
845 }
846
set_sample_rate(uint32_t sr)847 void multispread_audio_module::set_sample_rate(uint32_t sr)
848 {
849 srate = sr;
850 int meter[] = {param_meter_inL, param_meter_inR, param_meter_outL, param_meter_outR};
851 int clip[] = {param_clip_inL, param_clip_inR, param_clip_outL, param_clip_outR};
852 meters.init(params, meter, clip, 4, srate);
853 attack_coef = exp(log(0.01)/(0.01 * srate * 0.001));
854 release_coef = exp(log(0.01)/(2000 * srate * 0.001));
855 phase_buffer_size = srate / 30 * 2;
856 phase_buffer_size -= phase_buffer_size % 2;
857 phase_buffer_size = std::min(phase_buffer_size, (int)max_phase_buffer_size);
858 }
859
process(uint32_t offset,uint32_t numsamples,uint32_t inputs_mask,uint32_t outputs_mask)860 uint32_t multispread_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask)
861 {
862 bool bypassed = bypass.update(*params[param_bypass] > 0.5f, numsamples);
863 uint32_t orig_numsamples = numsamples;
864 uint32_t orig_offset = offset;
865 numsamples += offset;
866 if(bypassed) {
867 // everything bypassed
868 while(offset < numsamples) {
869 outs[0][offset] = ins[0][offset];
870 outs[1][offset] = *params[param_mono] > 0.5 ? ins[0][offset] : ins[1][offset];
871 float values[] = {0, 0, 0, 0};
872 meters.process(values);
873 // phase buffer handling
874 phase_buffer[ppos] = 0;
875 phase_buffer[ppos + 1] = 0;
876 plength = std::min(phase_buffer_size, plength + 2);
877 ppos += 2;
878 ppos %= (phase_buffer_size - 2);
879 ++offset;
880 }
881 } else {
882 // process all strips
883 while(offset < numsamples) {
884 float inL = ins[0][offset]; // input
885 float inR = *params[param_mono] > 0.5 ? ins[0][offset] : ins[1][offset];
886 float outL = 0.f; // final output
887 float outR = 0.f;
888
889 // in level
890 inR *= *params[param_level_in];
891 inL *= *params[param_level_in];
892
893 outL = inL;
894 outR = inR;
895
896 // filters
897 int amount = filters * 4;
898 for (int i = 0; i < amount; i++) {
899 outL = L[i].process(outL);
900 outR = R[i].process(outR);
901 }
902 // out level
903 outL *= *params[param_level_out];
904 outR *= *params[param_level_out];
905
906 // phase buffer
907 float lemax = fabs(outL) > fabs(outR) ? fabs(outL) : fabs(outR);
908 if (lemax > envelope)
909 envelope = lemax; //attack_coef * (envelope[i] - lemax) + lemax;
910 else
911 envelope = release_coef * (envelope - lemax) + lemax;
912 phase_buffer[ppos] = outL / std::max(0.25f, (envelope));
913 phase_buffer[ppos + 1] = outR / std::max(0.25f, (envelope));
914
915 // phase buffer handling
916 plength = std::min(phase_buffer_size, plength + 2);
917 ppos += 2;
918 ppos %= (phase_buffer_size - 2);
919
920 // send to output
921 outs[0][offset] = outL;
922 outs[1][offset] = outR;
923
924 // next sample
925 ++offset;
926
927 float values[] = {inL, inR, outL, outR};
928 meters.process(values);
929 } // cycle trough samples
930 bypass.crossfade(ins, outs, 2, orig_offset, orig_numsamples);
931 } // process (no bypass)
932 meters.fall(numsamples);
933 return outputs_mask;
934 }
get_graph(int index,int subindex,int phase,float * data,int points,cairo_iface * context,int * mode) const935 bool multispread_audio_module::get_graph(int index, int subindex, int phase, float *data, int points, cairo_iface *context, int *mode) const
936 {
937 if (subindex || phase)
938 return false;
939 return ::get_graph(*this, index, data, points, 64, 0);
940 }
get_layers(int index,int generation,unsigned int & layers) const941 bool multispread_audio_module::get_layers(int index, int generation, unsigned int &layers) const
942 {
943 redraw_graph = redraw_graph || !generation;
944 layers |= (redraw_graph ? LG_CACHE_GRAPH : LG_NONE) | (generation ? LG_NONE : LG_CACHE_GRID);
945 int red = redraw_graph;
946 if (index == param_amount1)
947 redraw_graph = false;
948 return red;
949 }
get_gridline(int index,int subindex,int phase,float & pos,bool & vertical,std::string & legend,cairo_iface * context) const950 bool multispread_audio_module::get_gridline(int index, int subindex, int phase, float &pos, bool &vertical, std::string &legend, cairo_iface *context) const
951 {
952 if (phase)
953 return false;
954 bool r = get_freq_gridline(subindex, pos, vertical, legend, context, true, 64, 0);
955 if (!vertical)
956 legend = "";
957 return r;
958 }
freq_gain(int index,double freq) const959 float multispread_audio_module::freq_gain(int index, double freq) const
960 {
961 float ret = 1.f;
962 for (int i = 0; i < *params[param_filters] * 4; i++)
963 ret *= (index == param_amount0 ? L : R)[i].freq_gain(freq, (float)srate);
964 return ret;
965 }
get_phase_graph(int index,float ** _buffer,int * _length,int * _mode,bool * _use_fade,float * _fade,int * _accuracy,bool * _display) const966 bool multispread_audio_module::get_phase_graph(int index, float ** _buffer, int *_length, int * _mode, bool * _use_fade, float * _fade, int * _accuracy, bool * _display) const {
967 *_buffer = &phase_buffer[0];
968 *_length = plength;
969 *_use_fade = 1;
970 *_fade = 0.6;
971 *_mode = 0;
972 *_accuracy = 3;
973 *_display = true;
974 return false;
975 }
976 /**********************************************************************
977 * WIDGETS TEST
978 **********************************************************************/
979
widgets_audio_module()980 widgets_audio_module::widgets_audio_module() {
981 }
~widgets_audio_module()982 widgets_audio_module::~widgets_audio_module() {
983 }
984
params_changed()985 void widgets_audio_module::params_changed() {
986
987 }
988
process(uint32_t offset,uint32_t numsamples,uint32_t inputs_mask,uint32_t outputs_mask)989 uint32_t widgets_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
990 float meter_1, meter_2, meter_3, meter_4;
991 for(uint32_t i = offset; i < offset + numsamples; i++) {
992 meter_1 = 0.f;
993 meter_2 = 0.f;
994 meter_3 = 0.f;
995 meter_4 = 0.f;
996
997 //float L = ins[0][i];
998 //float R = ins[1][i];
999 float values[] = {meter_1, meter_2, meter_3, meter_4};
1000 meters.process(values);
1001 }
1002 meters.fall(numsamples);
1003 return outputs_mask;
1004 }
1005
set_sample_rate(uint32_t sr)1006 void widgets_audio_module::set_sample_rate(uint32_t sr)
1007 {
1008 srate = sr;
1009 int meter[] = {param_meter1, param_meter2, param_meter3, param_meter4};
1010 int clip[] = {0, 0, 0, 0};
1011 meters.init(params, meter, clip, 4, sr);
1012 }
1013