falkTX
/
Carla-Plugins
mirror of https://github.com/falkTX/Carla-Plugins
1
0
Fork 0
Code Releases 0 Activity
External plugins for Carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
37 Commits
2 Branches
3.3MB
Branch: develop
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'develop'
${ noResults }
Carla-Plugins/zynaddsubfx/Effects/DynamicFilter.cpp

366 lines
11KB
Raw Permalink Blame History 

  1. /*

  2.   ZynAddSubFX - a software synthesizer

  3. 

  4.   DynamicFilter.cpp - "WahWah" effect and others

  5.   Copyright (C) 2002-2005 Nasca Octavian Paul

  6.   Author: Nasca Octavian Paul

  7. 

  8.   This program is free software; you can redistribute it and/or

  9.   modify it under the terms of the GNU General Public License

  10.   as published by the Free Software Foundation; either version 2

  11.   of the License, or (at your option) any later version.

  12. */

  13. 

  14. #include <cassert>

  15. #include <cmath>

  16. #include <iostream>

  17. #include "DynamicFilter.h"

  18. #include "../DSP/Filter.h"

  19. #include "../Misc/Allocator.h"

  20. #include <rtosc/ports.h>

  21. #include <rtosc/port-sugar.h>

  22. 

  23. namespace zyncarla {

  24. 

  25. #define rObject DynamicFilter

  26. #define rBegin [](const char *msg, rtosc::RtData &d) {

  27. #define rEnd }

  28. 

  29. rtosc::Ports DynamicFilter::ports = {

  30.     {"preset::i", rOptions(WahWah, AutoWah, Sweep, VocalMorph1, VocalMorph1)

  31.                   rDoc("Instrument Presets"), 0,

  32.                   rBegin;

  33.                   rObject *o = (rObject*)d.obj;

  34.                   if(rtosc_narguments(msg))

  35.                       o->setpreset(rtosc_argument(msg, 0).i);

  36.                   else

  37.                       d.reply(d.loc, "i", o->Ppreset);

  38.                   rEnd},

  39.     rEffParVol(rDefault(110), rPreset(2, 110), rPreset(4, 127)),

  40.     rEffParPan(),

  41.     rEffPar(Pfreq,      2, rShort("freq"),   rPresets(80, 70, 30, 80, 50),

  42.             "Effect Frequency"),

  43.     rEffPar(Pfreqrnd,   3, rShort("rand"),   rDefault(0),

  44.             "Frequency Randomness"),

  45.     rEffPar(PLFOtype,   4, rShort("shape"),  rOptions(sin, tri), rDefault(sin),

  46.             "LFO Shape"),

  47.     rEffPar(PStereo,    5, rShort("stereo"), rPresets(64, 80, 50, 64, 96),

  48.             "Stereo Mode"),

  49.     rEffPar(Pdepth,     6, rShort("depth"),  rPresets(0, 70, 80, 0, 64),

  50.             "LFO Depth"),

  51.     rEffPar(Pampsns,    7, rShort("sense"),

  52.             rPreset(0, 90) rPreset(3, 64) rDefault(0),

  53.             "how the filter varies according to the input amplitude"),

  54.     rEffPar(Pampsnsinv, 8, rShort("sns.inv"), rDefault(0),  "Sense Inversion"),

  55.     rEffPar(Pampsmooth, 9, rShort("smooth"),  rDefault(60),

  56.             "how smooth the input amplitude changes the filter"),

  57. };

  58. #undef rBegin

  59. #undef rEnd

  60. #undef rObject

  61. 

  62. DynamicFilter::DynamicFilter(EffectParams pars, const AbsTime *time)

  63.     :Effect(pars),

  64.       lfo(pars.srate, pars.bufsize),

  65.       Pvolume(110),

  66.       Pdepth(0),

  67.       Pampsns(90),

  68.       Pampsnsinv(0),

  69.       Pampsmooth(60),

  70.       filterl(NULL),

  71.       filterr(NULL)

  72. {

  73.     filterpars = pars.filterpars;

  74.     setpreset(Ppreset, pars.filterprotect);

  75.     cleanup();

  76. }

  77. 

  78. DynamicFilter::~DynamicFilter()

  79. {

  80.     memory.dealloc(filterl);

  81.     memory.dealloc(filterr);

  82. }

  83. 

  84. 

  85. // Apply the effect

  86. void DynamicFilter::out(const Stereo<float *> &smp)

  87. {

  88.     if(filterpars->changed) {

  89.         filterpars->changed = false;

  90.         cleanup();

  91.     }

  92. 

  93.     float lfol, lfor;

  94.     lfo.effectlfoout(&lfol, &lfor);

  95.     lfol *= depth * 5.0f;

  96.     lfor *= depth * 5.0f;

  97.     const float freq = filterpars->getfreq();

  98.     const float q    = filterpars->getq();

  99. 

  100.     for(int i = 0; i < buffersize; ++i) {

  101.         efxoutl[i] = smp.l[i];

  102.         efxoutr[i] = smp.r[i];

  103. 

  104.         const float x = (fabsf(smp.l[i]) + fabsf(smp.r[i])) * 0.5f;

  105.         ms1 = ms1 * (1.0f - ampsmooth) + x * ampsmooth + 1e-10;

  106.     }

  107. 

  108.     const float ampsmooth2 = powf(ampsmooth, 0.2f) * 0.3f;

  109.     ms2 = ms2 * (1.0f - ampsmooth2) + ms1 * ampsmooth2;

  110.     ms3 = ms3 * (1.0f - ampsmooth2) + ms2 * ampsmooth2;

  111.     ms4 = ms4 * (1.0f - ampsmooth2) + ms3 * ampsmooth2;

  112.     const float rms = (sqrtf(ms4)) * ampsns;

  113. 

  114.     const float frl = Filter::getrealfreq(freq + lfol + rms);

  115.     const float frr = Filter::getrealfreq(freq + lfor + rms);

  116. 

  117.     filterl->setfreq_and_q(frl, q);

  118.     filterr->setfreq_and_q(frr, q);

  119. 

  120.     filterl->filterout(efxoutl);

  121.     filterr->filterout(efxoutr);

  122. 

  123.     //panning

  124.     for(int i = 0; i < buffersize; ++i) {

  125.         efxoutl[i] *= pangainL;

  126.         efxoutr[i] *= pangainR;

  127.     }

  128. }

  129. 

  130. // Cleanup the effect

  131. void DynamicFilter::cleanup(void)

  132. {

  133.     reinitfilter();

  134.     ms1 = ms2 = ms3 = ms4 = 0.0f;

  135. }

  136. 

  137. 

  138. //Parameter control

  139. void DynamicFilter::setdepth(unsigned char _Pdepth)

  140. {

  141.     Pdepth = _Pdepth;

  142.     depth  = powf(Pdepth / 127.0f, 2.0f);

  143. }

  144. 

  145. 

  146. void DynamicFilter::setvolume(unsigned char _Pvolume)

  147. {

  148.     Pvolume   = _Pvolume;

  149.     outvolume = Pvolume / 127.0f;

  150.     if(!insertion)

  151.         volume = 1.0f;

  152.     else

  153.         volume = outvolume;

  154. }

  155. 

  156. void DynamicFilter::setampsns(unsigned char _Pampsns)

  157. {

  158.     Pampsns = _Pampsns;

  159.     ampsns  = powf(Pampsns / 127.0f, 2.5f) * 10.0f;

  160.     if(Pampsnsinv)

  161.         ampsns = -ampsns;

  162.     ampsmooth = expf(-Pampsmooth / 127.0f * 10.0f) * 0.99f;

  163. }

  164. 

  165. void DynamicFilter::reinitfilter(void)

  166. {

  167.     memory.dealloc(filterl);

  168.     memory.dealloc(filterr);

  169. 

  170.     try {

  171.         filterl = Filter::generate(memory, filterpars, samplerate, buffersize);

  172.     } catch(std::bad_alloc& ba) {

  173.         std::cerr << "failed to generate left filter for dynamic filter: " << ba.what() << std::endl;

  174.     }

  175. 

  176.     try {

  177.         filterr = Filter::generate(memory, filterpars, samplerate, buffersize);

  178.     } catch(std::bad_alloc& ba) {

  179.         std::cerr << "failed to generate right filter for dynamic filter: " << ba.what() << std::endl;

  180.     }

  181. }

  182. 

  183. void DynamicFilter::setfilterpreset(unsigned char npreset)

  184. {

  185.     filterpars->defaults();

  186. 

  187.     switch(npreset) {

  188.         case 0:

  189.             filterpars->Pcategory = 0;

  190.             filterpars->Ptype     = 2;

  191.             filterpars->Pfreq     = 45;

  192.             filterpars->Pq      = 64;

  193.             filterpars->Pstages = 1;

  194.             filterpars->Pgain   = 64;

  195.             break;

  196.         case 1:

  197.             filterpars->Pcategory = 2;

  198.             filterpars->Ptype     = 0;

  199.             filterpars->Pfreq     = 72;

  200.             filterpars->Pq      = 64;

  201.             filterpars->Pstages = 0;

  202.             filterpars->Pgain   = 64;

  203.             break;

  204.         case 2:

  205.             filterpars->Pcategory = 0;

  206.             filterpars->Ptype     = 4;

  207.             filterpars->Pfreq     = 64;

  208.             filterpars->Pq      = 64;

  209.             filterpars->Pstages = 2;

  210.             filterpars->Pgain   = 64;

  211.             break;

  212.         case 3:

  213.             filterpars->Pcategory = 1;

  214.             filterpars->Ptype     = 0;

  215.             filterpars->Pfreq     = 50;

  216.             filterpars->Pq      = 70;

  217.             filterpars->Pstages = 1;

  218.             filterpars->Pgain   = 64;

  219. 

  220.             filterpars->Psequencesize = 2;

  221.             // "I"

  222.             filterpars->Pvowels[0].formants[0].freq = 34;

  223.             filterpars->Pvowels[0].formants[0].amp  = 127;

  224.             filterpars->Pvowels[0].formants[0].q    = 64;

  225.             filterpars->Pvowels[0].formants[1].freq = 99;

  226.             filterpars->Pvowels[0].formants[1].amp  = 122;

  227.             filterpars->Pvowels[0].formants[1].q    = 64;

  228.             filterpars->Pvowels[0].formants[2].freq = 108;

  229.             filterpars->Pvowels[0].formants[2].amp  = 112;

  230.             filterpars->Pvowels[0].formants[2].q    = 64;

  231.             // "A"

  232.             filterpars->Pvowels[1].formants[0].freq = 61;

  233.             filterpars->Pvowels[1].formants[0].amp  = 127;

  234.             filterpars->Pvowels[1].formants[0].q    = 64;

  235.             filterpars->Pvowels[1].formants[1].freq = 71;

  236.             filterpars->Pvowels[1].formants[1].amp  = 121;

  237.             filterpars->Pvowels[1].formants[1].q    = 64;

  238.             filterpars->Pvowels[1].formants[2].freq = 99;

  239.             filterpars->Pvowels[1].formants[2].amp  = 117;

  240.             filterpars->Pvowels[1].formants[2].q    = 64;

  241.             break;

  242.         case 4:

  243.             filterpars->Pcategory = 1;

  244.             filterpars->Ptype     = 0;

  245.             filterpars->Pfreq     = 64;

  246.             filterpars->Pq      = 70;

  247.             filterpars->Pstages = 1;

  248.             filterpars->Pgain   = 64;

  249. 

  250.             filterpars->Psequencesize   = 2;

  251.             filterpars->Pnumformants    = 2;

  252.             filterpars->Pvowelclearness = 0;

  253. 

  254.             filterpars->Pvowels[0].formants[0].freq = 70;

  255.             filterpars->Pvowels[0].formants[0].amp  = 127;

  256.             filterpars->Pvowels[0].formants[0].q    = 64;

  257.             filterpars->Pvowels[0].formants[1].freq = 80;

  258.             filterpars->Pvowels[0].formants[1].amp  = 122;

  259.             filterpars->Pvowels[0].formants[1].q    = 64;

  260. 

  261.             filterpars->Pvowels[1].formants[0].freq = 20;

  262.             filterpars->Pvowels[1].formants[0].amp  = 127;

  263.             filterpars->Pvowels[1].formants[0].q    = 64;

  264.             filterpars->Pvowels[1].formants[1].freq = 100;

  265.             filterpars->Pvowels[1].formants[1].amp  = 121;

  266.             filterpars->Pvowels[1].formants[1].q    = 64;

  267.             break;

  268.     }

  269. 

  270. //	    for (int i=0;i<5;i++){

  271. //		printf("freq=%d  amp=%d  q=%d\n",filterpars->Pvowels[0].formants[i].freq,filterpars->Pvowels[0].formants[i].amp,filterpars->Pvowels[0].formants[i].q);

  272. //	    };

  273.     reinitfilter();

  274. }

  275. 

  276. void DynamicFilter::setpreset(unsigned char npreset, bool protect)

  277. {

  278.     const int     PRESET_SIZE = 10;

  279.     const int     NUM_PRESETS = 5;

  280.     unsigned char presets[NUM_PRESETS][PRESET_SIZE] = {

  281.         //WahWah

  282.         {110, 64, 80, 0, 0, 64, 0,  90, 0, 60},

  283.         //AutoWah

  284.         {110, 64, 70, 0, 0, 80, 70, 0,  0, 60},

  285.         //Sweep

  286.         {100, 64, 30, 0, 0, 50, 80, 0,  0, 60},

  287.         //VocalMorph1

  288.         {110, 64, 80, 0, 0, 64, 0,  64, 0, 60},

  289.         //VocalMorph1

  290.         {127, 64, 50, 0, 0, 96, 64, 0,  0, 60}

  291.     };

  292. 

  293.     if(npreset >= NUM_PRESETS)

  294.         npreset = NUM_PRESETS - 1;

  295.     for(int n = 0; n < PRESET_SIZE; ++n)

  296.         changepar(n, presets[npreset][n]);

  297. 

  298.     if(insertion == 0) //lower the volume if this is system effect

  299.         changepar(0, presets[npreset][0] * 0.5f);

  300.     Ppreset = npreset;

  301.     if(!protect)

  302.         setfilterpreset(npreset);

  303. }

  304. 

  305. 

  306. void DynamicFilter::changepar(int npar, unsigned char value)

  307. {

  308.     switch(npar) {

  309.         case 0:

  310.             setvolume(value);

  311.             break;

  312.         case 1:

  313.             setpanning(value);

  314.             break;

  315.         case 2:

  316.             lfo.Pfreq = value;

  317.             lfo.updateparams();

  318.             break;

  319.         case 3:

  320.             lfo.Prandomness = value;

  321.             lfo.updateparams();

  322.             break;

  323.         case 4:

  324.             lfo.PLFOtype = value;

  325.             lfo.updateparams();

  326.             break;

  327.         case 5:

  328.             lfo.Pstereo = value;

  329.             lfo.updateparams();

  330.             break;

  331.         case 6:

  332.             setdepth(value);

  333.             break;

  334.         case 7:

  335.             setampsns(value);

  336.             break;

  337.         case 8:

  338.             Pampsnsinv = value;

  339.             setampsns(Pampsns);

  340.             break;

  341.         case 9:

  342.             Pampsmooth = value;

  343.             setampsns(Pampsns);

  344.             break;

  345.     }

  346. }

  347. 

  348. unsigned char DynamicFilter::getpar(int npar) const

  349. {

  350.     switch(npar) {

  351.         case 0:  return Pvolume;

  352.         case 1:  return Ppanning;

  353.         case 2:  return lfo.Pfreq;

  354.         case 3:  return lfo.Prandomness;

  355.         case 4:  return lfo.PLFOtype;

  356.         case 5:  return lfo.Pstereo;

  357.         case 6:  return Pdepth;

  358.         case 7:  return Pampsns;

  359.         case 8:  return Pampsnsinv;

  360.         case 9:  return Pampsmooth;

  361.         default: return 0;

  362.     }

  363. }

  364. 

  365. }