falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 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.
3959 Commits
16 Branches
16GB
Tree: 510209d0ee
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '510209d0ee'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/Synth/OscilGen.cpp

1809 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. namespace zyncarla {

  31. 

  32. #define rObject OscilGen

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

  34.     rSelf(OscilGen),

  35.     rPaste,

  36.     //TODO ensure min/max

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

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

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

  40.                      dB scale (-100)),

  41.             rDefault(linear),

  42.             "Type of magnitude for harmonics"),

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

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

  45.                 diode, abssine, pulsesine, stretchsine,

  46.                 chirp, absstretchsine, chebyshev, sqr,

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

  48.             rDefault(sine),

  49.             "Base Waveform for harmonics"),

  50.     rParamZyn(Pbasefuncpar, rShort("shape"), rDefault(64),

  51.             "Morph between possible base function shapes "

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

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

  54.             rOptions(None, Rev, Sine, Power, Chop), rDefault(None),

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

  56.     rParamZyn(Pbasefuncmodulationpar1, rShort("p1"), rDefault(64),

  57.             "Base function modulation parameter"),

  58.     rParamZyn(Pbasefuncmodulationpar2, rShort("p2"), rDefault(64),

  59.             "Base function modulation parameter"),

  60.     rParamZyn(Pbasefuncmodulationpar3, rShort("p3"), rDefault(32),

  61.             "Base function modulation parameter"),

  62.     rParamZyn(Pwaveshaping, rShort("amount"), rDefault(64),

  63.             "Degree Of Waveshaping"),

  64.     rOption(Pwaveshapingfunction, rShort("distort"), rDefault(Undistorted),

  65.             rOptions(Undistorted,

  66.                 Arctangent, Asymmetric, Pow, Sine, Quantisize,

  67.                 Zigzag, Limiter, Upper Limiter, Lower Limiter,

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

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

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

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

  72.             cos, sin, low_shelf, s), rDefaultId(No Filter), "Harmonic Filter"),

  73.     rParamZyn(Pfilterpar1, rShort("p1"), rDefault(64), "Filter parameter"),

  74.     rParamZyn(Pfilterpar2, rShort("p2"), rDefault(64), "Filter parameter"),

  75.     rToggle(Pfilterbeforews, rShort("pre/post"), rDefault(false),

  76.             "Filter before waveshaping spectra;"

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

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

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

  80.             rDefault(None), "Spectral Adjustment Type"),

  81.     rParamZyn(Psapar, rShort("p1"), rDefault(64),

  82.               "Spectral Adjustment Parameter"),

  83.     rParamI(Pharmonicshift, rLinear(-64,64), rShort("shift"), rDefault(0),

  84.             "Amount of shift on harmonics"),

  85.     rToggle(Pharmonicshiftfirst, rShort("pre/post"), rDefault(false),

  86.             "If harmonics are shifted before waveshaping/filtering"),

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

  88.             rDefault(None), "Frequency Modulation To Combined Spectra"),

  89.     rParamZyn(Pmodulationpar1, rShort("p1"), rDefault(64),

  90.               "modulation parameter"),

  91.     rParamZyn(Pmodulationpar2, rShort("p2"), rDefault(64),

  92.               "modulation parameter"),

  93.     rParamZyn(Pmodulationpar3, rShort("p3"), rDefault(32),

  94.               "modulation parameter"),

  95. 

  96. 

  97.     //TODO update to rArray and test

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

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

  100.             const char *mm = m;

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

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

  103.             if(!rtosc_narguments(m))

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

  105.             else {

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

  107.                 //XXX hack hack

  108.                 char  repath[128];

  109.                 strcpy(repath, d.loc);

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

  111.                 strcpy(edit, "prepare");

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

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

  114.                 o.prepare(data);

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

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

  117.                 o.pendingfreqs = data;

  118.             }

  119.         }},

  120.     //TODO update to rArray and test

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

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

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

  124.             const char *mm = m;

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

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

  127.             if(!rtosc_narguments(m))

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

  129.             else {

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

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

  132.                 //XXX hack hack

  133.                 char  repath[128];

  134.                 strcpy(repath, d.loc);

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

  136.                 strcpy(edit, "prepare");

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

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

  139.                 o.prepare(data);

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

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

  142.                 o.pendingfreqs = data;

  143.             }

  144.         }},

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

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

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

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

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

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

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

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

  153.             delete[] spc;

  154.         }},

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

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

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

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

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

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

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

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

  163.             delete[] smps;

  164.         }},

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

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

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

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

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

  170.             o.prepare(data);

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

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

  173.             o.pendingfreqs = data;

  174.         }},

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

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

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

  178.             //XXX hack hack

  179.             char  repath[128];

  180.             strcpy(repath, d.loc);

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

  182.             *edit = 0;

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

  184.         }},

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

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

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

  188.             //XXX hack hack

  189.             char  repath[128];

  190.             strcpy(repath, d.loc);

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

  192.             *edit = 0;

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

  194.         }}};

  195. 

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

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

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

  199.     rSelf(OscilGen),

  200.     rPresetType,

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

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

  203.     rParamZyn(Pamprandpower, rShort("variance"), rDefault(64),

  204.             "Variance of harmonic randomness"),

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

  206.             rDefault(None),

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

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

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

  210.             rDefault(OFF),

  211.             "Adaptive Harmonics Mode"),

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

  213.             rDefault(128), "Base frequency of adaptive harmonic (30..3000Hz)"),

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

  215.             rDefault(100), "Adaptive Harmonic Strength"),

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

  217.             rDefault(50), "Adaptive Harmonics Postprocessing Power"),

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

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

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

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

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

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

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

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

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

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

  228.             delete[] smps;

  229.         }},

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

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

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

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

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

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

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

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

  238.             delete[] spc;

  239.         }},

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

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

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

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

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

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

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

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

  248.         }},

  249. 

  250. };

  251. 

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

  253.     &OscilGen::realtime_ports,

  254.     &OscilGen::non_realtime_ports

  255. };

  256. 

  257. #ifndef M_PI_2

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

  259. #endif

  260. 

  261. 

  262. //operations on FFTfreqs

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

  264. {

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

  266. }

  267. 

  268. inline void clearDC(fft_t *freqs)

  269. {

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

  271. }

  272. 

  273. //return magnitude squared

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

  275. {

  276.     return norm(freqs[x]);

  277. }

  278. 

  279. //return magnitude

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

  281. {

  282.     return abs(freqs[x]);

  283. }

  284. 

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

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

  287. {

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

  289.     return arg(tmp);

  290. }

  291. 

  292. /**

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

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

  295.  */

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

  297. {

  298.     float normMax = 0.0f;

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

  300.         //magnitude squared

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

  302.         if(normMax < norm)

  303.             normMax = norm;

  304.     }

  305. 

  306.     const float max = sqrt(normMax);

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

  308.         return;

  309. 

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

  311.         freqs[i] /= max;

  312. }

  313. 

  314. //Full RMS normalize

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

  316. {

  317.     float sum = 0.0f;

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

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

  320. 

  321.     if(sum < 0.000001f)

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

  323. 

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

  325. 

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

  327.         freqs[i] *= gain;

  328. }

  329. 

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

  331. 

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

  333.     :Presets(), synth(synth_)

  334. {

  335.     //assert(fft_);

  336. 

  337.     setpresettype("Poscilgen");

  338.     fft = fft_;

  339.     res = res_;

  340. 

  341. 

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

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

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

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

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

  347.     cachedbasevalid = false;

  348.     pendingfreqs     = oscilFFTfreqs;

  349. 

  350.     randseed = 1;

  351.     ADvsPAD  = false;

  352. 

  353.     defaults();

  354. }

  355. 

  356. OscilGen::~OscilGen()

  357. {

  358.     delete[] tmpsmps;

  359.     delete[] outoscilFFTfreqs;

  360.     delete[] basefuncFFTfreqs;

  361.     delete[] oscilFFTfreqs;

  362.     delete[] cachedbasefunc;

  363. }

  364. 

  365. 

  366. void OscilGen::defaults()

  367. {

  368.     oldbasefunc = 0;

  369.     oldbasepar  = 64;

  370.     oldhmagtype = 0;

  371.     oldwaveshapingfunction = 0;

  372.     oldwaveshaping = 64;

  373.     oldbasefuncmodulation     = 0;

  374.     oldharmonicshift          = 0;

  375.     oldbasefuncmodulationpar1 = 0;

  376.     oldbasefuncmodulationpar2 = 0;

  377.     oldbasefuncmodulationpar3 = 0;

  378.     oldmodulation     = 0;

  379.     oldmodulationpar1 = 0;

  380.     oldmodulationpar2 = 0;

  381.     oldmodulationpar3 = 0;

  382. 

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

  384.         hmag[i]    = 0.0f;

  385.         hphase[i]  = 0.0f;

  386.         Phmag[i]   = 64;

  387.         Phphase[i] = 64;

  388.     }

  389.     Phmag[0]  = 127;

  390.     Phmagtype = 0;

  391.     if(ADvsPAD)

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

  393.     else

  394.         Prand = 64;  //no randomness

  395. 

  396.     Pcurrentbasefunc = 0;

  397.     Pbasefuncpar     = 64;

  398. 

  399.     Pbasefuncmodulation     = 0;

  400.     Pbasefuncmodulationpar1 = 64;

  401.     Pbasefuncmodulationpar2 = 64;

  402.     Pbasefuncmodulationpar3 = 32;

  403. 

  404.     Pmodulation     = 0;

  405.     Pmodulationpar1 = 64;

  406.     Pmodulationpar2 = 64;

  407.     Pmodulationpar3 = 32;

  408. 

  409.     Pwaveshapingfunction = 0;

  410.     Pwaveshaping    = 64;

  411.     Pfiltertype     = 0;

  412.     Pfilterpar1     = 64;

  413.     Pfilterpar2     = 64;

  414.     Pfilterbeforews = 0;

  415.     Psatype = 0;

  416.     Psapar  = 64;

  417. 

  418.     Pamprandpower = 64;

  419.     Pamprandtype  = 0;

  420. 

  421.     Pharmonicshift      = 0;

  422.     Pharmonicshiftfirst = 0;

  423. 

  424.     Padaptiveharmonics         = 0;

  425.     Padaptiveharmonicspower    = 100;

  426.     Padaptiveharmonicsbasefreq = 128;

  427.     Padaptiveharmonicspar      = 50;

  428. 

  429.     clearAll(oscilFFTfreqs, synth.oscilsize);

  430.     clearAll(basefuncFFTfreqs, synth.oscilsize);

  431.     oscilprepared = 0;

  432.     oldfilterpars = 0;

  433.     oldsapars     = 0;

  434.     prepare();

  435. }

  436. 

  437. void OscilGen::convert2sine()

  438. {

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

  440.     float  oscil[synth.oscilsize];

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

  442.     get(oscil, -1.0f);

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

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

  445.     delete (fft);

  446. 

  447.     normalize(freqs, synth.oscilsize);

  448. 

  449.     mag[0]   = 0;

  450.     phase[0] = 0;

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

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

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

  454.     }

  455. 

  456.     defaults();

  457. 

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

  459.         float newmag   = mag[i];

  460.         float newphase = phase[i];

  461. 

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

  463. 

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

  465.         if(Phphase[i] > 127)

  466.             Phphase[i] = 127;

  467. 

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

  469.             Phphase[i] = 64;

  470.     }

  471.     delete[] freqs;

  472.     prepare();

  473. }

  474. 

  475. float OscilGen::userfunc(float x)

  476. {

  477.     if (!fft)

  478.         return 0;

  479.     if (!cachedbasevalid) {

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

  481.         cachedbasevalid = true;

  482.     }

  483.     return cinterpolate(cachedbasefunc,

  484.                         synth.oscilsize,

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

  486. }

  487. 

  488. /*

  489.  * Get the base function

  490.  */

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

  492. {

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

  494.     if(Pbasefuncpar == 64)

  495.         par = 0.5f;

  496. 

  497.     float p1 = Pbasefuncmodulationpar1 / 127.0f,

  498.           p2 = Pbasefuncmodulationpar2 / 127.0f,

  499.           p3 = Pbasefuncmodulationpar3 / 127.0f;

  500. 

  501.     switch(Pbasefuncmodulation) {

  502.         case 1:

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

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

  505.             if(p3 < 0.9999f)

  506.                 p3 = -1.0f;

  507.             break;

  508.         case 2:

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

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

  511.             break;

  512.         case 3:

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

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

  515.             break;

  516.     }

  517. 

  518.     base_func func = getBaseFunction(Pcurrentbasefunc);

  519. 

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

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

  522. 

  523.         switch(Pbasefuncmodulation) {

  524.             case 1: //rev

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

  526.                 break;

  527.             case 2: //sine

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

  529.                 break;

  530.             case 3: //power

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

  532.                 break;

  533.             case 4: //chop

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

  535.                               Pbasefuncmodulationpar2/2048.0)) + p3;

  536.         }

  537. 

  538.         t = t - floor(t);

  539. 

  540.         if(func)

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

  542.         else if (Pcurrentbasefunc == 0)

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

  544.         else

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

  546.     }

  547. }

  548. 

  549. 

  550. /*

  551.  * Filter the oscillator

  552.  */

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

  554. {

  555.     if(Pfiltertype == 0)

  556.         return;

  557. 

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

  559.     const float par2   = Pfilterpar2 / 127.0f;

  560.     filter_func filter = getFilter(Pfiltertype);

  561. 

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

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

  564. 

  565.     normalize(freqs, synth.oscilsize);

  566. }

  567. 

  568. 

  569. /*

  570.  * Change the base function

  571.  */

  572. void OscilGen::changebasefunction(void)

  573. {

  574.     if(Pcurrentbasefunc != 0) {

  575.         getbasefunction(tmpsmps);

  576.         if(fft)

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

  578.         clearDC(basefuncFFTfreqs);

  579.     }

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

  581.         clearAll(basefuncFFTfreqs, synth.oscilsize);

  582.     oscilprepared = 0;

  583.     oldbasefunc   = Pcurrentbasefunc;

  584.     oldbasepar    = Pbasefuncpar;

  585.     oldbasefuncmodulation     = Pbasefuncmodulation;

  586.     oldbasefuncmodulationpar1 = Pbasefuncmodulationpar1;

  587.     oldbasefuncmodulationpar2 = Pbasefuncmodulationpar2;

  588.     oldbasefuncmodulationpar3 = Pbasefuncmodulationpar3;

  589. }

  590. 

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

  592. {

  593.     //Find max

  594.     float max = 0.0f;

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

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

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

  598.     if(max < 0.00001f)

  599.         max = 1.0f;

  600. 

  601.     //Normalize to +-1

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

  603.         smps[i] /= max;

  604. }

  605. 

  606. /*

  607.  * Waveshape

  608.  */

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

  610. {

  611.     oldwaveshapingfunction = Pwaveshapingfunction;

  612.     oldwaveshaping = Pwaveshaping;

  613.     if(Pwaveshapingfunction == 0)

  614.         return;

  615. 

  616.     clearDC(freqs);

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

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

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

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

  621.     }

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

  623. 

  624.     //Normalize

  625.     normalize(tmpsmps, synth.oscilsize);

  626. 

  627.     //Do the waveshaping

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

  629. 

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

  631. }

  632. 

  633. 

  634. /*

  635.  * Do the Frequency Modulation of the Oscil

  636.  */

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

  638. {

  639.     oldmodulation     = Pmodulation;

  640.     oldmodulationpar1 = Pmodulationpar1;

  641.     oldmodulationpar2 = Pmodulationpar2;

  642.     oldmodulationpar3 = Pmodulationpar3;

  643.     if(Pmodulation == 0)

  644.         return;

  645. 

  646. 

  647.     float modulationpar1 = Pmodulationpar1 / 127.0f,

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

  649.           modulationpar3 = Pmodulationpar3 / 127.0f;

  650. 

  651.     switch(Pmodulation) {

  652.         case 1:

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

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

  655.             if(modulationpar3 < 0.9999f)

  656.                 modulationpar3 = -1.0f;

  657.             break;

  658.         case 2:

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

  660.             modulationpar3 = 1.0f

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

  662.             break;

  663.         case 3:

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

  665.             modulationpar3 = 0.01f

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

  667.             break;

  668.     }

  669. 

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

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

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

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

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

  675.     }

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

  677.     const int    extra_points = 2;

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

  679. 

  680.     //Normalize

  681.     normalize(tmpsmps, synth.oscilsize);

  682. 

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

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

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

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

  687. 

  688.     //Do the modulation

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

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

  691. 

  692.         switch(Pmodulation) {

  693.             case 1:

  694.                 t = t * modulationpar3

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

  696.                 break;

  697.             case 2:

  698.                 t = t

  699.                     + sinf((t * modulationpar3

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

  701.                 break;

  702.             case 3:

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

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

  705.                              modulationpar3) * modulationpar1; //power

  706.                 break;

  707.         }

  708. 

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

  710. 

  711.         const int   poshi = (int) t;

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

  713. 

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

  715.     }

  716. 

  717.     delete [] in;

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

  719. }

  720. 

  721. 

  722. /*

  723.  * Adjust the spectrum

  724.  */

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

  726. {

  727.     if(Psatype == 0)

  728.         return;

  729.     float par = Psapar / 127.0f;

  730.     switch(Psatype) {

  731.         case 1:

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

  733.             if(par >= 0.0f)

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

  735.             else

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

  737.             break;

  738.         case 2:

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

  740.             break;

  741.         case 3:

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

  743.             break;

  744.     }

  745. 

  746.     normalize(freqs, synth.oscilsize);

  747. 

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

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

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

  751. 

  752.         switch(Psatype) {

  753.             case 1:

  754.                 mag = powf(mag, par);

  755.                 break;

  756.             case 2:

  757.                 if(mag < par)

  758.                     mag = 0.0f;

  759.                 break;

  760.             case 3:

  761.                 mag /= par;

  762.                 if(mag > 1.0f)

  763.                     mag = 1.0f;

  764.                 break;

  765.         }

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

  767.     }

  768. }

  769. 

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

  771. {

  772.     if(Pharmonicshift == 0)

  773.         return;

  774. 

  775.     int   harmonicshift = -Pharmonicshift;

  776.     fft_t h;

  777. 

  778.     if(harmonicshift > 0)

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

  780.             int oldh = i - harmonicshift;

  781.             if(oldh < 0)

  782.                 h = 0.0f;

  783.             else

  784.                 h = freqs[oldh + 1];

  785.             freqs[i + 1] = h;

  786.         }

  787.     else

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

  789. 	    int oldh = i + ::abs(harmonicshift);

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

  791.                 h = 0.0f;

  792.             else {

  793.                 h = freqs[oldh + 1];

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

  795.                     h = 0.0f;

  796.             }

  797. 

  798.             freqs[i + 1] = h;

  799.         }

  800. 

  801.     clearDC(freqs);

  802. }

  803. 

  804. /*

  805.  * Prepare the Oscillator

  806.  */

  807. void OscilGen::prepare(void)

  808. {

  809.     prepare(oscilFFTfreqs);

  810. }

  811. 

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

  813. {

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

  815.        || DIFF(basefuncmodulation) || DIFF(basefuncmodulationpar1)

  816.        || DIFF(basefuncmodulationpar2) || DIFF(basefuncmodulationpar3))

  817.         changebasefunction();

  818. 

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

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

  821. 

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

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

  824.         switch(Phmagtype) {

  825.             case 1:

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

  827.                 break;

  828.             case 2:

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

  830.                 break;

  831.             case 3:

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

  833.                 break;

  834.             case 4:

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

  836.                 break;

  837.             default:

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

  839.                 break;

  840.         }

  841. 

  842.         if(Phmag[i] < 64)

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

  844.     }

  845. 

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

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

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

  849.             hmag[i] = 0.0f;

  850. 

  851. 

  852.     clearAll(freqs, synth.oscilsize);

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

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

  855.             freqs[i + 1] =

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

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

  858.         }

  859.     else

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

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

  862.                 continue;

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

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

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

  866.                     break;

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

  868.                     hmag[j],

  869.                     hphase[j] * k);

  870.             }

  871.         }

  872. 

  873.     if(Pharmonicshiftfirst != 0)

  874.         shiftharmonics(freqs);

  875. 

  876.     if(Pfilterbeforews) {

  877.         oscilfilter(freqs);

  878.         waveshape(freqs);

  879.     } else {

  880.         waveshape(freqs);

  881.         oscilfilter(freqs);

  882.     }

  883. 

  884.     modulation(freqs);

  885.     spectrumadjust(freqs);

  886.     if(Pharmonicshiftfirst == 0)

  887.         shiftharmonics(freqs);

  888. 

  889.     clearDC(freqs);

  890. 

  891.     oldhmagtype      = Phmagtype;

  892.     oldharmonicshift = Pharmonicshift + Pharmonicshiftfirst * 256;

  893. 

  894.     oscilprepared = 1;

  895. }

  896. 

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

  898. {

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

  900. }

  901. 

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

  903. {

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

  905.         return;

  906.     if(freq < 1.0f)

  907.         freq = 440.0f;

  908. 

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

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

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

  912.     clearAll(f, synth.oscilsize);

  913.     clearDC(inf);

  914. 

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

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

  917. 

  918.     float rap = freq / basefreq;

  919. 

  920.     rap = powf(rap, power);

  921. 

  922.     bool down = false;

  923.     if(rap > 1.0f) {

  924.         rap  = 1.0f / rap;

  925.         down = true;

  926.     }

  927. 

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

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

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

  931. 

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

  933.             break;

  934. 

  935.         if(down) {

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

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

  938.         }

  939.         else {

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

  941.         }

  942.     }

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

  944.         f[0] *= rap;

  945. 

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

  947.     clearDC(f);

  948.     delete[] inf;

  949. }

  950. 

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

  952. {

  953.     if(Padaptiveharmonics <= 1)

  954.         return;

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

  956.     float  par = Padaptiveharmonicspar * 0.01f;

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

  958. 

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

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

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

  962.     }

  963. 

  964. 

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

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

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

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

  969.     }

  970.     else {  //other ways

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

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

  973.         if(sub_vs_add == 0) {

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

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

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

  977.         }

  978.         else

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

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

  981.     }

  982. 

  983.     delete [] inf;

  984. }

  985. 

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

  987. {

  988.     this->randseed = randseed;

  989. }

  990. 

  991. bool OscilGen::needPrepare(void)

  992. {

  993.     bool outdated = false;

  994. 

  995.     //Check function parameters

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

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

  998.         outdated = true;

  999. 

  1000.     //Check filter parameters

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

  1002.        + Pfilterbeforews * 16777216) {

  1003.         outdated      = true;

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

  1005.                         + Pfilterbeforews * 16777216;

  1006.     }

  1007. 

  1008.     //Check spectrum adjustments

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

  1010.         outdated  = true;

  1011.         oldsapars = Psatype * 256 + Psapar;

  1012.     }

  1013. 

  1014.     //Check function modulation

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

  1016.        || DIFF(basefuncmodulationpar2) || DIFF(basefuncmodulationpar3))

  1017.         outdated = true;

  1018. 

  1019.     //Check overall modulation

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

  1021.        || DIFF(modulationpar2) || DIFF(modulationpar3))

  1022.         outdated = true;

  1023. 

  1024.     //Check harmonic shifts

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

  1026.         outdated = true;

  1027. 

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

  1029. }

  1030. 

  1031. /*

  1032.  * Get the oscillator function

  1033.  */

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

  1035. {

  1036.     if(needPrepare())

  1037.         prepare();

  1038. 

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

  1040. 

  1041.     int outpos =

  1042.         (int)((RND * 2.0f

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

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

  1045. 

  1046. 

  1047.     clearAll(outoscilFFTfreqs, synth.oscilsize);

  1048. 

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

  1050.     if(ADvsPAD)

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

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

  1053.         nyquist = synth.oscilsize / 2;

  1054. 

  1055.     //Process harmonics

  1056.     {

  1057.         int realnyquist = nyquist;

  1058. 

  1059.         if(Padaptiveharmonics != 0)

  1060.             nyquist = synth.oscilsize / 2;

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

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

  1063. 

  1064.         adaptiveharmonic(outoscilFFTfreqs, freqHz);

  1065.         adaptiveharmonicpostprocess(&outoscilFFTfreqs[1],

  1066.                                     synth.oscilsize / 2 - 1);

  1067. 

  1068.         nyquist = realnyquist;

  1069.     }

  1070. 

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

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

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

  1074. 

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

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

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

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

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

  1080.             outoscilFFTfreqs[i] *=

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

  1082.     }

  1083. 

  1084.     //Harmonic Amplitude Randomness

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

  1086.         unsigned int realrnd = prng();

  1087.         sprng(randseed);

  1088.         float power     = Pamprandpower / 127.0f;

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

  1090.         switch(Pamprandtype) {

  1091.             case 1:

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

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

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

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

  1096.                 break;

  1097.             case 2:

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

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

  1100.                 float rndfreq = 2 * PI * RND;

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

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

  1103.                                            * normalize;

  1104.                 break;

  1105.         }

  1106.         sprng(realrnd + 1);

  1107.     }

  1108. 

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

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

  1111. 

  1112.     rmsNormalize(outoscilFFTfreqs, synth.oscilsize);

  1113. 

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

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

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

  1117.     else {

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

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

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

  1121.     }

  1122. 

  1123.     if(Prand < 64)

  1124.         return outpos;

  1125.     else

  1126.         return 0;

  1127. }

  1128. 

  1129. ///*

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

  1131. // */

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

  1133. //{

  1134. //    if(needPrepare())

  1135. //        prepare();

  1136. //

  1137. //    clearAll(outoscilFFTfreqs);

  1138. //

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

  1140. //

  1141. //    //Process harmonics

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

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

  1144. //

  1145. //    adaptiveharmonic(outoscilFFTfreqs, freqHz);

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

  1147. //

  1148. //    rmsNormalize(outoscilFFTfreqs);

  1149. //

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

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

  1152. //}

  1153. //

  1154. 

  1155. /*

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

  1157.  */

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

  1159. {

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

  1161.         n = synth.oscilsize / 2;

  1162. 

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

  1164.         if(what == 0)

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

  1166.         else {

  1167.             if(Pcurrentbasefunc == 0)

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

  1169.             else

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

  1171.         }

  1172.     }

  1173.     spc[0]=0;

  1174. 

  1175.     if(what == 0) {

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

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

  1178.         memset(outoscilFFTfreqs + n, 0,

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

  1180.         adaptiveharmonic(outoscilFFTfreqs, 0.0f);

  1181.         adaptiveharmonicpostprocess(outoscilFFTfreqs, n - 1);

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

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

  1184.     }

  1185. }

  1186. 

  1187. 

  1188. /*

  1189.  * Convert the oscillator as base function

  1190.  */

  1191. void OscilGen::useasbase()

  1192. {

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

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

  1195. 

  1196.     oldbasefunc = Pcurrentbasefunc = 127;

  1197.     prepare();

  1198.     cachedbasevalid = false;

  1199. }

  1200. 

  1201. 

  1202. /*

  1203.  * Get the base function for UI

  1204.  */

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

  1206. {

  1207.     if(Pcurrentbasefunc != 0)

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

  1209.     else

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

  1211. }

  1212. 

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

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

  1215. {

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

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

  1218.         COPY(Phmag[i]);

  1219.         COPY(Phphase[i]);

  1220.     }

  1221. 

  1222.     COPY(Phmagtype);

  1223.     COPY(Pcurrentbasefunc);

  1224.     COPY(Pbasefuncpar);

  1225. 

  1226.     COPY(Pbasefuncmodulation);

  1227.     COPY(Pbasefuncmodulationpar1);

  1228.     COPY(Pbasefuncmodulationpar2);

  1229.     COPY(Pbasefuncmodulationpar3);

  1230. 

  1231.     COPY(Pwaveshaping);

  1232.     COPY(Pwaveshapingfunction);

  1233.     COPY(Pfiltertype);

  1234.     COPY(Pfilterpar1);

  1235.     COPY(Pfilterpar2);

  1236.     COPY(Pfilterbeforews);

  1237.     COPY(Psatype);

  1238.     COPY(Psapar);

  1239. 

  1240.     COPY(Pharmonicshift);

  1241.     COPY(Pharmonicshiftfirst);

  1242. 

  1243.     COPY(Pmodulation);

  1244.     COPY(Pmodulationpar1);

  1245.     COPY(Pmodulationpar2);

  1246.     COPY(Pmodulationpar3);

  1247. 

  1248.     COPY(Prand);

  1249.     COPY(Pamprandpower);

  1250.     COPY(Pamprandtype);

  1251.     COPY(Padaptiveharmonics);

  1252.     COPY(Padaptiveharmonicsbasefreq);

  1253.     COPY(Padaptiveharmonicspower);

  1254.     COPY(Padaptiveharmonicspar);

  1255. 

  1256. 

  1257.     if(this->Pcurrentbasefunc)

  1258.         changebasefunction();

  1259.     this->prepare();

  1260. }

  1261. #undef COPY

  1262. 

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

  1264. {

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

  1266. 

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

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

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

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

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

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

  1273. 

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

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

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

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

  1278. 

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

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

  1281. 

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

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

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

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

  1286. 

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

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

  1289. 

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

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

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

  1293. 

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

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

  1296. 

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

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

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

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

  1301. 

  1302.     xml.beginbranch("HARMONICS");

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

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

  1305.             continue;

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

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

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

  1309.         xml.endbranch();

  1310.     }

  1311.     xml.endbranch();

  1312. 

  1313.     if(Pcurrentbasefunc == 127) {

  1314.         normalize(basefuncFFTfreqs, synth.oscilsize);

  1315. 

  1316.         xml.beginbranch("BASE_FUNCTION");

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

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

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

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

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

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

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

  1324.                 xml.endbranch();

  1325.             }

  1326.         }

  1327.         xml.endbranch();

  1328.     }

  1329. }

  1330. 

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

  1332. {

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

  1334. 

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

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

  1337. 

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

  1339.                                          Pbasefuncmodulation);

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

  1341.                                              Pbasefuncmodulationpar1);

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

  1343.                                              Pbasefuncmodulationpar2);

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

  1345.                                              Pbasefuncmodulationpar3);

  1346. 

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

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

  1349.                                      Pmodulationpar1);

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

  1351.                                      Pmodulationpar2);

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

  1353.                                      Pmodulationpar3);

  1354. 

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

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

  1357.                                           Pwaveshapingfunction);

  1358. 

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

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

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

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

  1363.                                      Pfilterbeforews);

  1364. 

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

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

  1367. 

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

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

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

  1371. 

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

  1373.                                  Pharmonicshift,

  1374.                                  -64,

  1375.                                  64);

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

  1377.                                           Pharmonicshiftfirst);

  1378. 

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

  1380.                                      Padaptiveharmonics,

  1381.                                      0,

  1382.                                      127);

  1383.     Padaptiveharmonicsbasefreq = xml.getpar(

  1384.         "adaptive_harmonics_base_frequency",

  1385.         Padaptiveharmonicsbasefreq,

  1386.         0,

  1387.         255);

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

  1389.                                           Padaptiveharmonicspower,

  1390.                                           0,

  1391.                                           200);

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

  1393.                                        Padaptiveharmonicspar,

  1394.                                        0,

  1395.                                        100);

  1396. 

  1397. 

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

  1399.         Phmag[0]   = 64;

  1400.         Phphase[0] = 64;

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

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

  1403.                 continue;

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

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

  1406.             xml.exitbranch();

  1407.         }

  1408.         xml.exitbranch();

  1409.     }

  1410. 

  1411.     if(Pcurrentbasefunc != 0)

  1412.         changebasefunction();

  1413. 

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

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

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

  1417.                 basefuncFFTfreqs[i] =

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

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

  1420.                 xml.exitbranch();

  1421.             }

  1422.         xml.exitbranch();

  1423. 

  1424.         clearDC(basefuncFFTfreqs);

  1425.         normalize(basefuncFFTfreqs, synth.oscilsize);

  1426.         cachedbasevalid = false;

  1427.     }}

  1428. 

  1429. 

  1430. //Define basic functions

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

  1432. 

  1433. FUNC(pulse)

  1434. {

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

  1436. }

  1437. 

  1438. FUNC(saw)

  1439. {

  1440.     if(a < 0.00001f)

  1441.         a = 0.00001f;

  1442.     else

  1443.     if(a > 0.99999f)

  1444.         a = 0.99999f;

  1445.     x = fmod(x, 1);

  1446.     if(x < a)

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

  1448.     else

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

  1450. }

  1451. 

  1452. FUNC(triangle)

  1453. {

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

  1455.     a = 1 - a;

  1456.     if(a < 0.00001f)

  1457.         a = 0.00001f;

  1458.     if(x < 0.5f)

  1459.         x = x * 4 - 1.0f;

  1460.     else

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

  1462.     x /= -a;

  1463.     if(x < -1.0f)

  1464.         x = -1.0f;

  1465.     if(x > 1.0f)

  1466.         x = 1.0f;

  1467.     return x;

  1468. }

  1469. 

  1470. FUNC(power)

  1471. {

  1472.     x = fmod(x, 1);

  1473.     if(a < 0.00001f)

  1474.         a = 0.00001f;

  1475.     else

  1476.     if(a > 0.99999f)

  1477.         a = 0.99999f;

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

  1479. }

  1480. 

  1481. FUNC(gauss)

  1482. {

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

  1484.     if(a < 0.00001f)

  1485.         a = 0.00001f;

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

  1487. }

  1488. 

  1489. FUNC(diode)

  1490. {

  1491.     if(a < 0.00001f)

  1492.         a = 0.00001f;

  1493.     else

  1494.     if(a > 0.99999f)

  1495.         a = 0.99999f;

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

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

  1498.     if(x < 0.0f)

  1499.         x = 0.0f;

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

  1501. }

  1502. 

  1503. FUNC(abssine)

  1504. {

  1505.     x = fmod(x, 1);

  1506.     if(a < 0.00001f)

  1507.         a = 0.00001f;

  1508.     else

  1509.     if(a > 0.99999f)

  1510.         a = 0.99999f;

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

  1512. }

  1513. 

  1514. FUNC(pulsesine)

  1515. {

  1516.     if(a < 0.00001f)

  1517.         a = 0.00001f;

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

  1519.     if(x < -0.5f)

  1520.         x = -0.5f;

  1521.     else

  1522.     if(x > 0.5f)

  1523.         x = 0.5f;

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

  1525.     return x;

  1526. }

  1527. 

  1528. FUNC(stretchsine)

  1529. {

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

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

  1532.     if(a > 0.0f)

  1533.         a *= 2;

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

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

  1536.     if(x < 0)

  1537.         b = -b;

  1538.     return -sinf(b * PI);

  1539. }

  1540. 

  1541. FUNC(chirp)

  1542. {

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

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

  1545.     if(a < 0.0f)

  1546.         a *= 2.0f;

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

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

  1549. }

  1550. 

  1551. FUNC(absstretchsine)

  1552. {

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

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

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

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

  1557.     if(x < 0)

  1558.         b = -b;

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

  1560. }

  1561. 

  1562. FUNC(chebyshev)

  1563. {

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

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

  1566. }

  1567. 

  1568. FUNC(sqr)

  1569. {

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

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

  1572. }

  1573. 

  1574. FUNC(spike)

  1575. {

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

  1577. 

  1578.     if(x < 0.5) {

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

  1580.             return 0.0;

  1581.         else {

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

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

  1584.         }

  1585.     }

  1586.     else {

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

  1588.             return 0.0;

  1589.         else {

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

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

  1592.         }

  1593.     }

  1594. }

  1595. 

  1596. FUNC(circle)

  1597. {

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

  1599.     float b, y;

  1600. 

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

  1602.     x = x * 4;

  1603. 

  1604.     if(x < 2) {

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

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

  1607.             y = 0;

  1608.         else

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

  1610.     }

  1611.     else {

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

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

  1614.             y = 0;

  1615.         else

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

  1617.     }

  1618.     return y;

  1619. }

  1620. 

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

  1622. 

  1623. base_func getBaseFunction(unsigned char func)

  1624. {

  1625.     if(!func)

  1626.         return NULL;

  1627. 

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

  1629.         return NULL;

  1630. 

  1631.     func--;

  1632.     assert(func < 15);

  1633.     base_func functions[] = {

  1634.         basefunc_triangle,

  1635.         basefunc_pulse,

  1636.         basefunc_saw,

  1637.         basefunc_power,

  1638.         basefunc_gauss,

  1639.         basefunc_diode,

  1640.         basefunc_abssine,

  1641.         basefunc_pulsesine,

  1642.         basefunc_stretchsine,

  1643.         basefunc_chirp,

  1644.         basefunc_absstretchsine,

  1645.         basefunc_chebyshev,

  1646.         basefunc_sqr,

  1647.         basefunc_spike,

  1648.         basefunc_circle,

  1649.     };

  1650.     return functions[func];

  1651. }

  1652. 

  1653. //And filters

  1654. 

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

  1656. FILTER(lp)

  1657. {

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

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

  1660.     if(gain < tmp)

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

  1662.     return gain;

  1663. }

  1664. 

  1665. FILTER(hp1)

  1666. {

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

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

  1669. }

  1670. 

  1671. FILTER(hp1b)

  1672. {

  1673.     if(par < 0.2f)

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

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

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

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

  1678.     return powf(gain, tmp);

  1679. }

  1680. 

  1681. FILTER(bp1)

  1682. {

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

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

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

  1686.     gain = powf(gain, tmp);

  1687.     if(gain < 1e-5)

  1688.         gain = 1e-5;

  1689.     return gain;

  1690. }

  1691. 

  1692. FILTER(bs1)

  1693. {

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

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

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

  1697. }

  1698. 

  1699. FILTER(lp2)

  1700. {

  1701.     return (i + 1 >

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

  1703. }

  1704. 

  1705. FILTER(hp2)

  1706. {

  1707.     if(par == 1)

  1708.         return 1.0f;

  1709.     return (i + 1 >

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

  1711. }

  1712. 

  1713. FILTER(bp2)

  1714. {

  1715.     return (fabs(powf(2,

  1716.                       (1.0f

  1717.                        - par)

  1718.                       * 7)

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

  1720. }

  1721. 

  1722. FILTER(bs2)

  1723. {

  1724.     return (fabs(powf(2,

  1725.                       (1.0f

  1726.                        - par)

  1727.                       * 7)

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

  1729. }

  1730. 

  1731. bool floatEq(float a, float b)

  1732. {

  1733.     const float fudge = .01;

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

  1735. }

  1736. 

  1737. FILTER(cos)

  1738. {

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

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

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

  1742.         tmp = i;

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

  1744.     gain *= gain;

  1745.     return gain;

  1746. }

  1747. 

  1748. FILTER(sin)

  1749. {

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

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

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

  1753.         tmp = i;

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

  1755.     gain *= gain;

  1756.     return gain;

  1757. }

  1758. 

  1759. FILTER(low_shelf)

  1760. {

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

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

  1763.     if(x < 0.0f)

  1764.         x = 0.0f;

  1765.     else

  1766.     if(x > 1.0f)

  1767.         x = 1.0f;

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

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

  1770. }

  1771. 

  1772. FILTER(s)

  1773. {

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

  1775.     float gain = 1.0f;

  1776.     if(i == tmp)

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

  1778.     return gain;

  1779. }

  1780. #undef FILTER

  1781. 

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

  1783. filter_func getFilter(unsigned char func)

  1784. {

  1785.     if(!func)

  1786.         return NULL;

  1787. 

  1788.     func--;

  1789.     assert(func < 13);

  1790.     filter_func functions[] = {

  1791.         osc_lp,

  1792.         osc_hp1,

  1793.         osc_hp1b,

  1794.         osc_bp1,

  1795.         osc_bs1,

  1796.         osc_lp2,

  1797.         osc_hp2,

  1798.         osc_bp2,

  1799.         osc_bs2,

  1800.         osc_cos,

  1801.         osc_sin,

  1802.         osc_low_shelf,

  1803.         osc_s

  1804.     };

  1805.     return functions[func];

  1806. }

  1807. 

  1808. }