falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/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.
3441 Commits
17 Branches
263MB
Tree: f9387f9a34
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f9387f9a34'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/Synth/OscilGen.cpp

1793 lines
51KB
Raw Blame History 

  1. /*

  2.   ZynAddSubFX - a software synthesizer

  3. 

  4.   OscilGen.cpp - Waveform generator for ADnote

  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 "OscilGen.h"

  15. #include "../DSP/FFTwrapper.h"

  16. #include "../Synth/Resonance.h"

  17. #include "../Misc/WaveShapeSmps.h"

  18. 

  19. #include <cassert>

  20. #include <cstdlib>

  21. #include <cmath>

  22. #include <cstdio>

  23. #include <cstddef>

  24. 

  25. #include <unistd.h>

  26. 

  27. #include <rtosc/ports.h>

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

  29. 

  30. #define rObject OscilGen

  31. const rtosc::Ports OscilGen::non_realtime_ports = {

  32.     rSelf(OscilGen),

  33.     rPaste,

  34.     //TODO ensure min/max

  35.     rOption(Phmagtype, rShort("scale"),

  36.             rOptions(linear,dB scale (-40),

  37.                      dB scale (-60), dB scale (-80),

  38.                      dB scale (-100)),

  39.             "Type of magnitude for harmonics"),

  40.     rOption(Pcurrentbasefunc, rShort("base"),

  41.             rOptions(sine, triangle, pulse, saw, power, gauss,

  42.                 diode, abssine, pulsesine, stretchsine,

  43.                 chirp, absstretchsine, chebyshev, sqr,

  44.                 spike, circle), rOpt(127,use-as-base waveform),

  45.             "Base Waveform for harmonics"),

  46.     rParamZyn(Pbasefuncpar, rShort("shape"),

  47.             "Morph between possible base function shapes "

  48.             "(e.g. rising sawtooth vs a falling sawtooth)"),

  49.     rOption(Pbasefuncmodulation, rShort("mod"),

  50.             rOptions(None, Rev, Sine, Power, Chop),

  51.             "Modulation applied to Base function spectra"),

  52.     rParamZyn(Pbasefuncmodulationpar1, rShort("p1"),

  53.             "Base function modulation parameter"),

  54.     rParamZyn(Pbasefuncmodulationpar2, rShort("p2"),

  55.             "Base function modulation parameter"),

  56.     rParamZyn(Pbasefuncmodulationpar3, rShort("p3"),

  57.             "Base function modulation parameter"),

  58.     rParamZyn(Pwaveshaping, rShort("amount"), "Degree Of Waveshaping"),

  59.     rOption(Pwaveshapingfunction, rShort("distort"),

  60.             rOptions(Undistorted,

  61.                 Arctangent, Asymmetric, Pow, Sine, Quantisize,

  62.                 Zigzag, Limiter, Upper Limiter, Lower Limiter,

  63.                 Inverse Limiter, Clip, Asym2, Pow2, sigmoid),

  64.             "Shape of distortion to be applied"),

  65.     rOption(Pfiltertype, rShort("filter"), rOptions(No Filter,

  66.             lp, hp1, hp1b, bp1, bs1, lp2, hp2, bp2, bs2,

  67.             cos, sin, low_shelf, s), "Harmonic Filter"),

  68.     rParamZyn(Pfilterpar1, rShort("p1"), "Filter parameter"),

  69.     rParamZyn(Pfilterpar2, rShort("p2"), "Filter parameter"),

  70.     rToggle(Pfilterbeforews, rShort("pre/post"), "Filter before waveshaping spectra;"

  71.             "When enabled oscilfilter(freqs); then waveshape(freqs);, "

  72.             "otherwise waveshape(freqs); then oscilfilter(freqs);"),

  73.     rOption(Psatype, rShort("spec. adj."), rOptions(None, Pow, ThrsD, ThrsU),

  74.             "Spectral Adjustment Type"),

  75.     rParamZyn(Psapar, rShort("p1"), "Spectral Adjustment Parameter"),

  76.     rParamI(Pharmonicshift, rLinear(-64,64), rShort("shift"), "Amount of shift on harmonics"),

  77.     rToggle(Pharmonicshiftfirst, rShort("pre/post"), "If harmonics are shifted before waveshaping/filtering"),

  78.     rOption(Pmodulation, rShort("FM"), rOptions(None, Rev, Sine, Power),

  79.             "Frequency Modulation To Combined Spectra"),

  80.     rParamZyn(Pmodulationpar1, rShort("p1"), "modulation parameter"),

  81.     rParamZyn(Pmodulationpar2, rShort("p2"), "modulation parameter"),

  82.     rParamZyn(Pmodulationpar3, rShort("p3"), "modulation parameter"),

  83. 

  84. 

  85.     //TODO update to rArray and test

  86.     {"phase#128::c:i", rProp(parameter) rLinear(0,127) rDoc("Sets harmonic phase"),

  87.         NULL, [](const char *m, rtosc::RtData &d) {

  88.             const char *mm = m;

  89.             while(*mm && !isdigit(*mm)) ++mm;

  90.             unsigned char &phase = ((OscilGen*)d.obj)->Phphase[atoi(mm)];

  91.             if(!rtosc_narguments(m))

  92.                 d.reply(d.loc, "i", phase);

  93.             else {

  94.                 phase = rtosc_argument(m,0).i;

  95.                 //XXX hack hack

  96.                 char  repath[128];

  97.                 strcpy(repath, d.loc);

  98.                 char *edit   = strrchr(repath, '/')+1;

  99.                 strcpy(edit, "prepare");

  100.                 OscilGen &o = *((OscilGen*)d.obj);

  101.                 fft_t *data = new fft_t[o.synth.oscilsize / 2];

  102.                 o.prepare(data);

  103.                 // fprintf(stderr, "sending '%p' of fft data\n", data);

  104.                 d.chain(repath, "b", sizeof(fft_t*), &data);

  105.                 o.pendingfreqs = data;

  106.             }

  107.         }},

  108.     //TODO update to rArray and test

  109.     {"magnitude#128::c:i", rProp(parameter) rLinear(0,127) rDoc("Sets harmonic magnitude"),

  110.         NULL, [](const char *m, rtosc::RtData &d) {

  111.             //printf("I'm at '%s'\n", d.loc);

  112.             const char *mm = m;

  113.             while(*mm && !isdigit(*mm)) ++mm;

  114.             unsigned char &mag = ((OscilGen*)d.obj)->Phmag[atoi(mm)];

  115.             if(!rtosc_narguments(m))

  116.                 d.reply(d.loc, "i", mag);

  117.             else {

  118.                 mag = rtosc_argument(m,0).i;

  119.                 //printf("setting magnitude\n\n");

  120.                 //XXX hack hack

  121.                 char  repath[128];

  122.                 strcpy(repath, d.loc);

  123.                 char *edit   = strrchr(repath, '/')+1;

  124.                 strcpy(edit, "prepare");

  125.                 OscilGen &o = *((OscilGen*)d.obj);

  126.                 fft_t *data = new fft_t[o.synth.oscilsize / 2];

  127.                 o.prepare(data);

  128.                 // fprintf(stderr, "sending '%p' of fft data\n", data);

  129.                 d.chain(repath, "b", sizeof(fft_t*), &data);

  130.                 o.pendingfreqs = data;

  131.             }

  132.         }},

  133.     {"base-spectrum:", rProp(non-realtime) rDoc("Returns spectrum of base waveshape"),

  134.         NULL, [](const char *, rtosc::RtData &d) {

  135.             OscilGen &o = *((OscilGen*)d.obj);

  136.             const unsigned n = o.synth.oscilsize / 2;

  137.             float *spc = new float[n];

  138.             memset(spc, 0, 4*n);

  139.             ((OscilGen*)d.obj)->getspectrum(n,spc,1);

  140.             d.reply(d.loc, "b", n*sizeof(float), spc);

  141.             delete[] spc;

  142.         }},

  143.     {"base-waveform:", rProp(non-realtime) rDoc("Returns base waveshape points"),

  144.         NULL, [](const char *, rtosc::RtData &d) {

  145.             OscilGen &o = *((OscilGen*)d.obj);

  146.             const unsigned n = o.synth.oscilsize;

  147.             float *smps = new float[n];

  148.             memset(smps, 0, 4*n);

  149.             ((OscilGen*)d.obj)->getcurrentbasefunction(smps);

  150.             d.reply(d.loc, "b", n*sizeof(float), smps);

  151.             delete[] smps;

  152.         }},

  153.     {"prepare:", rProp(non-realtime) rDoc("Performs setup operation to oscillator"),

  154.         NULL, [](const char *, rtosc::RtData &d) {

  155.             //fprintf(stderr, "prepare: got a message from '%s'\n", m);

  156.             OscilGen &o = *(OscilGen*)d.obj;

  157.             fft_t *data = new fft_t[o.synth.oscilsize / 2];

  158.             o.prepare(data);

  159.             // fprintf(stderr, "sending '%p' of fft data\n", data);

  160.             d.chain(d.loc, "b", sizeof(fft_t*), &data);

  161.             o.pendingfreqs = data;

  162.         }},

  163.     {"convert2sine:", rProp(non-realtime) rDoc("Translates waveform into FS"),

  164.         NULL, [](const char *, rtosc::RtData &d) {

  165.             ((OscilGen*)d.obj)->convert2sine();

  166.             //XXX hack hack

  167.             char  repath[128];

  168.             strcpy(repath, d.loc);

  169.             char *edit   = strrchr(repath, '/')+1;

  170.             *edit = 0;

  171.             d.reply("/damage", "s", repath);

  172.         }},

  173.     {"use-as-base:", rProp(non-realtime) rDoc("Translates current waveform into base"),

  174.         NULL, [](const char *, rtosc::RtData &d) {

  175.             ((OscilGen*)d.obj)->useasbase();

  176.             //XXX hack hack

  177.             char  repath[128];

  178.             strcpy(repath, d.loc);

  179.             char *edit   = strrchr(repath, '/')+1;

  180.             *edit = 0;

  181.             d.reply("/damage", "s", repath);

  182.         }}};

  183. 

  184. #define rForwardCb [](const char *msg, rtosc::RtData &d) {\

  185.     printf("fowarding...\n"); d.forward();}

  186. const rtosc::Ports OscilGen::realtime_ports{

  187.     rSelf(OscilGen),

  188.     rPresetType,

  189.     rParamZyn(Prand, rLinear(-64, 63), rShort("phase rnd"), "Oscillator Phase Randomness: smaller than 0 is \""

  190.             "group\", larger than 0 is for each harmonic"),

  191.     rParamZyn(Pamprandpower, rShort("variance"),

  192.             "Variance of harmonic randomness"),

  193.     rOption(Pamprandtype, rShort("distribution"), rOptions(None, Pow, Sin),

  194.             "Harmonic random distribution to select from"),

  195.     rOption(Padaptiveharmonics, rShort("adapt")

  196.             rOptions(OFF, ON, Square, 2xSub, 2xAdd, 3xSub, 3xAdd, 4xSub, 4xAdd),

  197.             "Adaptive Harmonics Mode"),

  198.     rParamI(Padaptiveharmonicsbasefreq, rShort("c. freq"), rLinear(0,255),

  199.             "Base frequency of adaptive harmonic (30..3000Hz)"),

  200.     rParamI(Padaptiveharmonicspower, rShort("amount"), rLinear(0,200),

  201.             "Adaptive Harmonic Strength"),

  202.     rParamI(Padaptiveharmonicspar, rShort("power"), rLinear(0,100),

  203.             "Adaptive Harmonics Postprocessing Power"),

  204.     {"waveform:", rDoc("Returns waveform points"),

  205.         NULL, [](const char *, rtosc::RtData &d) {

  206.             OscilGen &o = *((OscilGen*)d.obj);

  207.             const unsigned n = o.synth.oscilsize;

  208.             float *smps = new float[n];

  209.             memset(smps, 0, 4*n);

  210.             //printf("%d\n", o->needPrepare());

  211.             o.get(smps,-1.0);

  212.             //printf("wave: %f %f %f %f\n", smps[0], smps[1], smps[2], smps[3]);

  213.             d.reply(d.loc, "b", n*sizeof(float), smps);

  214.             delete[] smps;

  215.         }},

  216.     {"spectrum:", rDoc("Returns spectrum of waveform"),

  217.         NULL, [](const char *, rtosc::RtData &d) {

  218.             OscilGen &o = *((OscilGen*)d.obj);

  219.             const unsigned n = o.synth.oscilsize / 2;

  220.             float *spc = new float[n];

  221.             memset(spc, 0, 4*n);

  222.             ((OscilGen*)d.obj)->getspectrum(n,spc,0);

  223.             d.reply(d.loc, "b", n*sizeof(float), spc);

  224.             delete[] spc;

  225.         }},

  226.     {"prepare:b", rProp(internal) rProp(realtime) rProp(pointer) rDoc("Sets prepared fft data"),

  227.         NULL, [](const char *m, rtosc::RtData &d) {

  228.             // fprintf(stderr, "prepare:b got a message from '%s'\n", m);

  229.             OscilGen &o = *(OscilGen*)d.obj;

  230.             assert(rtosc_argument(m,0).b.len == sizeof(void*));

  231.             d.reply("/free", "sb", "fft_t", sizeof(void*), &o.oscilFFTfreqs);

  232.             assert(o.oscilFFTfreqs !=*(fft_t**)rtosc_argument(m,0).b.data);

  233.             o.oscilFFTfreqs = *(fft_t**)rtosc_argument(m,0).b.data;

  234.         }},

  235. 

  236. };

  237. 

  238. const rtosc::MergePorts OscilGen::ports{

  239.     &OscilGen::realtime_ports,

  240.     &OscilGen::non_realtime_ports

  241. };

  242. 

  243. #ifndef M_PI_2

  244. # define M_PI_2		1.57079632679489661923	/* pi/2 */

  245. #endif

  246. 

  247. 

  248. //operations on FFTfreqs

  249. inline void clearAll(fft_t *freqs, int oscilsize)

  250. {

  251.     memset(freqs, 0, oscilsize / 2 * sizeof(fft_t));

  252. }

  253. 

  254. inline void clearDC(fft_t *freqs)

  255. {

  256.     freqs[0] = fft_t(0.0f, 0.0f);

  257. }

  258. 

  259. //return magnitude squared

  260. inline float normal(const fft_t *freqs, off_t x)

  261. {

  262.     return norm(freqs[x]);

  263. }

  264. 

  265. //return magnitude

  266. inline float abs(const fft_t *freqs, off_t x)

  267. {

  268.     return abs(freqs[x]);

  269. }

  270. 

  271. //return angle aka phase from a sine (not cosine wave)

  272. inline float arg(const fft_t *freqs, off_t x)

  273. {

  274.     const fft_t tmp(freqs[x].imag(), freqs[x].real());

  275.     return arg(tmp);

  276. }

  277. 

  278. /**

  279.  * Take frequency spectrum and ensure values are normalized based upon

  280.  * magnitude to 0<=x<=1

  281.  */

  282. void normalize(fft_t *freqs, int oscilsize)

  283. {

  284.     float normMax = 0.0f;

  285.     for(int i = 0; i < oscilsize / 2; ++i) {

  286.         //magnitude squared

  287.         const float norm = normal(freqs, i);

  288.         if(normMax < norm)

  289.             normMax = norm;

  290.     }

  291. 

  292.     const float max = sqrt(normMax);

  293.     if(max < 1e-8) //data is all ~zero, do not amplify noise

  294.         return;

  295. 

  296.     for(int i = 0; i < oscilsize / 2; ++i)

  297.         freqs[i] /= max;

  298. }

  299. 

  300. //Full RMS normalize

  301. void rmsNormalize(fft_t *freqs, int oscilsize)

  302. {

  303.     float sum = 0.0f;

  304.     for(int i = 1; i < oscilsize / 2; ++i)

  305.         sum += normal(freqs, i);

  306. 

  307.     if(sum < 0.000001f)

  308.         return;  //data is all ~zero, do not amplify noise

  309. 

  310.     const float gain = 1.0f / sqrt(sum);

  311. 

  312.     for(int i = 1; i < oscilsize / 2; ++i)

  313.         freqs[i] *= gain;

  314. }

  315. 

  316. #define DIFF(par) (old ## par != P ## par)

  317. 

  318. OscilGen::OscilGen(const SYNTH_T &synth_, FFTwrapper *fft_, Resonance *res_)

  319.     :Presets(), synth(synth_)

  320. {

  321.     //assert(fft_);

  322. 

  323.     setpresettype("Poscilgen");

  324.     fft = fft_;

  325.     res = res_;

  326. 

  327. 

  328.     tmpsmps = new float[synth.oscilsize];

  329.     outoscilFFTfreqs = new fft_t[synth.oscilsize / 2];

  330.     oscilFFTfreqs    = new fft_t[synth.oscilsize / 2];

  331.     basefuncFFTfreqs = new fft_t[synth.oscilsize / 2];

  332.     cachedbasefunc = new float[synth.oscilsize];

  333.     cachedbasevalid = false;

  334.     pendingfreqs     = oscilFFTfreqs;

  335. 

  336.     randseed = 1;

  337.     ADvsPAD  = false;

  338. 

  339.     defaults();

  340. }

  341. 

  342. OscilGen::~OscilGen()

  343. {

  344.     delete[] tmpsmps;

  345.     delete[] outoscilFFTfreqs;

  346.     delete[] basefuncFFTfreqs;

  347.     delete[] oscilFFTfreqs;

  348.     delete[] cachedbasefunc;

  349. }

  350. 

  351. 

  352. void OscilGen::defaults()

  353. {

  354.     oldbasefunc = 0;

  355.     oldbasepar  = 64;

  356.     oldhmagtype = 0;

  357.     oldwaveshapingfunction = 0;

  358.     oldwaveshaping = 64;

  359.     oldbasefuncmodulation     = 0;

  360.     oldharmonicshift          = 0;

  361.     oldbasefuncmodulationpar1 = 0;

  362.     oldbasefuncmodulationpar2 = 0;

  363.     oldbasefuncmodulationpar3 = 0;

  364.     oldmodulation     = 0;

  365.     oldmodulationpar1 = 0;

  366.     oldmodulationpar2 = 0;

  367.     oldmodulationpar3 = 0;

  368. 

  369.     for(int i = 0; i < MAX_AD_HARMONICS; ++i) {

  370.         hmag[i]    = 0.0f;

  371.         hphase[i]  = 0.0f;

  372.         Phmag[i]   = 64;

  373.         Phphase[i] = 64;

  374.     }

  375.     Phmag[0]  = 127;

  376.     Phmagtype = 0;

  377.     if(ADvsPAD)

  378.         Prand = 127;       //max phase randomness (usefull if the oscil will be imported to a ADsynth from a PADsynth

  379.     else

  380.         Prand = 64;  //no randomness

  381. 

  382.     Pcurrentbasefunc = 0;

  383.     Pbasefuncpar     = 64;

  384. 

  385.     Pbasefuncmodulation     = 0;

  386.     Pbasefuncmodulationpar1 = 64;

  387.     Pbasefuncmodulationpar2 = 64;

  388.     Pbasefuncmodulationpar3 = 32;

  389. 

  390.     Pmodulation     = 0;

  391.     Pmodulationpar1 = 64;

  392.     Pmodulationpar2 = 64;

  393.     Pmodulationpar3 = 32;

  394. 

  395.     Pwaveshapingfunction = 0;

  396.     Pwaveshaping    = 64;

  397.     Pfiltertype     = 0;

  398.     Pfilterpar1     = 64;

  399.     Pfilterpar2     = 64;

  400.     Pfilterbeforews = 0;

  401.     Psatype = 0;

  402.     Psapar  = 64;

  403. 

  404.     Pamprandpower = 64;

  405.     Pamprandtype  = 0;

  406. 

  407.     Pharmonicshift      = 0;

  408.     Pharmonicshiftfirst = 0;

  409. 

  410.     Padaptiveharmonics         = 0;

  411.     Padaptiveharmonicspower    = 100;

  412.     Padaptiveharmonicsbasefreq = 128;

  413.     Padaptiveharmonicspar      = 50;

  414. 

  415.     clearAll(oscilFFTfreqs, synth.oscilsize);

  416.     clearAll(basefuncFFTfreqs, synth.oscilsize);

  417.     oscilprepared = 0;

  418.     oldfilterpars = 0;

  419.     oldsapars     = 0;

  420.     prepare();

  421. }

  422. 

  423. void OscilGen::convert2sine()

  424. {

  425.     float  mag[MAX_AD_HARMONICS], phase[MAX_AD_HARMONICS];

  426.     float  oscil[synth.oscilsize];

  427.     fft_t *freqs = new fft_t[synth.oscilsize / 2];

  428.     get(oscil, -1.0f);

  429.     FFTwrapper *fft = new FFTwrapper(synth.oscilsize);

  430.     fft->smps2freqs(oscil, freqs);

  431.     delete (fft);

  432. 

  433.     normalize(freqs, synth.oscilsize);

  434. 

  435.     mag[0]   = 0;

  436.     phase[0] = 0;

  437.     for(int i = 0; i < MAX_AD_HARMONICS; ++i) {

  438.         mag[i]   = abs(freqs, i + 1);

  439.         phase[i] = arg(freqs, i + 1);

  440.     }

  441. 

  442.     defaults();

  443. 

  444.     for(int i = 0; i < MAX_AD_HARMONICS - 1; ++i) {

  445.         float newmag   = mag[i];

  446.         float newphase = phase[i];

  447. 

  448.         Phmag[i] = (int) ((newmag) * 63.0f) + 64;

  449. 

  450.         Phphase[i] = 64 - (int) (64.0f * newphase / PI);

  451.         if(Phphase[i] > 127)

  452.             Phphase[i] = 127;

  453. 

  454.         if(Phmag[i] == 64)

  455.             Phphase[i] = 64;

  456.     }

  457.     delete[] freqs;

  458.     prepare();

  459. }

  460. 

  461. float OscilGen::userfunc(float x)

  462. {

  463.     if (!fft)

  464.         return 0;

  465.     if (!cachedbasevalid) {

  466.         fft->freqs2smps(basefuncFFTfreqs, cachedbasefunc);

  467.         cachedbasevalid = true;

  468.     }

  469.     return cinterpolate(cachedbasefunc,

  470.                         synth.oscilsize,

  471.                         synth.oscilsize * (x + 1) - 1);

  472. }

  473. 

  474. /*

  475.  * Get the base function

  476.  */

  477. void OscilGen::getbasefunction(float *smps)

  478. {

  479.     float par = (Pbasefuncpar + 0.5f) / 128.0f;

  480.     if(Pbasefuncpar == 64)

  481.         par = 0.5f;

  482. 

  483.     float p1 = Pbasefuncmodulationpar1 / 127.0f,

  484.           p2 = Pbasefuncmodulationpar2 / 127.0f,

  485.           p3 = Pbasefuncmodulationpar3 / 127.0f;

  486. 

  487.     switch(Pbasefuncmodulation) {

  488.         case 1:

  489.             p1 = (powf(2, p1 * 5.0f) - 1.0f) / 10.0f;

  490.             p3 = floor(powf(2, p3 * 5.0f) - 1.0f);

  491.             if(p3 < 0.9999f)

  492.                 p3 = -1.0f;

  493.             break;

  494.         case 2:

  495.             p1 = (powf(2, p1 * 5.0f) - 1.0f) / 10.0f;

  496.             p3 = 1.0f + floor(powf(2, p3 * 5.0f) - 1.0f);

  497.             break;

  498.         case 3:

  499.             p1 = (powf(2, p1 * 7.0f) - 1.0f) / 10.0f;

  500.             p3 = 0.01f + (powf(2, p3 * 16.0f) - 1.0f) / 10.0f;

  501.             break;

  502.     }

  503. 

  504.     base_func func = getBaseFunction(Pcurrentbasefunc);

  505. 

  506.     for(int i = 0; i < synth.oscilsize; ++i) {

  507.         float t = i * 1.0f / synth.oscilsize;

  508. 

  509.         switch(Pbasefuncmodulation) {

  510.             case 1: //rev

  511.                 t = t * p3 + sinf((t + p2) * 2.0f * PI) * p1;

  512.                 break;

  513.             case 2: //sine

  514.                 t += sinf( (t * p3 + p2) * 2.0f * PI) * p1;

  515.                 break;

  516.             case 3: //power

  517.                 t += powf((1.0f - cosf((t + p2) * 2.0f * PI)) * 0.5f, p3) * p1;

  518.                 break;

  519.             case 4: //chop

  520.                 t = t * (powf(2.0, Pbasefuncmodulationpar1/32.0 +

  521.                               Pbasefuncmodulationpar2/2048.0)) + p3;

  522.         }

  523. 

  524.         t = t - floor(t);

  525. 

  526.         if(func)

  527.             smps[i] = func(t, par);

  528.         else if (Pcurrentbasefunc == 0)

  529.             smps[i] = -sinf(2.0f * PI * i / synth.oscilsize);

  530.         else

  531.             smps[i] = userfunc(t);

  532.     }

  533. }

  534. 

  535. 

  536. /*

  537.  * Filter the oscillator

  538.  */

  539. void OscilGen::oscilfilter(fft_t *freqs)

  540. {

  541.     if(Pfiltertype == 0)

  542.         return;

  543. 

  544.     const float par    = 1.0f - Pfilterpar1 / 128.0f;

  545.     const float par2   = Pfilterpar2 / 127.0f;

  546.     filter_func filter = getFilter(Pfiltertype);

  547. 

  548.     for(int i = 1; i < synth.oscilsize / 2; ++i)

  549.         freqs[i] *= filter(i, par, par2);

  550. 

  551.     normalize(freqs, synth.oscilsize);

  552. }

  553. 

  554. 

  555. /*

  556.  * Change the base function

  557.  */

  558. void OscilGen::changebasefunction(void)

  559. {

  560.     if(Pcurrentbasefunc != 0) {

  561.         getbasefunction(tmpsmps);

  562.         if(fft)

  563.             fft->smps2freqs(tmpsmps, basefuncFFTfreqs);

  564.         clearDC(basefuncFFTfreqs);

  565.     }

  566.     else //in this case basefuncFFTfreqs are not used

  567.         clearAll(basefuncFFTfreqs, synth.oscilsize);

  568.     oscilprepared = 0;

  569.     oldbasefunc   = Pcurrentbasefunc;

  570.     oldbasepar    = Pbasefuncpar;

  571.     oldbasefuncmodulation     = Pbasefuncmodulation;

  572.     oldbasefuncmodulationpar1 = Pbasefuncmodulationpar1;

  573.     oldbasefuncmodulationpar2 = Pbasefuncmodulationpar2;

  574.     oldbasefuncmodulationpar3 = Pbasefuncmodulationpar3;

  575. }

  576. 

  577. inline void normalize(float *smps, size_t N)

  578. {

  579.     //Find max

  580.     float max = 0.0f;

  581.     for(size_t i = 0; i < N; ++i)

  582.         if(max < fabs(smps[i]))

  583.             max = fabs(smps[i]);

  584.     if(max < 0.00001f)

  585.         max = 1.0f;

  586. 

  587.     //Normalize to +-1

  588.     for(size_t i = 0; i < N; ++i)

  589.         smps[i] /= max;

  590. }

  591. 

  592. /*

  593.  * Waveshape

  594.  */

  595. void OscilGen::waveshape(fft_t *freqs)

  596. {

  597.     oldwaveshapingfunction = Pwaveshapingfunction;

  598.     oldwaveshaping = Pwaveshaping;

  599.     if(Pwaveshapingfunction == 0)

  600.         return;

  601. 

  602.     clearDC(freqs);

  603.     //reduce the amplitude of the freqs near the nyquist

  604.     for(int i = 1; i < synth.oscilsize / 8; ++i) {

  605.         float gain = i / (synth.oscilsize / 8.0f);

  606.         freqs[synth.oscilsize / 2 - i] *= gain;

  607.     }

  608.     fft->freqs2smps(freqs, tmpsmps);

  609. 

  610.     //Normalize

  611.     normalize(tmpsmps, synth.oscilsize);

  612. 

  613.     //Do the waveshaping

  614.     waveShapeSmps(synth.oscilsize, tmpsmps, Pwaveshapingfunction, Pwaveshaping);

  615. 

  616.     fft->smps2freqs(tmpsmps, freqs); //perform FFT

  617. }

  618. 

  619. 

  620. /*

  621.  * Do the Frequency Modulation of the Oscil

  622.  */

  623. void OscilGen::modulation(fft_t *freqs)

  624. {

  625.     oldmodulation     = Pmodulation;

  626.     oldmodulationpar1 = Pmodulationpar1;

  627.     oldmodulationpar2 = Pmodulationpar2;

  628.     oldmodulationpar3 = Pmodulationpar3;

  629.     if(Pmodulation == 0)

  630.         return;

  631. 

  632. 

  633.     float modulationpar1 = Pmodulationpar1 / 127.0f,

  634.           modulationpar2 = 0.5f - Pmodulationpar2 / 127.0f,

  635.           modulationpar3 = Pmodulationpar3 / 127.0f;

  636. 

  637.     switch(Pmodulation) {

  638.         case 1:

  639.             modulationpar1 = (powf(2, modulationpar1 * 7.0f) - 1.0f) / 100.0f;

  640.             modulationpar3 = floor((powf(2, modulationpar3 * 5.0f) - 1.0f));

  641.             if(modulationpar3 < 0.9999f)

  642.                 modulationpar3 = -1.0f;

  643.             break;

  644.         case 2:

  645.             modulationpar1 = (powf(2, modulationpar1 * 7.0f) - 1.0f) / 100.0f;

  646.             modulationpar3 = 1.0f

  647.                              + floor((powf(2, modulationpar3 * 5.0f) - 1.0f));

  648.             break;

  649.         case 3:

  650.             modulationpar1 = (powf(2, modulationpar1 * 9.0f) - 1.0f) / 100.0f;

  651.             modulationpar3 = 0.01f

  652.                              + (powf(2, modulationpar3 * 16.0f) - 1.0f) / 10.0f;

  653.             break;

  654.     }

  655. 

  656.     clearDC(freqs); //remove the DC

  657.     //reduce the amplitude of the freqs near the nyquist

  658.     for(int i = 1; i < synth.oscilsize / 8; ++i) {

  659.         const float tmp = i / (synth.oscilsize / 8.0f);

  660.         freqs[synth.oscilsize / 2 - i] *= tmp;

  661.     }

  662.     fft->freqs2smps(freqs, tmpsmps);

  663.     const int    extra_points = 2;

  664.     float *in = new float[synth.oscilsize + extra_points];

  665. 

  666.     //Normalize

  667.     normalize(tmpsmps, synth.oscilsize);

  668. 

  669.     for(int i = 0; i < synth.oscilsize; ++i)

  670.         in[i] = tmpsmps[i];

  671.     for(int i = 0; i < extra_points; ++i)

  672.         in[i + synth.oscilsize] = tmpsmps[i];

  673. 

  674.     //Do the modulation

  675.     for(int i = 0; i < synth.oscilsize; ++i) {

  676.         float t = i * 1.0f / synth.oscilsize;

  677. 

  678.         switch(Pmodulation) {

  679.             case 1:

  680.                 t = t * modulationpar3

  681.                     + sinf((t + modulationpar2) * 2.0f * PI) * modulationpar1; //rev

  682.                 break;

  683.             case 2:

  684.                 t = t

  685.                     + sinf((t * modulationpar3

  686.                             + modulationpar2) * 2.0f * PI) * modulationpar1; //sine

  687.                 break;

  688.             case 3:

  689.                 t = t + powf((1.0f - cosf(

  690.                                   (t + modulationpar2) * 2.0f * PI)) * 0.5f,

  691.                              modulationpar3) * modulationpar1; //power

  692.                 break;

  693.         }

  694. 

  695.         t = (t - floor(t)) * synth.oscilsize;

  696. 

  697.         const int   poshi = (int) t;

  698.         const float poslo = t - floor(t);

  699. 

  700.         tmpsmps[i] = in[poshi] * (1.0f - poslo) + in[poshi + 1] * poslo;

  701.     }

  702. 

  703.     delete [] in;

  704.     fft->smps2freqs(tmpsmps, freqs); //perform FFT

  705. }

  706. 

  707. 

  708. /*

  709.  * Adjust the spectrum

  710.  */

  711. void OscilGen::spectrumadjust(fft_t *freqs)

  712. {

  713.     if(Psatype == 0)

  714.         return;

  715.     float par = Psapar / 127.0f;

  716.     switch(Psatype) {

  717.         case 1:

  718.             par = 1.0f - par * 2.0f;

  719.             if(par >= 0.0f)

  720.                 par = powf(5.0f, par);

  721.             else

  722.                 par = powf(8.0f, par);

  723.             break;

  724.         case 2:

  725.             par = powf(10.0f, (1.0f - par) * 3.0f) * 0.001f;

  726.             break;

  727.         case 3:

  728.             par = powf(10.0f, (1.0f - par) * 3.0f) * 0.001f;

  729.             break;

  730.     }

  731. 

  732.     normalize(freqs, synth.oscilsize);

  733. 

  734.     for(int i = 0; i < synth.oscilsize / 2; ++i) {

  735.         float mag   = abs(freqs, i);

  736.         float phase = M_PI_2 - arg(freqs, i);

  737. 

  738.         switch(Psatype) {

  739.             case 1:

  740.                 mag = powf(mag, par);

  741.                 break;

  742.             case 2:

  743.                 if(mag < par)

  744.                     mag = 0.0f;

  745.                 break;

  746.             case 3:

  747.                 mag /= par;

  748.                 if(mag > 1.0f)

  749.                     mag = 1.0f;

  750.                 break;

  751.         }

  752.         freqs[i] = FFTpolar<fftw_real>(mag, phase);

  753.     }

  754. }

  755. 

  756. void OscilGen::shiftharmonics(fft_t *freqs)

  757. {

  758.     if(Pharmonicshift == 0)

  759.         return;

  760. 

  761.     int   harmonicshift = -Pharmonicshift;

  762.     fft_t h;

  763. 

  764.     if(harmonicshift > 0)

  765.         for(int i = synth.oscilsize / 2 - 2; i >= 0; i--) {

  766.             int oldh = i - harmonicshift;

  767.             if(oldh < 0)

  768.                 h = 0.0f;

  769.             else

  770.                 h = freqs[oldh + 1];

  771.             freqs[i + 1] = h;

  772.         }

  773.     else

  774.         for(int i = 0; i < synth.oscilsize / 2 - 1; ++i) {

  775.             int oldh = i + abs(harmonicshift);

  776.             if(oldh >= (synth.oscilsize / 2 - 1))

  777.                 h = 0.0f;

  778.             else {

  779.                 h = freqs[oldh + 1];

  780.                 if(abs(h) < 0.000001f)

  781.                     h = 0.0f;

  782.             }

  783. 

  784.             freqs[i + 1] = h;

  785.         }

  786. 

  787.     clearDC(freqs);

  788. }

  789. 

  790. /*

  791.  * Prepare the Oscillator

  792.  */

  793. void OscilGen::prepare(void)

  794. {

  795.     prepare(oscilFFTfreqs);

  796. }

  797. 

  798. void OscilGen::prepare(fft_t *freqs)

  799. {

  800.     if((oldbasepar != Pbasefuncpar) || (oldbasefunc != Pcurrentbasefunc)

  801.        || DIFF(basefuncmodulation) || DIFF(basefuncmodulationpar1)

  802.        || DIFF(basefuncmodulationpar2) || DIFF(basefuncmodulationpar3))

  803.         changebasefunction();

  804. 

  805.     for(int i = 0; i < MAX_AD_HARMONICS; ++i)

  806.         hphase[i] = (Phphase[i] - 64.0f) / 64.0f * PI / (i + 1);

  807. 

  808.     for(int i = 0; i < MAX_AD_HARMONICS; ++i) {

  809.         const float hmagnew = 1.0f - fabs(Phmag[i] / 64.0f - 1.0f);

  810.         switch(Phmagtype) {

  811.             case 1:

  812.                 hmag[i] = expf(hmagnew * logf(0.01f));

  813.                 break;

  814.             case 2:

  815.                 hmag[i] = expf(hmagnew * logf(0.001f));

  816.                 break;

  817.             case 3:

  818.                 hmag[i] = expf(hmagnew * logf(0.0001f));

  819.                 break;

  820.             case 4:

  821.                 hmag[i] = expf(hmagnew * logf(0.00001f));

  822.                 break;

  823.             default:

  824.                 hmag[i] = 1.0f - hmagnew;

  825.                 break;

  826.         }

  827. 

  828.         if(Phmag[i] < 64)

  829.             hmag[i] = -hmag[i];

  830.     }

  831. 

  832.     //remove the harmonics where Phmag[i]==64

  833.     for(int i = 0; i < MAX_AD_HARMONICS; ++i)

  834.         if(Phmag[i] == 64)

  835.             hmag[i] = 0.0f;

  836. 

  837. 

  838.     clearAll(freqs, synth.oscilsize);

  839.     if(Pcurrentbasefunc == 0)   //the sine case

  840.         for(int i = 0; i < MAX_AD_HARMONICS - 1; ++i) {

  841.             freqs[i + 1] =

  842.                 std::complex<float>(-hmag[i] * sinf(hphase[i] * (i + 1)) / 2.0f,

  843.                         hmag[i] * cosf(hphase[i] * (i + 1)) / 2.0f);

  844.         }

  845.     else

  846.         for(int j = 0; j < MAX_AD_HARMONICS; ++j) {

  847.             if(Phmag[j] == 64)

  848.                 continue;

  849.             for(int i = 1; i < synth.oscilsize / 2; ++i) {

  850.                 int k = i * (j + 1);

  851.                 if(k >= synth.oscilsize / 2)

  852.                     break;

  853.                 freqs[k] += basefuncFFTfreqs[i] * FFTpolar<fftw_real>(

  854.                     hmag[j],

  855.                     hphase[j] * k);

  856.             }

  857.         }

  858. 

  859.     if(Pharmonicshiftfirst != 0)

  860.         shiftharmonics(freqs);

  861. 

  862.     if(Pfilterbeforews) {

  863.         oscilfilter(freqs);

  864.         waveshape(freqs);

  865.     } else {

  866.         waveshape(freqs);

  867.         oscilfilter(freqs);

  868.     }

  869. 

  870.     modulation(freqs);

  871.     spectrumadjust(freqs);

  872.     if(Pharmonicshiftfirst == 0)

  873.         shiftharmonics(freqs);

  874. 

  875.     clearDC(freqs);

  876. 

  877.     oldhmagtype      = Phmagtype;

  878.     oldharmonicshift = Pharmonicshift + Pharmonicshiftfirst * 256;

  879. 

  880.     oscilprepared = 1;

  881. }

  882. 

  883. fft_t operator*(float a, fft_t b)

  884. {

  885.     return std::complex<float>(a*b.real(), a*b.imag());

  886. }

  887. 

  888. void OscilGen::adaptiveharmonic(fft_t *f, float freq)

  889. {

  890.     if(Padaptiveharmonics == 0 /*||(freq<1.0f)*/)

  891.         return;

  892.     if(freq < 1.0f)

  893.         freq = 440.0f;

  894. 

  895.     fft_t *inf = new fft_t[synth.oscilsize / 2];

  896.     for(int i = 0; i < synth.oscilsize / 2; ++i)

  897.         inf[i] = f[i];

  898.     clearAll(f, synth.oscilsize);

  899.     clearDC(inf);

  900. 

  901.     float basefreq = 30.0f * powf(10.0f, Padaptiveharmonicsbasefreq / 128.0f);

  902.     float power    = (Padaptiveharmonicspower + 1.0f) / 101.0f;

  903. 

  904.     float rap = freq / basefreq;

  905. 

  906.     rap = powf(rap, power);

  907. 

  908.     bool down = false;

  909.     if(rap > 1.0f) {

  910.         rap  = 1.0f / rap;

  911.         down = true;

  912.     }

  913. 

  914.     for(int i = 0; i < synth.oscilsize / 2 - 2; ++i) {

  915.         const int   high = (int)(i * rap);

  916.         const float low  = fmod(i * rap, 1.0f);

  917. 

  918.         if(high >= (synth.oscilsize / 2 - 2))

  919.             break;

  920. 

  921.         if(down) {

  922.             f[high] += (1.0f - low) * inf[i];

  923.             f[high + 1] += low * inf[i];

  924.         }

  925.         else {

  926.             f[i] = (1.0f - low) * inf[high] + low * inf[high + 1];

  927.         }

  928.     }

  929.     if(!down)//corect the aplitude of the first harmonic

  930.         f[0] *= rap;

  931. 

  932.     f[1] += f[0];

  933.     clearDC(f);

  934.     delete[] inf;

  935. }

  936. 

  937. void OscilGen::adaptiveharmonicpostprocess(fft_t *f, int size)

  938. {

  939.     if(Padaptiveharmonics <= 1)

  940.         return;

  941.     fft_t *inf = new fft_t[size];

  942.     float  par = Padaptiveharmonicspar * 0.01f;

  943.     par = 1.0f - powf((1.0f - par), 1.5f);

  944. 

  945.     for(int i = 0; i < size; ++i) {

  946.         inf[i] = f[i] * double(par);

  947.         f[i]  *= (1.0f - par);

  948.     }

  949. 

  950. 

  951.     if(Padaptiveharmonics == 2) { //2n+1

  952.         for(int i = 0; i < size; ++i)

  953.             if((i % 2) == 0)

  954.                 f[i] += inf[i];  //i=0 first harmonic,etc.

  955.     }

  956.     else {  //other ways

  957.         int nh = (Padaptiveharmonics - 3) / 2 + 2;

  958.         int sub_vs_add = (Padaptiveharmonics - 3) % 2;

  959.         if(sub_vs_add == 0) {

  960.             for(int i = 0; i < size; ++i)

  961.                 if(((i + 1) % nh) == 0)

  962.                     f[i] += inf[i];

  963.         }

  964.         else

  965.             for(int i = 0; i < size / nh - 1; ++i)

  966.                 f[(i + 1) * nh - 1] += inf[i];

  967.     }

  968. 

  969.     delete [] inf;

  970. }

  971. 

  972. void OscilGen::newrandseed(unsigned int randseed)

  973. {

  974.     this->randseed = randseed;

  975. }

  976. 

  977. bool OscilGen::needPrepare(void)

  978. {

  979.     bool outdated = false;

  980. 

  981.     //Check function parameters

  982.     if((oldbasepar != Pbasefuncpar) || (oldbasefunc != Pcurrentbasefunc)

  983.        || DIFF(hmagtype) || DIFF(waveshaping) || DIFF(waveshapingfunction))

  984.         outdated = true;

  985. 

  986.     //Check filter parameters

  987.     if(oldfilterpars != Pfiltertype * 256 + Pfilterpar1 + Pfilterpar2 * 65536

  988.        + Pfilterbeforews * 16777216) {

  989.         outdated      = true;

  990.         oldfilterpars = Pfiltertype * 256 + Pfilterpar1 + Pfilterpar2 * 65536

  991.                         + Pfilterbeforews * 16777216;

  992.     }

  993. 

  994.     //Check spectrum adjustments

  995.     if(oldsapars != Psatype * 256 + Psapar) {

  996.         outdated  = true;

  997.         oldsapars = Psatype * 256 + Psapar;

  998.     }

  999. 

  1000.     //Check function modulation

  1001.     if(DIFF(basefuncmodulation) || DIFF(basefuncmodulationpar1)

  1002.        || DIFF(basefuncmodulationpar2) || DIFF(basefuncmodulationpar3))

  1003.         outdated = true;

  1004. 

  1005.     //Check overall modulation

  1006.     if(DIFF(modulation) || DIFF(modulationpar1)

  1007.        || DIFF(modulationpar2) || DIFF(modulationpar3))

  1008.         outdated = true;

  1009. 

  1010.     //Check harmonic shifts

  1011.     if(oldharmonicshift != Pharmonicshift + Pharmonicshiftfirst * 256)

  1012.         outdated = true;

  1013. 

  1014.     return outdated == true || oscilprepared == false;

  1015. }

  1016. 

  1017. /*

  1018.  * Get the oscillator function

  1019.  */

  1020. short int OscilGen::get(float *smps, float freqHz, int resonance)

  1021. {

  1022.     if(needPrepare())

  1023.         prepare();

  1024. 

  1025.     fft_t *input = freqHz > 0.0f ? oscilFFTfreqs : pendingfreqs;

  1026. 

  1027.     int outpos =

  1028.         (int)((RND * 2.0f

  1029.                - 1.0f) * synth.oscilsize_f * (Prand - 64.0f) / 64.0f);

  1030.     outpos = (outpos + 2 * synth.oscilsize) % synth.oscilsize;

  1031. 

  1032. 

  1033.     clearAll(outoscilFFTfreqs, synth.oscilsize);

  1034. 

  1035.     int nyquist = (int)(0.5f * synth.samplerate_f / fabs(freqHz)) + 2;

  1036.     if(ADvsPAD)

  1037.         nyquist = (int)(synth.oscilsize / 2);

  1038.     if(nyquist > synth.oscilsize / 2)

  1039.         nyquist = synth.oscilsize / 2;

  1040. 

  1041.     //Process harmonics

  1042.     {

  1043.         int realnyquist = nyquist;

  1044. 

  1045.         if(Padaptiveharmonics != 0)

  1046.             nyquist = synth.oscilsize / 2;

  1047.         for(int i = 1; i < nyquist - 1; ++i)

  1048.             outoscilFFTfreqs[i] = input[i];

  1049. 

  1050.         adaptiveharmonic(outoscilFFTfreqs, freqHz);

  1051.         adaptiveharmonicpostprocess(&outoscilFFTfreqs[1],

  1052.                                     synth.oscilsize / 2 - 1);

  1053. 

  1054.         nyquist = realnyquist;

  1055.     }

  1056. 

  1057.     if(Padaptiveharmonics)   //do the antialiasing in the case of adaptive harmonics

  1058.         for(int i = nyquist; i < synth.oscilsize / 2; ++i)

  1059.             outoscilFFTfreqs[i] = fft_t(0.0f, 0.0f);

  1060. 

  1061.     // Randomness (each harmonic), the block type is computed

  1062.     // in ADnote by setting start position according to this setting

  1063.     if((Prand > 64) && (freqHz >= 0.0f) && (!ADvsPAD)) {

  1064.         const float rnd = PI * powf((Prand - 64.0f) / 64.0f, 2.0f);

  1065.         for(int i = 1; i < nyquist - 1; ++i) //to Nyquist only for AntiAliasing

  1066.             outoscilFFTfreqs[i] *=

  1067.                 FFTpolar<fftw_real>(1.0f, (float)(rnd * i * RND));

  1068.     }

  1069. 

  1070.     //Harmonic Amplitude Randomness

  1071.     if((freqHz > 0.1f) && (!ADvsPAD)) {

  1072.         unsigned int realrnd = prng();

  1073.         sprng(randseed);

  1074.         float power     = Pamprandpower / 127.0f;

  1075.         float normalize = 1.0f / (1.2f - power);

  1076.         switch(Pamprandtype) {

  1077.             case 1:

  1078.                 power = power * 2.0f - 0.5f;

  1079.                 power = powf(15.0f, power);

  1080.                 for(int i = 1; i < nyquist - 1; ++i)

  1081.                     outoscilFFTfreqs[i] *= powf(RND, power) * normalize;

  1082.                 break;

  1083.             case 2:

  1084.                 power = power * 2.0f - 0.5f;

  1085.                 power = powf(15.0f, power) * 2.0f;

  1086.                 float rndfreq = 2 * PI * RND;

  1087.                 for(int i = 1; i < nyquist - 1; ++i)

  1088.                     outoscilFFTfreqs[i] *= powf(fabs(sinf(i * rndfreq)), power)

  1089.                                            * normalize;

  1090.                 break;

  1091.         }

  1092.         sprng(realrnd + 1);

  1093.     }

  1094. 

  1095.     if((freqHz > 0.1f) && (resonance != 0))

  1096.         res->applyres(nyquist - 1, outoscilFFTfreqs, freqHz);

  1097. 

  1098.     rmsNormalize(outoscilFFTfreqs, synth.oscilsize);

  1099. 

  1100.     if((ADvsPAD) && (freqHz > 0.1f)) //in this case the smps will contain the freqs

  1101.         for(int i = 1; i < synth.oscilsize / 2; ++i)

  1102.             smps[i - 1] = abs(outoscilFFTfreqs, i);

  1103.     else {

  1104.         fft->freqs2smps(outoscilFFTfreqs, smps);

  1105.         for(int i = 0; i < synth.oscilsize; ++i)

  1106.             smps[i] *= 0.25f;                     //correct the amplitude

  1107.     }

  1108. 

  1109.     if(Prand < 64)

  1110.         return outpos;

  1111.     else

  1112.         return 0;

  1113. }

  1114. 

  1115. ///*

  1116. // * Get the oscillator function's harmonics

  1117. // */

  1118. //void OscilGen::getPad(float *smps, float freqHz)

  1119. //{

  1120. //    if(needPrepare())

  1121. //        prepare();

  1122. //

  1123. //    clearAll(outoscilFFTfreqs);

  1124. //

  1125. //    const int nyquist = (synth.oscilsize / 2);

  1126. //

  1127. //    //Process harmonics

  1128. //    for(int i = 1; i < nyquist - 1; ++i)

  1129. //        outoscilFFTfreqs[i] = oscilFFTfreqs[i];

  1130. //

  1131. //    adaptiveharmonic(outoscilFFTfreqs, freqHz);

  1132. //    adaptiveharmonicpostprocess(&outoscilFFTfreqs[1], nyquist - 1);

  1133. //

  1134. //    rmsNormalize(outoscilFFTfreqs);

  1135. //

  1136. //    for(int i = 1; i < nyquist; ++i)

  1137. //        smps[i - 1] = abs(outoscilFFTfreqs, i);

  1138. //}

  1139. //

  1140. 

  1141. /*

  1142.  * Get the spectrum of the oscillator for the UI

  1143.  */

  1144. void OscilGen::getspectrum(int n, float *spc, int what)

  1145. {

  1146.     if(n > synth.oscilsize / 2)

  1147.         n = synth.oscilsize / 2;

  1148. 

  1149.     for(int i = 1; i < n; ++i) {

  1150.         if(what == 0)

  1151.             spc[i] = abs(pendingfreqs, i);

  1152.         else {

  1153.             if(Pcurrentbasefunc == 0)

  1154.                 spc[i] = ((i == 1) ? (1.0f) : (0.0f));

  1155.             else

  1156.                 spc[i] = abs(basefuncFFTfreqs, i);

  1157.         }

  1158.     }

  1159.     spc[0]=0;

  1160. 

  1161.     if(what == 0) {

  1162.         for(int i = 0; i < n; ++i)

  1163.             outoscilFFTfreqs[i] = fft_t(spc[i], spc[i]);

  1164.         memset(outoscilFFTfreqs + n, 0,

  1165.                (synth.oscilsize / 2 - n) * sizeof(fft_t));

  1166.         adaptiveharmonic(outoscilFFTfreqs, 0.0f);

  1167.         adaptiveharmonicpostprocess(outoscilFFTfreqs, n - 1);

  1168.         for(int i = 0; i < n; ++i)

  1169.             spc[i] = outoscilFFTfreqs[i].imag();

  1170.     }

  1171. }

  1172. 

  1173. 

  1174. /*

  1175.  * Convert the oscillator as base function

  1176.  */

  1177. void OscilGen::useasbase()

  1178. {

  1179.     for(int i = 0; i < synth.oscilsize / 2; ++i)

  1180.         basefuncFFTfreqs[i] = oscilFFTfreqs[i];

  1181. 

  1182.     oldbasefunc = Pcurrentbasefunc = 127;

  1183.     prepare();

  1184.     cachedbasevalid = false;

  1185. }

  1186. 

  1187. 

  1188. /*

  1189.  * Get the base function for UI

  1190.  */

  1191. void OscilGen::getcurrentbasefunction(float *smps)

  1192. {

  1193.     if(Pcurrentbasefunc != 0)

  1194.         fft->freqs2smps(basefuncFFTfreqs, smps);

  1195.     else

  1196.         getbasefunction(smps);   //the sine case

  1197. }

  1198. 

  1199. #define COPY(y) this->y = o.y

  1200. void OscilGen::paste(OscilGen &o)

  1201. {

  1202.     //XXX Figure out a better implementation of this sensitive to RT issues...

  1203.     for(int i=0; i<MAX_AD_HARMONICS; ++i) {

  1204.         COPY(Phmag[i]);

  1205.         COPY(Phphase[i]);

  1206.     }

  1207. 

  1208.     COPY(Phmagtype);

  1209.     COPY(Pcurrentbasefunc);

  1210.     COPY(Pbasefuncpar);

  1211. 

  1212.     COPY(Pbasefuncmodulation);

  1213.     COPY(Pbasefuncmodulationpar1);

  1214.     COPY(Pbasefuncmodulationpar2);

  1215.     COPY(Pbasefuncmodulationpar3);

  1216. 

  1217.     COPY(Pwaveshaping);

  1218.     COPY(Pwaveshapingfunction);

  1219.     COPY(Pfiltertype);

  1220.     COPY(Pfilterpar1);

  1221.     COPY(Pfilterpar2);

  1222.     COPY(Pfilterbeforews);

  1223.     COPY(Psatype);

  1224.     COPY(Psapar);

  1225. 

  1226.     COPY(Pharmonicshift);

  1227.     COPY(Pharmonicshiftfirst);

  1228. 

  1229.     COPY(Pmodulation);

  1230.     COPY(Pmodulationpar1);

  1231.     COPY(Pmodulationpar2);

  1232.     COPY(Pmodulationpar3);

  1233. 

  1234.     COPY(Prand);

  1235.     COPY(Pamprandpower);

  1236.     COPY(Pamprandtype);

  1237.     COPY(Padaptiveharmonics);

  1238.     COPY(Padaptiveharmonicsbasefreq);

  1239.     COPY(Padaptiveharmonicspower);

  1240.     COPY(Padaptiveharmonicspar);

  1241. 

  1242. 

  1243.     if(this->Pcurrentbasefunc)

  1244.         changebasefunction();

  1245.     this->prepare();

  1246. }

  1247. #undef COPY

  1248. 

  1249. void OscilGen::add2XML(XMLwrapper& xml)

  1250. {

  1251.     xml.addpar("harmonic_mag_type", Phmagtype);

  1252. 

  1253.     xml.addpar("base_function", Pcurrentbasefunc);

  1254.     xml.addpar("base_function_par", Pbasefuncpar);

  1255.     xml.addpar("base_function_modulation", Pbasefuncmodulation);

  1256.     xml.addpar("base_function_modulation_par1", Pbasefuncmodulationpar1);

  1257.     xml.addpar("base_function_modulation_par2", Pbasefuncmodulationpar2);

  1258.     xml.addpar("base_function_modulation_par3", Pbasefuncmodulationpar3);

  1259. 

  1260.     xml.addpar("modulation", Pmodulation);

  1261.     xml.addpar("modulation_par1", Pmodulationpar1);

  1262.     xml.addpar("modulation_par2", Pmodulationpar2);

  1263.     xml.addpar("modulation_par3", Pmodulationpar3);

  1264. 

  1265.     xml.addpar("wave_shaping", Pwaveshaping);

  1266.     xml.addpar("wave_shaping_function", Pwaveshapingfunction);

  1267. 

  1268.     xml.addpar("filter_type", Pfiltertype);

  1269.     xml.addpar("filter_par1", Pfilterpar1);

  1270.     xml.addpar("filter_par2", Pfilterpar2);

  1271.     xml.addpar("filter_before_wave_shaping", Pfilterbeforews);

  1272. 

  1273.     xml.addpar("spectrum_adjust_type", Psatype);

  1274.     xml.addpar("spectrum_adjust_par", Psapar);

  1275. 

  1276.     xml.addpar("rand", Prand);

  1277.     xml.addpar("amp_rand_type", Pamprandtype);

  1278.     xml.addpar("amp_rand_power", Pamprandpower);

  1279. 

  1280.     xml.addpar("harmonic_shift", Pharmonicshift);

  1281.     xml.addparbool("harmonic_shift_first", Pharmonicshiftfirst);

  1282. 

  1283.     xml.addpar("adaptive_harmonics", Padaptiveharmonics);

  1284.     xml.addpar("adaptive_harmonics_base_frequency", Padaptiveharmonicsbasefreq);

  1285.     xml.addpar("adaptive_harmonics_power", Padaptiveharmonicspower);

  1286.     xml.addpar("adaptive_harmonics_par", Padaptiveharmonicspar);

  1287. 

  1288.     xml.beginbranch("HARMONICS");

  1289.     for(int n = 0; n < MAX_AD_HARMONICS; ++n) {

  1290.         if((Phmag[n] == 64) && (Phphase[n] == 64))

  1291.             continue;

  1292.         xml.beginbranch("HARMONIC", n + 1);

  1293.         xml.addpar("mag", Phmag[n]);

  1294.         xml.addpar("phase", Phphase[n]);

  1295.         xml.endbranch();

  1296.     }

  1297.     xml.endbranch();

  1298. 

  1299.     if(Pcurrentbasefunc == 127) {

  1300.         normalize(basefuncFFTfreqs, synth.oscilsize);

  1301. 

  1302.         xml.beginbranch("BASE_FUNCTION");

  1303.         for(int i = 1; i < synth.oscilsize / 2; ++i) {

  1304.             float xc = basefuncFFTfreqs[i].real();

  1305.             float xs = basefuncFFTfreqs[i].imag();

  1306.             if((fabs(xs) > 1e-6f) || (fabs(xc) > 1e-6f)) {

  1307.                 xml.beginbranch("BF_HARMONIC", i);

  1308.                 xml.addparreal("cos", xc);

  1309.                 xml.addparreal("sin", xs);

  1310.                 xml.endbranch();

  1311.             }

  1312.         }

  1313.         xml.endbranch();

  1314.     }

  1315. }

  1316. 

  1317. void OscilGen::getfromXML(XMLwrapper& xml)

  1318. {

  1319.     Phmagtype = xml.getpar127("harmonic_mag_type", Phmagtype);

  1320. 

  1321.     Pcurrentbasefunc = xml.getpar127("base_function", Pcurrentbasefunc);

  1322.     Pbasefuncpar     = xml.getpar127("base_function_par", Pbasefuncpar);

  1323. 

  1324.     Pbasefuncmodulation = xml.getpar127("base_function_modulation",

  1325.                                          Pbasefuncmodulation);

  1326.     Pbasefuncmodulationpar1 = xml.getpar127("base_function_modulation_par1",

  1327.                                              Pbasefuncmodulationpar1);

  1328.     Pbasefuncmodulationpar2 = xml.getpar127("base_function_modulation_par2",

  1329.                                              Pbasefuncmodulationpar2);

  1330.     Pbasefuncmodulationpar3 = xml.getpar127("base_function_modulation_par3",

  1331.                                              Pbasefuncmodulationpar3);

  1332. 

  1333.     Pmodulation     = xml.getpar127("modulation", Pmodulation);

  1334.     Pmodulationpar1 = xml.getpar127("modulation_par1",

  1335.                                      Pmodulationpar1);

  1336.     Pmodulationpar2 = xml.getpar127("modulation_par2",

  1337.                                      Pmodulationpar2);

  1338.     Pmodulationpar3 = xml.getpar127("modulation_par3",

  1339.                                      Pmodulationpar3);

  1340. 

  1341.     Pwaveshaping = xml.getpar127("wave_shaping", Pwaveshaping);

  1342.     Pwaveshapingfunction = xml.getpar127("wave_shaping_function",

  1343.                                           Pwaveshapingfunction);

  1344. 

  1345.     Pfiltertype     = xml.getpar127("filter_type", Pfiltertype);

  1346.     Pfilterpar1     = xml.getpar127("filter_par1", Pfilterpar1);

  1347.     Pfilterpar2     = xml.getpar127("filter_par2", Pfilterpar2);

  1348.     Pfilterbeforews = xml.getpar127("filter_before_wave_shaping",

  1349.                                      Pfilterbeforews);

  1350. 

  1351.     Psatype = xml.getpar127("spectrum_adjust_type", Psatype);

  1352.     Psapar  = xml.getpar127("spectrum_adjust_par", Psapar);

  1353. 

  1354.     Prand = xml.getpar127("rand", Prand);

  1355.     Pamprandtype  = xml.getpar127("amp_rand_type", Pamprandtype);

  1356.     Pamprandpower = xml.getpar127("amp_rand_power", Pamprandpower);

  1357. 

  1358.     Pharmonicshift = xml.getpar("harmonic_shift",

  1359.                                  Pharmonicshift,

  1360.                                  -64,

  1361.                                  64);

  1362.     Pharmonicshiftfirst = xml.getparbool("harmonic_shift_first",

  1363.                                           Pharmonicshiftfirst);

  1364. 

  1365.     Padaptiveharmonics = xml.getpar("adaptive_harmonics",

  1366.                                      Padaptiveharmonics,

  1367.                                      0,

  1368.                                      127);

  1369.     Padaptiveharmonicsbasefreq = xml.getpar(

  1370.         "adaptive_harmonics_base_frequency",

  1371.         Padaptiveharmonicsbasefreq,

  1372.         0,

  1373.         255);

  1374.     Padaptiveharmonicspower = xml.getpar("adaptive_harmonics_power",

  1375.                                           Padaptiveharmonicspower,

  1376.                                           0,

  1377.                                           200);

  1378.     Padaptiveharmonicspar = xml.getpar("adaptive_harmonics_par",

  1379.                                        Padaptiveharmonicspar,

  1380.                                        0,

  1381.                                        100);

  1382. 

  1383. 

  1384.     if(xml.enterbranch("HARMONICS")) {

  1385.         Phmag[0]   = 64;

  1386.         Phphase[0] = 64;

  1387.         for(int n = 0; n < MAX_AD_HARMONICS; ++n) {

  1388.             if(xml.enterbranch("HARMONIC", n + 1) == 0)

  1389.                 continue;

  1390.             Phmag[n]   = xml.getpar127("mag", 64);

  1391.             Phphase[n] = xml.getpar127("phase", 64);

  1392.             xml.exitbranch();

  1393.         }

  1394.         xml.exitbranch();

  1395.     }

  1396. 

  1397.     if(Pcurrentbasefunc != 0)

  1398.         changebasefunction();

  1399. 

  1400.     if(xml.enterbranch("BASE_FUNCTION")) {

  1401.         for(int i = 1; i < synth.oscilsize / 2; ++i)

  1402.             if(xml.enterbranch("BF_HARMONIC", i)) {

  1403.                 basefuncFFTfreqs[i] =

  1404.                     std::complex<float>(xml.getparreal("cos", 0.0f),

  1405.                             xml.getparreal("sin", 0.0f));

  1406.                 xml.exitbranch();

  1407.             }

  1408.         xml.exitbranch();

  1409. 

  1410.         clearDC(basefuncFFTfreqs);

  1411.         normalize(basefuncFFTfreqs, synth.oscilsize);

  1412.         cachedbasevalid = false;

  1413.     }}

  1414. 

  1415. 

  1416. //Define basic functions

  1417. #define FUNC(b) float basefunc_ ## b(float x, float a)

  1418. 

  1419. FUNC(pulse)

  1420. {

  1421.     return (fmod(x, 1.0f) < a) ? -1.0f : 1.0f;

  1422. }

  1423. 

  1424. FUNC(saw)

  1425. {

  1426.     if(a < 0.00001f)

  1427.         a = 0.00001f;

  1428.     else

  1429.     if(a > 0.99999f)

  1430.         a = 0.99999f;

  1431.     x = fmod(x, 1);

  1432.     if(x < a)

  1433.         return x / a * 2.0f - 1.0f;

  1434.     else

  1435.         return (1.0f - x) / (1.0f - a) * 2.0f - 1.0f;

  1436. }

  1437. 

  1438. FUNC(triangle)

  1439. {

  1440.     x = fmod(x + 0.25f, 1);

  1441.     a = 1 - a;

  1442.     if(a < 0.00001f)

  1443.         a = 0.00001f;

  1444.     if(x < 0.5f)

  1445.         x = x * 4 - 1.0f;

  1446.     else

  1447.         x = (1.0f - x) * 4 - 1.0f;

  1448.     x /= -a;

  1449.     if(x < -1.0f)

  1450.         x = -1.0f;

  1451.     if(x > 1.0f)

  1452.         x = 1.0f;

  1453.     return x;

  1454. }

  1455. 

  1456. FUNC(power)

  1457. {

  1458.     x = fmod(x, 1);

  1459.     if(a < 0.00001f)

  1460.         a = 0.00001f;

  1461.     else

  1462.     if(a > 0.99999f)

  1463.         a = 0.99999f;

  1464.     return powf(x, expf((a - 0.5f) * 10.0f)) * 2.0f - 1.0f;

  1465. }

  1466. 

  1467. FUNC(gauss)

  1468. {

  1469.     x = fmod(x, 1) * 2.0f - 1.0f;

  1470.     if(a < 0.00001f)

  1471.         a = 0.00001f;

  1472.     return expf(-x * x * (expf(a * 8) + 5.0f)) * 2.0f - 1.0f;

  1473. }

  1474. 

  1475. FUNC(diode)

  1476. {

  1477.     if(a < 0.00001f)

  1478.         a = 0.00001f;

  1479.     else

  1480.     if(a > 0.99999f)

  1481.         a = 0.99999f;

  1482.     a = a * 2.0f - 1.0f;

  1483.     x = cosf((x + 0.5f) * 2.0f * PI) - a;

  1484.     if(x < 0.0f)

  1485.         x = 0.0f;

  1486.     return x / (1.0f - a) * 2 - 1.0f;

  1487. }

  1488. 

  1489. FUNC(abssine)

  1490. {

  1491.     x = fmod(x, 1);

  1492.     if(a < 0.00001f)

  1493.         a = 0.00001f;

  1494.     else

  1495.     if(a > 0.99999f)

  1496.         a = 0.99999f;

  1497.     return sinf(powf(x, expf((a - 0.5f) * 5.0f)) * PI) * 2.0f - 1.0f;

  1498. }

  1499. 

  1500. FUNC(pulsesine)

  1501. {

  1502.     if(a < 0.00001f)

  1503.         a = 0.00001f;

  1504.     x = (fmod(x, 1) - 0.5f) * expf((a - 0.5f) * logf(128));

  1505.     if(x < -0.5f)

  1506.         x = -0.5f;

  1507.     else

  1508.     if(x > 0.5f)

  1509.         x = 0.5f;

  1510.     x = sinf(x * PI * 2.0f);

  1511.     return x;

  1512. }

  1513. 

  1514. FUNC(stretchsine)

  1515. {

  1516.     x = fmod(x + 0.5f, 1) * 2.0f - 1.0f;

  1517.     a = (a - 0.5f) * 4;

  1518.     if(a > 0.0f)

  1519.         a *= 2;

  1520.     a = powf(3.0f, a);

  1521.     float b = powf(fabs(x), a);

  1522.     if(x < 0)

  1523.         b = -b;

  1524.     return -sinf(b * PI);

  1525. }

  1526. 

  1527. FUNC(chirp)

  1528. {

  1529.     x = fmod(x, 1.0f) * 2.0f * PI;

  1530.     a = (a - 0.5f) * 4;

  1531.     if(a < 0.0f)

  1532.         a *= 2.0f;

  1533.     a = powf(3.0f, a);

  1534.     return sinf(x / 2.0f) * sinf(a * x * x);

  1535. }

  1536. 

  1537. FUNC(absstretchsine)

  1538. {

  1539.     x = fmod(x + 0.5f, 1) * 2.0f - 1.0f;

  1540.     a = (a - 0.5f) * 9;

  1541.     a = powf(3.0f, a);

  1542.     float b = powf(fabs(x), a);

  1543.     if(x < 0)

  1544.         b = -b;

  1545.     return -powf(sinf(b * PI), 2);

  1546. }

  1547. 

  1548. FUNC(chebyshev)

  1549. {

  1550.     a = a * a * a * 30.0f + 1.0f;

  1551.     return cosf(acosf(x * 2.0f - 1.0f) * a);

  1552. }

  1553. 

  1554. FUNC(sqr)

  1555. {

  1556.     a = a * a * a * a * 160.0f + 0.001f;

  1557.     return -atanf(sinf(x * 2.0f * PI) * a);

  1558. }

  1559. 

  1560. FUNC(spike)

  1561. {

  1562.     float b = a * 0.66666; // the width of the range: if a == 0.5, b == 0.33333

  1563. 

  1564.     if(x < 0.5) {

  1565.         if(x < (0.5 - (b / 2.0)))

  1566.             return 0.0;

  1567.         else {

  1568.             x = (x + (b / 2) - 0.5) * (2.0 / b); // shift to zero, and expand to range from 0 to 1

  1569.             return x * (2.0 / b); // this is the slope: 1 / (b / 2)

  1570.         }

  1571.     }

  1572.     else {

  1573.         if(x > (0.5 + (b / 2.0)))

  1574.             return 0.0;

  1575.         else {

  1576.             x = (x - 0.5) * (2.0 / b);

  1577.             return (1 - x) * (2.0 / b);

  1578.         }

  1579.     }

  1580. }

  1581. 

  1582. FUNC(circle)

  1583. {

  1584.     // a is parameter: 0 -> 0.5 -> 1 // O.5 = circle

  1585.     float b, y;

  1586. 

  1587.     b = 2 - (a * 2); // b goes from 2 to 0

  1588.     x = x * 4;

  1589. 

  1590.     if(x < 2) {

  1591.         x = x - 1; // x goes from -1 to 1

  1592.         if((x < -b) || (x > b))

  1593.             y = 0;

  1594.         else

  1595.             y = sqrt(1 - (pow(x, 2) / pow(b, 2)));  // normally * a^2, but a stays 1

  1596.     }

  1597.     else {

  1598.         x = x - 3; // x goes from -1 to 1 as well

  1599.         if((x < -b) || (x > b))

  1600.             y = 0;

  1601.         else

  1602.             y = -sqrt(1 - (pow(x, 2) / pow(b, 2)));

  1603.     }

  1604.     return y;

  1605. }

  1606. 

  1607. typedef float (*base_func)(float, float);

  1608. 

  1609. base_func getBaseFunction(unsigned char func)

  1610. {

  1611.     if(!func)

  1612.         return NULL;

  1613. 

  1614.     if(func == 127) //should be the custom wave

  1615.         return NULL;

  1616. 

  1617.     func--;

  1618.     assert(func < 15);

  1619.     base_func functions[] = {

  1620.         basefunc_triangle,

  1621.         basefunc_pulse,

  1622.         basefunc_saw,

  1623.         basefunc_power,

  1624.         basefunc_gauss,

  1625.         basefunc_diode,

  1626.         basefunc_abssine,

  1627.         basefunc_pulsesine,

  1628.         basefunc_stretchsine,

  1629.         basefunc_chirp,

  1630.         basefunc_absstretchsine,

  1631.         basefunc_chebyshev,

  1632.         basefunc_sqr,

  1633.         basefunc_spike,

  1634.         basefunc_circle,

  1635.     };

  1636.     return functions[func];

  1637. }

  1638. 

  1639. //And filters

  1640. 

  1641. #define FILTER(x) float osc_ ## x(unsigned int i, float par, float par2)

  1642. FILTER(lp)

  1643. {

  1644.     float gain = powf(1.0f - par * par * par * 0.99f, i);

  1645.     float tmp  = par2 * par2 * par2 * par2 * 0.5f + 0.0001f;

  1646.     if(gain < tmp)

  1647.         gain = powf(gain, 10.0f) / powf(tmp, 9.0f);

  1648.     return gain;

  1649. }

  1650. 

  1651. FILTER(hp1)

  1652. {

  1653.     float gain = 1.0f - powf(1.0f - par * par, i + 1);

  1654.     return powf(gain, par2 * 2.0f + 0.1f);

  1655. }

  1656. 

  1657. FILTER(hp1b)

  1658. {

  1659.     if(par < 0.2f)

  1660.         par = par * 0.25f + 0.15f;

  1661.     float gain = 1.0f - powf(1.0f - par * par * 0.999f + 0.001f,

  1662.                              i * 0.05f * i + 1.0f);

  1663.     float tmp = powf(5.0f, par2 * 2.0f);

  1664.     return powf(gain, tmp);

  1665. }

  1666. 

  1667. FILTER(bp1)

  1668. {

  1669.     float gain = i + 1 - powf(2, (1.0f - par) * 7.5f);

  1670.     gain = 1.0f / (1.0f + gain * gain / (i + 1.0f));

  1671.     float tmp = powf(5.0f, par2 * 2.0f);

  1672.     gain = powf(gain, tmp);

  1673.     if(gain < 1e-5)

  1674.         gain = 1e-5;

  1675.     return gain;

  1676. }

  1677. 

  1678. FILTER(bs1)

  1679. {

  1680.     float gain = i + 1 - powf(2, (1.0f - par) * 7.5f);

  1681.     gain = powf(atanf(gain / (i / 10.0f + 1)) / 1.57f, 6);

  1682.     return powf(gain, par2 * par2 * 3.9f + 0.1f);

  1683. }

  1684. 

  1685. FILTER(lp2)

  1686. {

  1687.     return (i + 1 >

  1688.             powf(2, (1.0f - par) * 10) ? 0.0f : 1.0f) * par2 + (1.0f - par2);

  1689. }

  1690. 

  1691. FILTER(hp2)

  1692. {

  1693.     if(par == 1)

  1694.         return 1.0f;

  1695.     return (i + 1 >

  1696.             powf(2, (1.0f - par) * 7) ? 1.0f : 0.0f) * par2 + (1.0f - par2);

  1697. }

  1698. 

  1699. FILTER(bp2)

  1700. {

  1701.     return (fabs(powf(2,

  1702.                       (1.0f

  1703.                        - par)

  1704.                       * 7)

  1705.                  - i) > i / 2 + 1 ? 0.0f : 1.0f) * par2 + (1.0f - par2);

  1706. }

  1707. 

  1708. FILTER(bs2)

  1709. {

  1710.     return (fabs(powf(2,

  1711.                       (1.0f

  1712.                        - par)

  1713.                       * 7)

  1714.                  - i) < i / 2 + 1 ? 0.0f : 1.0f) * par2 + (1.0f - par2);

  1715. }

  1716. 

  1717. bool floatEq(float a, float b)

  1718. {

  1719.     const float fudge = .01;

  1720.     return a + fudge > b && a - fudge < b;

  1721. }

  1722. 

  1723. FILTER(cos)

  1724. {

  1725.     float tmp = powf(5.0f, par2 * 2.0f - 1.0f);

  1726.     tmp = powf(i / 32.0f, tmp) * 32.0f;

  1727.     if(floatEq(par2 * 127.0f, 64.0f))

  1728.         tmp = i;

  1729.     float gain = cosf(par * par * PI / 2.0f * tmp);

  1730.     gain *= gain;

  1731.     return gain;

  1732. }

  1733. 

  1734. FILTER(sin)

  1735. {

  1736.     float tmp = powf(5.0f, par2 * 2.0f - 1.0f);

  1737.     tmp = powf(i / 32.0f, tmp) * 32.0f;

  1738.     if(floatEq(par2 * 127.0f, 64.0f))

  1739.         tmp = i;

  1740.     float gain = sinf(par * par * PI / 2.0f * tmp);

  1741.     gain *= gain;

  1742.     return gain;

  1743. }

  1744. 

  1745. FILTER(low_shelf)

  1746. {

  1747.     float p2 = 1.0f - par + 0.2f;

  1748.     float x  = i / (64.0f * p2 * p2);

  1749.     if(x < 0.0f)

  1750.         x = 0.0f;

  1751.     else

  1752.     if(x > 1.0f)

  1753.         x = 1.0f;

  1754.     float tmp = powf(1.0f - par2, 2.0f);

  1755.     return cosf(x * PI) * (1.0f - tmp) + 1.01f + tmp;

  1756. }

  1757. 

  1758. FILTER(s)

  1759. {

  1760.     unsigned int tmp = (int) (powf(2.0f, (1.0f - par) * 7.2f));

  1761.     float gain = 1.0f;

  1762.     if(i == tmp)

  1763.         gain = powf(2.0f, par2 * par2 * 8.0f);

  1764.     return gain;

  1765. }

  1766. #undef FILTER

  1767. 

  1768. typedef float (*filter_func)(unsigned int, float, float);

  1769. filter_func getFilter(unsigned char func)

  1770. {

  1771.     if(!func)

  1772.         return NULL;

  1773. 

  1774.     func--;

  1775.     assert(func < 13);

  1776.     filter_func functions[] = {

  1777.         osc_lp,

  1778.         osc_hp1,

  1779.         osc_hp1b,

  1780.         osc_bp1,

  1781.         osc_bs1,

  1782.         osc_lp2,

  1783.         osc_hp2,

  1784.         osc_bp2,

  1785.         osc_bs2,

  1786.         osc_cos,

  1787.         osc_sin,

  1788.         osc_low_shelf,

  1789.         osc_s

  1790.     };

  1791.     return functions[func];

  1792. }