src/modules_tools.cpp

   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 <sys/time.h>
  28 #include <calf/utils.h>
  29
  30
  31 using namespace dsp;
  32 using namespace calf_plugins;
  33
  34 #define SET_IF_CONNECTED(name) if (params[AM::param_##name] != NULL) *params[AM::param_##name] = name;
  35 #define sinc(x) (!x) ? 1 : sin(M_PI * x)/(M_PI * x);
  36
  37 /**********************************************************************
  38  * STEREO TOOLS by Markus Schmidt
  39 **********************************************************************/
  40
  41 stereo_audio_module::stereo_audio_module() {
  42     active      = false;
  43     _phase      = -1;
  44 }
  45 stereo_audio_module::~stereo_audio_module() {
  46     free(buffer);
  47 }
  48 void stereo_audio_module::activate() {
  49     active = true;
  50 }
  51
  52 void stereo_audio_module::deactivate() {
  53     active = false;
  54 }
  55
  56 void stereo_audio_module::params_changed() {
  57     if(*params[param_stereo_phase] != _phase) {
  58         _phase = *params[param_stereo_phase];
  59         _phase_cos_coef = cos(_phase / 180 * M_PI);
  60         _phase_sin_coef = sin(_phase / 180 * M_PI);
  61     }
  62     if(*params[param_sc_level] != _sc_level) {
  63         _sc_level = *params[param_sc_level];
  64         _inv_atan_shape = 1.0 / atan(_sc_level);
  65     }
  66 }
  67
  68 uint32_t stereo_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
  69     bool bypassed = bypass.update(*params[param_bypass] > 0.5f, numsamples);
  70     uint32_t orig_offset = offset;
  71     for(uint32_t i = offset; i < offset + numsamples; i++) {
  72         if(bypassed) {
  73             outs[0][i] = ins[0][i];
  74             outs[1][i] = ins[1][i];
  75             meter_inL  = 0.f;
  76             meter_inR  = 0.f;
  77             meter_outL = 0.f;
  78             meter_outR = 0.f;
  79         } else {
  80             meter_inL = 0.f;
  81             meter_inR = 0.f;
  82             meter_outL = 0.f;
  83             meter_outR = 0.f;
  84
  85             float L = ins[0][i];
  86             float R = ins[1][i];
  87
  88             // levels in
  89             L *= *params[param_level_in];
  90             R *= *params[param_level_in];
  91
  92             // balance in
  93             L *= (1.f - std::max(0.f, *params[param_balance_in]));
  94             R *= (1.f + std::min(0.f, *params[param_balance_in]));
  95
  96             // softclip
  97             if(*params[param_softclip]) {
  98                 R = _inv_atan_shape * atan(R * _sc_level);
  99                 L = _inv_atan_shape * atan(L * _sc_level);
 100             }
 101
 102             // GUI stuff
 103             meter_inL = L;
 104             meter_inR = R;
 105
 106             // modes
 107             float slev = *params[param_slev];       // slev - stereo level ( -2 -> 2 )
 108             float sbal = 1 + *params[param_sbal];   // sbal - stereo balance ( 0 -> 2 )
 109             float mlev = *params[param_mlev];       // mlev - mono level ( 0 -> 2 )
 110             float mpan = (1 + *params[param_mpan]); // mpan - mono pan ( 0 -> 1 )
 111
 112             float l, r, m, s;
 113
 114             switch((int)*params[param_mode])
 115             {
 116                 case 0:
 117                     // LR > LR
 118                     m = (L + R) * 0.5;
 119                     s = (L - R) * 0.5;
 120                     l = m * mlev * std::min(1.f, 2.f - mpan) + s * slev * std::min(1.f, 2.f - sbal);
 121                     r = m * mlev * std::min(1.f, mpan)       - s * slev * std::min(1.f, sbal);
 122                     L = l;
 123                     R = r;
 124                     break;
 125                 case 1:
 126                     // LR > MS
 127                     l = L * std::min(1.f, 2.f - sbal);
 128                     r = R * std::min(1.f, sbal);
 129                     L = 0.5 * (l + r) * mlev;
 130                     R = 0.5 * (l - r) * slev;
 131                     break;
 132                 case 2:
 133                     // MS > LR
 134                     l = L * mlev * std::min(1.f, 2.f - mpan) + R * slev * std::min(1.f, 2.f - sbal);
 135                     r = L * mlev * std::min(1.f, mpan)       - R * slev * std::min(1.f, sbal);
 136                     L = l;
 137                     R = r;
 138                     break;
 139                 case 3:
 140                     // LR > LL
 141                     R = L;
 142                     break;
 143                 case 4:
 144                     // LR > RR
 145                     L = R;
 146                     break;
 147                 case 5:
 148                     // LR > L+R
 149                     L = (L + R) / 2;
 150                     R = L;
 151                     break;
 152                 case 6:
 153                     // LR > RL
 154                     l = L;
 155                     L = R;
 156                     R = l;
 157                     break;
 158             }
 159
 160             // mute
 161             L *= (1 - floor(*params[param_mute_l] + 0.5));
 162             R *= (1 - floor(*params[param_mute_r] + 0.5));
 163
 164             // phase
 165             L *= (2 * (1 - floor(*params[param_phase_l] + 0.5))) - 1;
 166             R *= (2 * (1 - floor(*params[param_phase_r] + 0.5))) - 1;
 167
 168             // delay
 169             buffer[pos]     = L;
 170             buffer[pos + 1] = R;
 171
 172             int nbuf = srate * (fabs(*params[param_delay]) / 1000.f);
 173             nbuf -= nbuf % 2;
 174             if(*params[param_delay] > 0.f) {
 175                 R = buffer[(pos - (int)nbuf + 1 + buffer_size) % buffer_size];
 176             } else if (*params[param_delay] < 0.f) {
 177                 L = buffer[(pos - (int)nbuf + buffer_size)     % buffer_size];
 178             }
 179
 180             // stereo base
 181             float _sb = *params[param_stereo_base];
 182             if(_sb < 0) _sb *= 0.5;
 183
 184             float __l = L + _sb * L - _sb * R;
 185             float __r = R + _sb * R - _sb * L;
 186
 187             L = __l;
 188             R = __r;
 189
 190             // stereo phase
 191             __l = L * _phase_cos_coef - R * _phase_sin_coef;
 192             __r = L * _phase_sin_coef + R * _phase_cos_coef;
 193
 194             L = __l;
 195             R = __r;
 196
 197             pos = (pos + 2) % buffer_size;
 198
 199             // balance out
 200             L *= (1.f - std::max(0.f, *params[param_balance_out]));
 201             R *= (1.f + std::min(0.f, *params[param_balance_out]));
 202
 203             // level
 204             L *= *params[param_level_out];
 205             R *= *params[param_level_out];
 206
 207             //output
 208             outs[0][i] = L;
 209             outs[1][i] = R;
 210
 211             meter_outL = L;
 212             meter_outR = R;
 213
 214             // phase meter
 215             if(fabs(L) > 0.001 and fabs(R) > 0.001) {
 216                 meter_phase = fabs(fabs(L+R) > 0.000000001 ? sin(fabs((L-R)/(L+R))) : 0.f);
 217             } else {
 218                 meter_phase = 0.f;
 219             }
 220         }
 221         float values[] = {meter_inL, meter_inR, meter_outL, meter_outR};
 222         meters.process(values);
 223     }
 224     if (!bypassed)
 225         bypass.crossfade(ins, outs, 2, orig_offset, numsamples);
 226     meters.fall(numsamples);
 227     return outputs_mask;
 228 }
 229
 230 void stereo_audio_module::set_sample_rate(uint32_t sr)
 231 {
 232     srate = sr;
 233     // rebuild buffer
 234     buffer_size = (int)(srate * 0.05 * 2.f); // buffer size attack rate multiplied by 2 channels
 235     buffer = (float*) calloc(buffer_size, sizeof(float));
 236     pos = 0;
 237     int meter[] = {param_meter_inL, param_meter_inR,  param_meter_outL, param_meter_outR};
 238     int clip[] = {param_clip_inL, param_clip_inR, param_clip_outL, param_clip_outR};
 239     meters.init(params, meter, clip, 4, sr);
 240 }
 241
 242 /**********************************************************************
 243  * MONO INPUT by Markus Schmidt
 244 **********************************************************************/
 245
 246 mono_audio_module::mono_audio_module() {
 247     active      = false;
 248     meter_in    = 0.f;
 249     meter_outL  = 0.f;
 250     meter_outR  = 0.f;
 251     _phase      = -1.f;
 252 }
 253 mono_audio_module::~mono_audio_module() {
 254     free(buffer);
 255 }
 256 void mono_audio_module::activate() {
 257     active = true;
 258 }
 259
 260 void mono_audio_module::deactivate() {
 261     active = false;
 262 }
 263
 264 void mono_audio_module::params_changed() {
 265     if(*params[param_sc_level] != _sc_level) {
 266         _sc_level = *params[param_sc_level];
 267         _inv_atan_shape = 1.0 / atan(_sc_level);
 268     }
 269     if(*params[param_stereo_phase] != _phase) {
 270         _phase = *params[param_stereo_phase];
 271         _phase_cos_coef = cos(_phase / 180 * M_PI);
 272         _phase_sin_coef = sin(_phase / 180 * M_PI);
 273     }
 274 }
 275
 276 uint32_t mono_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
 277     bool bypassed = bypass.update(*params[param_bypass] > 0.5f, numsamples);
 278     uint32_t orig_offset = offset;
 279     for(uint32_t i = offset; i < offset + numsamples; i++) {
 280         if(bypassed) {
 281             outs[0][i] = ins[0][i];
 282             outs[1][i] = ins[0][i];
 283             meter_in    = 0.f;
 284             meter_outL  = 0.f;
 285             meter_outR  = 0.f;
 286         } else {
 287             meter_in     = 0.f;
 288             meter_outL   = 0.f;
 289             meter_outR   = 0.f;
 290
 291             float L = ins[0][i];
 292
 293             // levels in
 294             L *= *params[param_level_in];
 295
 296             // softclip
 297             if(*params[param_softclip]) {
 298                 //int ph = L / fabs(L);
 299                 //L = L > 0.63 ? ph * (0.63 + 0.36 * (1 - pow(MATH_E, (1.f / 3) * (0.63 + L * ph)))) : L;
 300                 L = _inv_atan_shape * atan(L * _sc_level);
 301             }
 302
 303             // GUI stuff
 304             meter_in = L;
 305
 306             float R = L;
 307
 308             // mute
 309             L *= (1 - floor(*params[param_mute_l] + 0.5));
 310             R *= (1 - floor(*params[param_mute_r] + 0.5));
 311
 312             // phase
 313             L *= (2 * (1 - floor(*params[param_phase_l] + 0.5))) - 1;
 314             R *= (2 * (1 - floor(*params[param_phase_r] + 0.5))) - 1;
 315
 316             // delay
 317             buffer[pos]     = L;
 318             buffer[pos + 1] = R;
 319
 320             int nbuf = srate * (fabs(*params[param_delay]) / 1000.f);
 321             nbuf -= nbuf % 2;
 322             if(*params[param_delay] > 0.f) {
 323                 R = buffer[(pos - (int)nbuf + 1 + buffer_size) % buffer_size];
 324             } else if (*params[param_delay] < 0.f) {
 325                 L = buffer[(pos - (int)nbuf + buffer_size)     % buffer_size];
 326             }
 327
 328             // stereo base
 329             float _sb = *params[param_stereo_base];
 330             if(_sb < 0) _sb *= 0.5;
 331
 332             float __l = L +_sb * L - _sb * R;
 333             float __r = R + _sb * R - _sb * L;
 334
 335             L = __l;
 336             R = __r;
 337
 338             // stereo phase
 339             __l = L * _phase_cos_coef - R * _phase_sin_coef;
 340             __r = L * _phase_sin_coef + R * _phase_cos_coef;
 341
 342             L = __l;
 343             R = __r;
 344
 345             pos = (pos + 2) % buffer_size;
 346
 347             // balance out
 348             L *= (1.f - std::max(0.f, *params[param_balance_out]));
 349             R *= (1.f + std::min(0.f, *params[param_balance_out]));
 350
 351             // level
 352             L *= *params[param_level_out];
 353             R *= *params[param_level_out];
 354
 355             //output
 356             outs[0][i] = L;
 357             outs[1][i] = R;
 358
 359             meter_outL = L;
 360             meter_outR = R;
 361         }
 362         float values[] = {meter_in, meter_outL, meter_outR};
 363         meters.process(values);
 364     }
 365     if (!bypassed)
 366         bypass.crossfade(ins, outs, 2, orig_offset, numsamples);
 367     meters.fall(numsamples);
 368     return outputs_mask;
 369 }
 370
 371 void mono_audio_module::set_sample_rate(uint32_t sr)
 372 {
 373     srate = sr;
 374     // rebuild buffer
 375     buffer_size = (int)srate * 0.05 * 2; // delay buffer size multiplied by 2 channels
 376     buffer = (float*) calloc(buffer_size, sizeof(float));
 377     pos = 0;
 378     int meter[] = {param_meter_in,  param_meter_outL, param_meter_outR};
 379     int clip[] = {param_clip_in, param_clip_outL, param_clip_outR};
 380     meters.init(params, meter, clip, 3, sr);
 381 }
 382
 383 /**********************************************************************
 384  * ANALYZER by Markus Schmidt and Christian Holschuh
 385 **********************************************************************/
 386
 387 analyzer_audio_module::analyzer_audio_module() {
 388
 389     active          = false;
 390     clip_L          = 0.f;
 391     clip_R          = 0.f;
 392     meter_L         = 0.f;
 393     meter_R         = 0.f;
 394     envelope        = 0.f;
 395     ppos            = 0;
 396     plength         = 0;
 397     phase_buffer = (float*) calloc(max_phase_buffer_size, sizeof(float));
 398 }
 399 analyzer_audio_module::~analyzer_audio_module() {
 400     free(phase_buffer);
 401 }
 402 void analyzer_audio_module::activate() {
 403     active = true;
 404 }
 405
 406 void analyzer_audio_module::deactivate() {
 407     active = false;
 408 }
 409
 410 void analyzer_audio_module::params_changed() {
 411     float resolution, offset;
 412     switch((int)*params[param_analyzer_mode]) {
 413         case 0:
 414         case 1:
 415         case 2:
 416         case 3:
 417         default:
 418             // analyzer
 419             resolution = pow(64, *params[param_analyzer_level]);
 420             offset = 0.75;
 421             break;
 422         case 4:
 423             // we want to draw Stereo Image
 424             resolution = pow(64, *params[param_analyzer_level] * 1.75);
 425             offset = 1.f;
 426             break;
 427         case 5:
 428             // We want to draw Stereo Difference
 429             offset = *params[param_analyzer_level] > 1
 430                 ? 1 + (*params[param_analyzer_level] - 1) / 4
 431                 : *params[param_analyzer_level];
 432             resolution = pow(64, 2 * offset);
 433             break;
 434     }
 435
 436     _analyzer.set_params(
 437         resolution,
 438         offset,
 439         *params[param_analyzer_accuracy],
 440         *params[param_analyzer_hold],
 441         *params[param_analyzer_smoothing],
 442         *params[param_analyzer_mode],
 443         *params[param_analyzer_scale],
 444         *params[param_analyzer_post],
 445         *params[param_analyzer_speed],
 446         *params[param_analyzer_windowing],
 447         *params[param_analyzer_view],
 448         *params[param_analyzer_freeze]
 449     );
 450 }
 451
 452 uint32_t analyzer_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
 453     for(uint32_t i = offset; i < offset + numsamples; i++) {
 454         // let meters fall a bit
 455         clip_L   -= std::min(clip_L, numsamples);
 456         clip_R   -= std::min(clip_R, numsamples);
 457         meter_L   = 0.f;
 458         meter_R   = 0.f;
 459
 460         float L = ins[0][i];
 461         float R = ins[1][i];
 462
 463         // GUI stuff
 464         if(L > 1.f) clip_L = srate >> 3;
 465         if(R > 1.f) clip_R = srate >> 3;
 466
 467         // goniometer
 468         //the goniometer tries to show the signal in maximum
 469         //size. therefor an envelope with fast attack and slow
 470         //release is calculated with the max value of left and right.
 471         float lemax  = fabs(L) > fabs(R) ? fabs(L) : fabs(R);
 472         attack_coef  = exp(log(0.01)/(0.01 * srate * 0.001));
 473         release_coef = exp(log(0.01)/(2000 * srate * 0.001));
 474         if( lemax > envelope)
 475            envelope  = lemax; //attack_coef * (envelope - lemax) + lemax;
 476         else
 477            envelope  = release_coef * (envelope - lemax) + lemax;
 478
 479         //use the envelope to bring biggest signal to 1. the biggest
 480         //enlargement of the signal is 4.
 481
 482         phase_buffer[ppos]     = L / std::max(0.25f , (envelope));
 483         phase_buffer[ppos + 1] = R / std::max(0.25f , (envelope));
 484
 485
 486         plength = std::min(phase_buffer_size, plength + 2);
 487         ppos += 2;
 488         ppos %= (phase_buffer_size - 2);
 489
 490         // analyzer
 491         _analyzer.process(L, R);
 492
 493         // meter
 494         meter_L = L;
 495         meter_R = R;
 496
 497         //output
 498         outs[0][i] = L;
 499         outs[1][i] = R;
 500     }
 501     // draw meters
 502     SET_IF_CONNECTED(clip_L);
 503     SET_IF_CONNECTED(clip_R);
 504     SET_IF_CONNECTED(meter_L);
 505     SET_IF_CONNECTED(meter_R);
 506     return outputs_mask;
 507 }
 508
 509 void analyzer_audio_module::set_sample_rate(uint32_t sr)
 510 {
 511     srate = sr;
 512     phase_buffer_size = srate / 30 * 2;
 513     phase_buffer_size -= phase_buffer_size % 2;
 514     phase_buffer_size = std::min(phase_buffer_size, (int)max_phase_buffer_size);
 515     _analyzer.set_sample_rate(sr);
 516 }
 517
 518 bool analyzer_audio_module::get_phase_graph(float ** _buffer, int *_length, int * _mode, bool * _use_fade, float * _fade, int * _accuracy, bool * _display) const {
 519     *_buffer   = &phase_buffer[0];
 520     *_length   = plength;
 521     *_use_fade = *params[param_gonio_use_fade];
 522     *_fade     = 0.6;
 523     *_mode     = *params[param_gonio_mode];
 524     *_accuracy = *params[param_gonio_accuracy];
 525     *_display  = *params[param_gonio_display];
 526     return false;
 527 }
 528
 529 bool analyzer_audio_module::get_graph(int index, int subindex, int phase, float *data, int points, cairo_iface *context, int *mode) const
 530 {
 531     if (*params[param_analyzer_display])
 532         return _analyzer.get_graph(subindex, phase, data, points, context, mode);
 533     return false;
 534 }
 535 bool analyzer_audio_module::get_moving(int index, int subindex, int &direction, float *data, int x, int y, int &offset, uint32_t &color) const
 536 {
 537     if (*params[param_analyzer_display])
 538         return _analyzer.get_moving(subindex, direction, data, x, y, offset, color);
 539     return false;
 540 }
 541 bool analyzer_audio_module::get_gridline(int index, int subindex, int phase, float &pos, bool &vertical, std::string &legend, cairo_iface *context) const
 542 {
 543     return _analyzer.get_gridline(subindex, phase, pos, vertical, legend, context);
 544 }
 545 bool analyzer_audio_module::get_layers(int index, int generation, unsigned int &layers) const
 546 {
 547     return _analyzer.get_layers(generation, layers);
 548 }
 549
 550
 551
 552 /**********************************************************************
 553  * WIDGETS TEST
 554 **********************************************************************/
 555
 556 widgets_audio_module::widgets_audio_module() {
 557 }
 558 widgets_audio_module::~widgets_audio_module() {
 559 }
 560
 561 void widgets_audio_module::params_changed() {
 562
 563 }
 564
 565 uint32_t widgets_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask) {
 566     float meter_1, meter_2, meter_3, meter_4;
 567     for(uint32_t i = offset; i < offset + numsamples; i++) {
 568         meter_1 = 0.f;
 569         meter_2 = 0.f;
 570         meter_3 = 0.f;
 571         meter_4 = 0.f;
 572
 573         //float L = ins[0][i];
 574         //float R = ins[1][i];
 575         float values[] = {meter_1, meter_2, meter_3, meter_4};
 576         meters.process(values);
 577     }
 578     meters.fall(numsamples);
 579     return outputs_mask;
 580 }
 581
 582 void widgets_audio_module::set_sample_rate(uint32_t sr)
 583 {
 584     srate = sr;
 585     int meter[] = {param_meter1, param_meter2,  param_meter3, param_meter4};
 586     int clip[] = {0, 0, 0, 0};
 587     meters.init(params, meter, clip, 4, sr);
 588 }