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.
1817 Commits
16 Branches
16GB
Tree: 8738b6ecd1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8738b6ecd1'
${ noResults }
Carla/source/modules/native-plugins/zynaddsubfx/Params/PADnoteParameters.cpp

903 lines
29KB
Raw Blame History 

  1. /*

  2.   ZynAddSubFX - a software synthesizer

  3. 

  4.   PADnoteParameters.cpp - Parameters for PADnote (PADsynth)

  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 modify

  9.   it under the terms of version 2 of the GNU General Public License

  10.   as published by the Free Software Foundation.

  11. 

  12.   This program is distributed in the hope that it will be useful,

  13.   but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  15.   GNU General Public License (version 2 or later) for more details.

  16. 

  17.   You should have received a copy of the GNU General Public License (version 2)

  18.   along with this program; if not, write to the Free Software Foundation,

  19.   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA

  20. 

  21. */

  22. #include <math.h>

  23. #include "PADnoteParameters.h"

  24. #include "../Misc/WavFile.h"

  25. 

  26. PADnoteParameters::PADnoteParameters(FFTwrapper *fft_,

  27.                                      pthread_mutex_t *mutex_):Presets()

  28. {

  29.     setpresettype("Ppadsynth");

  30. 

  31.     fft   = fft_;

  32.     mutex = mutex_;

  33. 

  34.     resonance = new Resonance();

  35.     oscilgen  = new OscilGen(fft_, resonance);

  36.     oscilgen->ADvsPAD = true;

  37. 

  38.     FreqEnvelope = new EnvelopeParams(0, 0);

  39.     FreqEnvelope->ASRinit(64, 50, 64, 60);

  40.     FreqLfo = new LFOParams(70, 0, 64, 0, 0, 0, 0, 0);

  41. 

  42.     AmpEnvelope = new EnvelopeParams(64, 1);

  43.     AmpEnvelope->ADSRinit_dB(0, 40, 127, 25);

  44.     AmpLfo = new LFOParams(80, 0, 64, 0, 0, 0, 0, 1);

  45. 

  46.     GlobalFilter   = new FilterParams(2, 94, 40);

  47.     FilterEnvelope = new EnvelopeParams(0, 1);

  48.     FilterEnvelope->ADSRinit_filter(64, 40, 64, 70, 60, 64);

  49.     FilterLfo = new LFOParams(80, 0, 64, 0, 0, 0, 0, 2);

  50. 

  51.     for(int i = 0; i < PAD_MAX_SAMPLES; ++i)

  52.         sample[i].smp = NULL;

  53.     newsample.smp = NULL;

  54. 

  55.     defaults();

  56. }

  57. 

  58. PADnoteParameters::~PADnoteParameters()

  59. {

  60.     deletesamples();

  61.     delete (oscilgen);

  62.     delete (resonance);

  63. 

  64.     delete (FreqEnvelope);

  65.     delete (FreqLfo);

  66.     delete (AmpEnvelope);

  67.     delete (AmpLfo);

  68.     delete (GlobalFilter);

  69.     delete (FilterEnvelope);

  70.     delete (FilterLfo);

  71. }

  72. 

  73. void PADnoteParameters::defaults()

  74. {

  75.     Pmode = 0;

  76.     Php.base.type      = 0;

  77.     Php.base.par1      = 80;

  78.     Php.freqmult       = 0;

  79.     Php.modulator.par1 = 0;

  80.     Php.modulator.freq = 30;

  81.     Php.width     = 127;

  82.     Php.amp.type  = 0;

  83.     Php.amp.mode  = 0;

  84.     Php.amp.par1  = 80;

  85.     Php.amp.par2  = 64;

  86.     Php.autoscale = true;

  87.     Php.onehalf   = 0;

  88. 

  89.     setPbandwidth(500);

  90.     Pbwscale = 0;

  91. 

  92.     resonance->defaults();

  93.     oscilgen->defaults();

  94. 

  95.     Phrpos.type = 0;

  96.     Phrpos.par1 = 64;

  97.     Phrpos.par2 = 64;

  98.     Phrpos.par3 = 0;

  99. 

  100.     Pquality.samplesize = 3;

  101.     Pquality.basenote   = 4;

  102.     Pquality.oct    = 3;

  103.     Pquality.smpoct = 2;

  104. 

  105.     PStereo = 1; //stereo

  106.     /* Frequency Global Parameters */

  107.     Pfixedfreq    = 0;

  108.     PfixedfreqET  = 0;

  109.     PDetune       = 8192; //zero

  110.     PCoarseDetune = 0;

  111.     PDetuneType   = 1;

  112.     FreqEnvelope->defaults();

  113.     FreqLfo->defaults();

  114. 

  115.     /* Amplitude Global Parameters */

  116.     PVolume  = 90;

  117.     PPanning = 64; //center

  118.     PAmpVelocityScaleFunction = 64;

  119.     AmpEnvelope->defaults();

  120.     AmpLfo->defaults();

  121.     PPunchStrength = 0;

  122.     PPunchTime     = 60;

  123.     PPunchStretch  = 64;

  124.     PPunchVelocitySensing = 72;

  125. 

  126.     /* Filter Global Parameters*/

  127.     PFilterVelocityScale = 64;

  128.     PFilterVelocityScaleFunction = 64;

  129.     GlobalFilter->defaults();

  130.     FilterEnvelope->defaults();

  131.     FilterLfo->defaults();

  132. 

  133.     deletesamples();

  134. }

  135. 

  136. void PADnoteParameters::deletesample(int n)

  137. {

  138.     if((n < 0) || (n >= PAD_MAX_SAMPLES))

  139.         return;

  140.     if(sample[n].smp != NULL) {

  141.         delete[] sample[n].smp;

  142.         sample[n].smp = NULL;

  143.     }

  144.     sample[n].size     = 0;

  145.     sample[n].basefreq = 440.0f;

  146. }

  147. 

  148. void PADnoteParameters::deletesamples()

  149. {

  150.     for(int i = 0; i < PAD_MAX_SAMPLES; ++i)

  151.         deletesample(i);

  152. }

  153. 

  154. /*

  155.  * Get the harmonic profile (i.e. the frequency distributio of a single harmonic)

  156.  */

  157. float PADnoteParameters::getprofile(float *smp, int size)

  158. {

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

  160.         smp[i] = 0.0f;

  161.     const int supersample = 16;

  162.     float     basepar     = powf(2.0f, (1.0f - Php.base.par1 / 127.0f) * 12.0f);

  163.     float     freqmult    = floor(powf(2.0f,

  164.                                        Php.freqmult / 127.0f

  165.                                        * 5.0f) + 0.000001f);

  166. 

  167.     float modfreq = floor(powf(2.0f,

  168.                                Php.modulator.freq / 127.0f

  169.                                * 5.0f) + 0.000001f);

  170.     float modpar1 = powf(Php.modulator.par1 / 127.0f, 4.0f) * 5.0f / sqrt(

  171.         modfreq);

  172.     float amppar1 =

  173.         powf(2.0f, powf(Php.amp.par1 / 127.0f, 2.0f) * 10.0f) - 0.999f;

  174.     float amppar2 = (1.0f - Php.amp.par2 / 127.0f) * 0.998f + 0.001f;

  175.     float width   = powf(150.0f / (Php.width + 22.0f), 2.0f);

  176. 

  177.     for(int i = 0; i < size * supersample; ++i) {

  178.         bool  makezero = false;

  179.         float x = i * 1.0f / (size * (float) supersample);

  180. 

  181.         float origx = x;

  182. 

  183.         //do the sizing (width)

  184.         x = (x - 0.5f) * width + 0.5f;

  185.         if(x < 0.0f) {

  186.             x = 0.0f;

  187.             makezero = true;

  188.         }

  189.         else

  190.         if(x > 1.0f) {

  191.             x = 1.0f;

  192.             makezero = true;

  193.         }

  194. 

  195.         //compute the full profile or one half

  196.         switch(Php.onehalf) {

  197.             case 1:

  198.                 x = x * 0.5f + 0.5f;

  199.                 break;

  200.             case 2:

  201.                 x = x * 0.5f;

  202.                 break;

  203.         }

  204. 

  205.         float x_before_freq_mult = x;

  206. 

  207.         //do the frequency multiplier

  208.         x *= freqmult;

  209. 

  210.         //do the modulation of the profile

  211.         x += sinf(x_before_freq_mult * 3.1415926f * modfreq) * modpar1;

  212.         x  = fmod(x + 1000.0f, 1.0f) * 2.0f - 1.0f;

  213. 

  214. 

  215.         //this is the base function of the profile

  216.         float f;

  217.         switch(Php.base.type) {

  218.             case 1:

  219.                 f = expf(-(x * x) * basepar);

  220.                 if(f < 0.4f)

  221.                     f = 0.0f;

  222.                 else

  223.                     f = 1.0f;

  224.                 break;

  225.             case 2:

  226.                 f = expf(-(fabs(x)) * sqrt(basepar));

  227.                 break;

  228.             default:

  229.                 f = expf(-(x * x) * basepar);

  230.                 break;

  231.         }

  232.         if(makezero)

  233.             f = 0.0f;

  234. 

  235.         float amp = 1.0f;

  236.         origx = origx * 2.0f - 1.0f;

  237. 

  238.         //compute the amplitude multiplier

  239.         switch(Php.amp.type) {

  240.             case 1:

  241.                 amp = expf(-(origx * origx) * 10.0f * amppar1);

  242.                 break;

  243.             case 2:

  244.                 amp = 0.5f

  245.                       * (1.0f

  246.                          + cosf(3.1415926f * origx * sqrt(amppar1 * 4.0f + 1.0f)));

  247.                 break;

  248.             case 3:

  249.                 amp = 1.0f

  250.                       / (powf(origx * (amppar1 * 2.0f + 0.8f), 14.0f) + 1.0f);

  251.                 break;

  252.         }

  253. 

  254.         //apply the amplitude multiplier

  255.         float finalsmp = f;

  256.         if(Php.amp.type != 0)

  257.             switch(Php.amp.mode) {

  258.                 case 0:

  259.                     finalsmp = amp * (1.0f - amppar2) + finalsmp * amppar2;

  260.                     break;

  261.                 case 1:

  262.                     finalsmp *= amp * (1.0f - amppar2) + amppar2;

  263.                     break;

  264.                 case 2:

  265.                     finalsmp = finalsmp

  266.                                / (amp + powf(amppar2, 4.0f) * 20.0f + 0.0001f);

  267.                     break;

  268.                 case 3:

  269.                     finalsmp = amp

  270.                                / (finalsmp

  271.                                   + powf(amppar2, 4.0f) * 20.0f + 0.0001f);

  272.                     break;

  273.             }

  274.         ;

  275. 

  276.         smp[i / supersample] += finalsmp / supersample;

  277.     }

  278. 

  279.     //normalize the profile (make the max. to be equal to 1.0f)

  280.     float max = 0.0f;

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

  282.         if(smp[i] < 0.0f)

  283.             smp[i] = 0.0f;

  284.         if(smp[i] > max)

  285.             max = smp[i];

  286.     }

  287.     if(max < 0.00001f)

  288.         max = 1.0f;

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

  290.         smp[i] /= max;

  291. 

  292.     if(!Php.autoscale)

  293.         return 0.5f;

  294. 

  295.     //compute the estimated perceived bandwidth

  296.     float sum = 0.0f;

  297.     int   i;

  298.     for(i = 0; i < size / 2 - 2; ++i) {

  299.         sum += smp[i] * smp[i] + smp[size - i - 1] * smp[size - i - 1];

  300.         if(sum >= 4.0f)

  301.             break;

  302.     }

  303. 

  304.     float result = 1.0f - 2.0f * i / (float) size;

  305.     return result;

  306. }

  307. 

  308. /*

  309.  * Compute the real bandwidth in cents and returns it

  310.  * Also, sets the bandwidth parameter

  311.  */

  312. float PADnoteParameters::setPbandwidth(int Pbandwidth)

  313. {

  314.     this->Pbandwidth = Pbandwidth;

  315.     float result = powf(Pbandwidth / 1000.0f, 1.1f);

  316.     result = powf(10.0f, result * 4.0f) * 0.25f;

  317.     return result;

  318. }

  319. 

  320. /*

  321.  * Get the harmonic(overtone) position

  322.  */

  323. float PADnoteParameters::getNhr(int n)

  324. {

  325.     float result = 1.0f;

  326.     float par1   = powf(10.0f, -(1.0f - Phrpos.par1 / 255.0f) * 3.0f);

  327.     float par2   = Phrpos.par2 / 255.0f;

  328. 

  329.     float n0     = n - 1.0f;

  330.     float tmp    = 0.0f;

  331.     int   thresh = 0;

  332.     switch(Phrpos.type) {

  333.         case 1:

  334.             thresh = (int)(par2 * par2 * 100.0f) + 1;

  335.             if(n < thresh)

  336.                 result = n;

  337.             else

  338.                 result = 1.0f + n0 + (n0 - thresh + 1.0f) * par1 * 8.0f;

  339.             break;

  340.         case 2:

  341.             thresh = (int)(par2 * par2 * 100.0f) + 1;

  342.             if(n < thresh)

  343.                 result = n;

  344.             else

  345.                 result = 1.0f + n0 - (n0 - thresh + 1.0f) * par1 * 0.90f;

  346.             break;

  347.         case 3:

  348.             tmp    = par1 * 100.0f + 1.0f;

  349.             result = powf(n0 / tmp, 1.0f - par2 * 0.8f) * tmp + 1.0f;

  350.             break;

  351.         case 4:

  352.             result = n0

  353.                      * (1.0f

  354.                         - par1)

  355.                      + powf(n0 * 0.1f, par2 * 3.0f

  356.                             + 1.0f) * par1 * 10.0f + 1.0f;

  357.             break;

  358.         case 5:

  359.             result = n0

  360.                      + sinf(n0 * par2 * par2 * PI

  361.                             * 0.999f) * sqrt(par1) * 2.0f + 1.0f;

  362.             break;

  363.         case 6:

  364.             tmp    = powf(par2 * 2.0f, 2.0f) + 0.1f;

  365.             result = n0 * powf(1.0f + par1 * powf(n0 * 0.8f, tmp), tmp) + 1.0f;

  366.             break;

  367.         default:

  368.             result = n;

  369.             break;

  370.     }

  371. 

  372.     float par3 = Phrpos.par3 / 255.0f;

  373. 

  374.     float iresult = floor(result + 0.5f);

  375.     float dresult = result - iresult;

  376. 

  377.     result = iresult + (1.0f - par3) * dresult;

  378. 

  379.     return result;

  380. }

  381. 

  382. /*

  383.  * Generates the long spectrum for Bandwidth mode (only amplitudes are generated; phases will be random)

  384.  */

  385. void PADnoteParameters::generatespectrum_bandwidthMode(float *spectrum,

  386.                                                        int size,

  387.                                                        float basefreq,

  388.                                                        float *profile,

  389.                                                        int profilesize,

  390.                                                        float bwadjust)

  391. {

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

  393.         spectrum[i] = 0.0f;

  394. 

  395.     float harmonics[synth->oscilsize / 2];

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

  397.         harmonics[i] = 0.0f;

  398.     //get the harmonic structure from the oscillator (I am using the frequency amplitudes, only)

  399.     oscilgen->get(harmonics, basefreq, false);

  400. 

  401.     //normalize

  402.     float max = 0.0f;

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

  404.         if(harmonics[i] > max)

  405.             max = harmonics[i];

  406.     if(max < 0.000001f)

  407.         max = 1;

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

  409.         harmonics[i] /= max;

  410. 

  411.     for(int nh = 1; nh < synth->oscilsize / 2; ++nh) { //for each harmonic

  412.         float realfreq = getNhr(nh) * basefreq;

  413.         if(realfreq > synth->samplerate_f * 0.49999f)

  414.             break;

  415.         if(realfreq < 20.0f)

  416.             break;

  417.         if(harmonics[nh - 1] < 1e-4)

  418.             continue;

  419. 

  420.         //compute the bandwidth of each harmonic

  421.         float bandwidthcents = setPbandwidth(Pbandwidth);

  422.         float bw =

  423.             (powf(2.0f, bandwidthcents / 1200.0f) - 1.0f) * basefreq / bwadjust;

  424.         float power = 1.0f;

  425.         switch(Pbwscale) {

  426.             case 0:

  427.                 power = 1.0f;

  428.                 break;

  429.             case 1:

  430.                 power = 0.0f;

  431.                 break;

  432.             case 2:

  433.                 power = 0.25f;

  434.                 break;

  435.             case 3:

  436.                 power = 0.5f;

  437.                 break;

  438.             case 4:

  439.                 power = 0.75f;

  440.                 break;

  441.             case 5:

  442.                 power = 1.5f;

  443.                 break;

  444.             case 6:

  445.                 power = 2.0f;

  446.                 break;

  447.             case 7:

  448.                 power = -0.5f;

  449.                 break;

  450.         }

  451.         bw = bw * powf(realfreq / basefreq, power);

  452.         int ibw = (int)((bw / (synth->samplerate_f * 0.5f) * size)) + 1;

  453. 

  454.         float amp = harmonics[nh - 1];

  455.         if(resonance->Penabled)

  456.             amp *= resonance->getfreqresponse(realfreq);

  457. 

  458.         if(ibw > profilesize) { //if the bandwidth is larger than the profilesize

  459.             float rap   = sqrt((float)profilesize / (float)ibw);

  460.             int   cfreq =

  461.                 (int) (realfreq

  462.                        / (synth->samplerate_f * 0.5f) * size) - ibw / 2;

  463.             for(int i = 0; i < ibw; ++i) {

  464.                 int src    = (int)(i * rap * rap);

  465.                 int spfreq = i + cfreq;

  466.                 if(spfreq < 0)

  467.                     continue;

  468.                 if(spfreq >= size)

  469.                     break;

  470.                 spectrum[spfreq] += amp * profile[src] * rap;

  471.             }

  472.         }

  473.         else {  //if the bandwidth is smaller than the profilesize

  474.             float rap = sqrt((float)ibw / (float)profilesize);

  475.             float ibasefreq = realfreq / (synth->samplerate_f * 0.5f) * size;

  476.             for(int i = 0; i < profilesize; ++i) {

  477.                 float idfreq = i / (float)profilesize - 0.5f;

  478.                 idfreq *= ibw;

  479.                 int   spfreq  = (int) (idfreq + ibasefreq);

  480.                 float fspfreq = fmodf((float)idfreq + ibasefreq, 1.0f);

  481.                 if(spfreq <= 0)

  482.                     continue;

  483.                 if(spfreq >= size - 1)

  484.                     break;

  485.                 spectrum[spfreq] += amp * profile[i] * rap

  486.                                     * (1.0f - fspfreq);

  487.                 spectrum[spfreq + 1] += amp * profile[i] * rap * fspfreq;

  488.             }

  489.         }

  490.     }

  491. }

  492. 

  493. /*

  494.  * Generates the long spectrum for non-Bandwidth modes (only amplitudes are generated; phases will be random)

  495.  */

  496. void PADnoteParameters::generatespectrum_otherModes(float *spectrum,

  497.                                                     int size,

  498.                                                     float basefreq)

  499. {

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

  501.         spectrum[i] = 0.0f;

  502. 

  503.     float harmonics[synth->oscilsize / 2];

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

  505.         harmonics[i] = 0.0f;

  506.     //get the harmonic structure from the oscillator (I am using the frequency amplitudes, only)

  507.     oscilgen->get(harmonics, basefreq, false);

  508. 

  509.     //normalize

  510.     float max = 0.0f;

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

  512.         if(harmonics[i] > max)

  513.             max = harmonics[i];

  514.     if(max < 0.000001f)

  515.         max = 1;

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

  517.         harmonics[i] /= max;

  518. 

  519.     for(int nh = 1; nh < synth->oscilsize / 2; ++nh) { //for each harmonic

  520.         float realfreq = getNhr(nh) * basefreq;

  521. 

  522.         ///sa fac aici interpolarea si sa am grija daca frecv descresc

  523. 

  524.         if(realfreq > synth->samplerate_f * 0.49999f)

  525.             break;

  526.         if(realfreq < 20.0f)

  527.             break;

  528. //	if (harmonics[nh-1]<1e-4) continue;

  529. 

  530. 

  531.         float amp = harmonics[nh - 1];

  532.         if(resonance->Penabled)

  533.             amp *= resonance->getfreqresponse(realfreq);

  534.         int cfreq = (int) (realfreq / (synth->samplerate_f * 0.5f) * size);

  535. 

  536.         spectrum[cfreq] = amp + 1e-9;

  537.     }

  538. 

  539.     if(Pmode != 1) {

  540.         int old = 0;

  541.         for(int k = 1; k < size; ++k)

  542.             if((spectrum[k] > 1e-10) || (k == (size - 1))) {

  543.                 int   delta  = k - old;

  544.                 float val1   = spectrum[old];

  545.                 float val2   = spectrum[k];

  546.                 float idelta = 1.0f / delta;

  547.                 for(int i = 0; i < delta; ++i) {

  548.                     float x = idelta * i;

  549.                     spectrum[old + i] = val1 * (1.0f - x) + val2 * x;

  550.                 }

  551.                 old = k;

  552.             }

  553.     }

  554. }

  555. 

  556. /*

  557.  * Applies the parameters (i.e. computes all the samples, based on parameters);

  558.  */

  559. void PADnoteParameters::applyparameters(bool lockmutex)

  560. {

  561.     const int samplesize   = (((int) 1) << (Pquality.samplesize + 14));

  562.     int       spectrumsize = samplesize / 2;

  563.     float     spectrum[spectrumsize];

  564.     int       profilesize = 512;

  565.     float     profile[profilesize];

  566. 

  567. 

  568.     float bwadjust = getprofile(profile, profilesize);

  569. //    for (int i=0;i<profilesize;i++) profile[i]*=profile[i];

  570.     float basefreq = 65.406f * powf(2.0f, Pquality.basenote / 2);

  571.     if(Pquality.basenote % 2 == 1)

  572.         basefreq *= 1.5f;

  573. 

  574.     int samplemax = Pquality.oct + 1;

  575.     int smpoct    = Pquality.smpoct;

  576.     if(Pquality.smpoct == 5)

  577.         smpoct = 6;

  578.     if(Pquality.smpoct == 6)

  579.         smpoct = 12;

  580.     if(smpoct != 0)

  581.         samplemax *= smpoct;

  582.     else

  583.         samplemax = samplemax / 2 + 1;

  584.     if(samplemax == 0)

  585.         samplemax = 1;

  586. 

  587.     //prepare a BIG FFT stuff

  588.     FFTwrapper *fft      = new FFTwrapper(samplesize);

  589.     fft_t      *fftfreqs = new fft_t[samplesize / 2];

  590. 

  591.     float adj[samplemax]; //this is used to compute frequency relation to the base frequency

  592.     for(int nsample = 0; nsample < samplemax; ++nsample)

  593.         adj[nsample] = (Pquality.oct + 1.0f) * (float)nsample / samplemax;

  594.     for(int nsample = 0; nsample < samplemax; ++nsample) {

  595.         float tmp = adj[nsample] - adj[samplemax - 1] * 0.5f;

  596.         float basefreqadjust = powf(2.0f, tmp);

  597. 

  598.         if(Pmode == 0)

  599.             generatespectrum_bandwidthMode(spectrum,

  600.                                            spectrumsize,

  601.                                            basefreq * basefreqadjust,

  602.                                            profile,

  603.                                            profilesize,

  604.                                            bwadjust);

  605.         else

  606.             generatespectrum_otherModes(spectrum, spectrumsize,

  607.                                         basefreq * basefreqadjust);

  608. 

  609.         const int extra_samples = 5; //the last samples contains the first samples (used for linear/cubic interpolation)

  610.         newsample.smp = new float[samplesize + extra_samples];

  611. 

  612.         newsample.smp[0] = 0.0f;

  613.         for(int i = 1; i < spectrumsize; ++i) //randomize the phases

  614.             fftfreqs[i] = std::polar(spectrum[i], (float)RND * 6.29f);

  615.         fft->freqs2smps(fftfreqs, newsample.smp); //that's all; here is the only ifft for the whole sample; no windows are used ;-)

  616. 

  617. 

  618.         //normalize(rms)

  619.         float rms = 0.0f;

  620.         for(int i = 0; i < samplesize; ++i)

  621.             rms += newsample.smp[i] * newsample.smp[i];

  622.         rms = sqrt(rms);

  623.         if(rms < 0.000001f)

  624.             rms = 1.0f;

  625.         rms *= sqrt(262144.0f / samplesize);

  626.         for(int i = 0; i < samplesize; ++i)

  627.             newsample.smp[i] *= 1.0f / rms * 50.0f;

  628. 

  629.         //prepare extra samples used by the linear or cubic interpolation

  630.         for(int i = 0; i < extra_samples; ++i)

  631.             newsample.smp[i + samplesize] = newsample.smp[i];

  632. 

  633.         //replace the current sample with the new computed sample

  634.         if(lockmutex) {

  635.             pthread_mutex_lock(mutex);

  636.             deletesample(nsample);

  637.             sample[nsample].smp      = newsample.smp;

  638.             sample[nsample].size     = samplesize;

  639.             sample[nsample].basefreq = basefreq * basefreqadjust;

  640.             pthread_mutex_unlock(mutex);

  641.         }

  642.         else {

  643.             deletesample(nsample);

  644.             sample[nsample].smp      = newsample.smp;

  645.             sample[nsample].size     = samplesize;

  646.             sample[nsample].basefreq = basefreq * basefreqadjust;

  647.         }

  648.         newsample.smp = NULL;

  649.     }

  650.     delete (fft);

  651.     delete[] fftfreqs;

  652. 

  653.     //delete the additional samples that might exists and are not useful

  654.     if(lockmutex) {

  655.         pthread_mutex_lock(mutex);

  656.         for(int i = samplemax; i < PAD_MAX_SAMPLES; ++i)

  657.             deletesample(i);

  658.         pthread_mutex_unlock(mutex);

  659.     }

  660.     else

  661.         for(int i = samplemax; i < PAD_MAX_SAMPLES; ++i)

  662.             deletesample(i);

  663.     ;

  664. }

  665. 

  666. void PADnoteParameters::export2wav(std::string basefilename)

  667. {

  668.     applyparameters(true);

  669.     basefilename += "_PADsynth_";

  670.     for(int k = 0; k < PAD_MAX_SAMPLES; ++k) {

  671.         if(sample[k].smp == NULL)

  672.             continue;

  673.         char tmpstr[20];

  674.         snprintf(tmpstr, 20, "_%02d", k + 1);

  675.         std::string filename = basefilename + std::string(tmpstr) + ".wav";

  676.         WavFile     wav(filename, synth->samplerate, 1);

  677.         if(wav.good()) {

  678.             int nsmps = sample[k].size;

  679.             short int *smps = new short int[nsmps];

  680.             for(int i = 0; i < nsmps; ++i)

  681.                 smps[i] = (short int)(sample[k].smp[i] * 32767.0f);

  682.             wav.writeMonoSamples(nsmps, smps);

  683.         }

  684.     }

  685. }

  686. 

  687. void PADnoteParameters::add2XML(XMLwrapper *xml)

  688. {

  689.     xml->setPadSynth(true);

  690. 

  691.     xml->addparbool("stereo", PStereo);

  692.     xml->addpar("mode", Pmode);

  693.     xml->addpar("bandwidth", Pbandwidth);

  694.     xml->addpar("bandwidth_scale", Pbwscale);

  695. 

  696.     xml->beginbranch("HARMONIC_PROFILE");

  697.     xml->addpar("base_type", Php.base.type);

  698.     xml->addpar("base_par1", Php.base.par1);

  699.     xml->addpar("frequency_multiplier", Php.freqmult);

  700.     xml->addpar("modulator_par1", Php.modulator.par1);

  701.     xml->addpar("modulator_frequency", Php.modulator.freq);

  702.     xml->addpar("width", Php.width);

  703.     xml->addpar("amplitude_multiplier_type", Php.amp.type);

  704.     xml->addpar("amplitude_multiplier_mode", Php.amp.mode);

  705.     xml->addpar("amplitude_multiplier_par1", Php.amp.par1);

  706.     xml->addpar("amplitude_multiplier_par2", Php.amp.par2);

  707.     xml->addparbool("autoscale", Php.autoscale);

  708.     xml->addpar("one_half", Php.onehalf);

  709.     xml->endbranch();

  710. 

  711.     xml->beginbranch("OSCIL");

  712.     oscilgen->add2XML(xml);

  713.     xml->endbranch();

  714. 

  715.     xml->beginbranch("RESONANCE");

  716.     resonance->add2XML(xml);

  717.     xml->endbranch();

  718. 

  719.     xml->beginbranch("HARMONIC_POSITION");

  720.     xml->addpar("type", Phrpos.type);

  721.     xml->addpar("parameter1", Phrpos.par1);

  722.     xml->addpar("parameter2", Phrpos.par2);

  723.     xml->addpar("parameter3", Phrpos.par3);

  724.     xml->endbranch();

  725. 

  726.     xml->beginbranch("SAMPLE_QUALITY");

  727.     xml->addpar("samplesize", Pquality.samplesize);

  728.     xml->addpar("basenote", Pquality.basenote);

  729.     xml->addpar("octaves", Pquality.oct);

  730.     xml->addpar("samples_per_octave", Pquality.smpoct);

  731.     xml->endbranch();

  732. 

  733.     xml->beginbranch("AMPLITUDE_PARAMETERS");

  734.     xml->addpar("volume", PVolume);

  735.     xml->addpar("panning", PPanning);

  736.     xml->addpar("velocity_sensing", PAmpVelocityScaleFunction);

  737.     xml->addpar("punch_strength", PPunchStrength);

  738.     xml->addpar("punch_time", PPunchTime);

  739.     xml->addpar("punch_stretch", PPunchStretch);

  740.     xml->addpar("punch_velocity_sensing", PPunchVelocitySensing);

  741. 

  742.     xml->beginbranch("AMPLITUDE_ENVELOPE");

  743.     AmpEnvelope->add2XML(xml);

  744.     xml->endbranch();

  745. 

  746.     xml->beginbranch("AMPLITUDE_LFO");

  747.     AmpLfo->add2XML(xml);

  748.     xml->endbranch();

  749. 

  750.     xml->endbranch();

  751. 

  752.     xml->beginbranch("FREQUENCY_PARAMETERS");

  753.     xml->addpar("fixed_freq", Pfixedfreq);

  754.     xml->addpar("fixed_freq_et", PfixedfreqET);

  755.     xml->addpar("detune", PDetune);

  756.     xml->addpar("coarse_detune", PCoarseDetune);

  757.     xml->addpar("detune_type", PDetuneType);

  758. 

  759.     xml->beginbranch("FREQUENCY_ENVELOPE");

  760.     FreqEnvelope->add2XML(xml);

  761.     xml->endbranch();

  762. 

  763.     xml->beginbranch("FREQUENCY_LFO");

  764.     FreqLfo->add2XML(xml);

  765.     xml->endbranch();

  766.     xml->endbranch();

  767. 

  768.     xml->beginbranch("FILTER_PARAMETERS");

  769.     xml->addpar("velocity_sensing_amplitude", PFilterVelocityScale);

  770.     xml->addpar("velocity_sensing", PFilterVelocityScaleFunction);

  771. 

  772.     xml->beginbranch("FILTER");

  773.     GlobalFilter->add2XML(xml);

  774.     xml->endbranch();

  775. 

  776.     xml->beginbranch("FILTER_ENVELOPE");

  777.     FilterEnvelope->add2XML(xml);

  778.     xml->endbranch();

  779. 

  780.     xml->beginbranch("FILTER_LFO");

  781.     FilterLfo->add2XML(xml);

  782.     xml->endbranch();

  783.     xml->endbranch();

  784. }

  785. 

  786. void PADnoteParameters::getfromXML(XMLwrapper *xml)

  787. {

  788.     PStereo    = xml->getparbool("stereo", PStereo);

  789.     Pmode      = xml->getpar127("mode", 0);

  790.     Pbandwidth = xml->getpar("bandwidth", Pbandwidth, 0, 1000);

  791.     Pbwscale   = xml->getpar127("bandwidth_scale", Pbwscale);

  792. 

  793.     if(xml->enterbranch("HARMONIC_PROFILE")) {

  794.         Php.base.type = xml->getpar127("base_type", Php.base.type);

  795.         Php.base.par1 = xml->getpar127("base_par1", Php.base.par1);

  796.         Php.freqmult  = xml->getpar127("frequency_multiplier",

  797.                                        Php.freqmult);

  798.         Php.modulator.par1 = xml->getpar127("modulator_par1",

  799.                                             Php.modulator.par1);

  800.         Php.modulator.freq = xml->getpar127("modulator_frequency",

  801.                                             Php.modulator.freq);

  802.         Php.width    = xml->getpar127("width", Php.width);

  803.         Php.amp.type = xml->getpar127("amplitude_multiplier_type",

  804.                                       Php.amp.type);

  805.         Php.amp.mode = xml->getpar127("amplitude_multiplier_mode",

  806.                                       Php.amp.mode);

  807.         Php.amp.par1 = xml->getpar127("amplitude_multiplier_par1",

  808.                                       Php.amp.par1);

  809.         Php.amp.par2 = xml->getpar127("amplitude_multiplier_par2",

  810.                                       Php.amp.par2);

  811.         Php.autoscale = xml->getparbool("autoscale", Php.autoscale);

  812.         Php.onehalf   = xml->getpar127("one_half", Php.onehalf);

  813.         xml->exitbranch();

  814.     }

  815. 

  816.     if(xml->enterbranch("OSCIL")) {

  817.         oscilgen->getfromXML(xml);

  818.         xml->exitbranch();

  819.     }

  820. 

  821.     if(xml->enterbranch("RESONANCE")) {

  822.         resonance->getfromXML(xml);

  823.         xml->exitbranch();

  824.     }

  825. 

  826.     if(xml->enterbranch("HARMONIC_POSITION")) {

  827.         Phrpos.type = xml->getpar127("type", Phrpos.type);

  828.         Phrpos.par1 = xml->getpar("parameter1", Phrpos.par1, 0, 255);

  829.         Phrpos.par2 = xml->getpar("parameter2", Phrpos.par2, 0, 255);

  830.         Phrpos.par3 = xml->getpar("parameter3", Phrpos.par3, 0, 255);

  831.         xml->exitbranch();

  832.     }

  833. 

  834.     if(xml->enterbranch("SAMPLE_QUALITY")) {

  835.         Pquality.samplesize = xml->getpar127("samplesize", Pquality.samplesize);

  836.         Pquality.basenote   = xml->getpar127("basenote", Pquality.basenote);

  837.         Pquality.oct    = xml->getpar127("octaves", Pquality.oct);

  838.         Pquality.smpoct = xml->getpar127("samples_per_octave",

  839.                                          Pquality.smpoct);

  840.         xml->exitbranch();

  841.     }

  842. 

  843.     if(xml->enterbranch("AMPLITUDE_PARAMETERS")) {

  844.         PVolume  = xml->getpar127("volume", PVolume);

  845.         PPanning = xml->getpar127("panning", PPanning);

  846.         PAmpVelocityScaleFunction = xml->getpar127("velocity_sensing",

  847.                                                    PAmpVelocityScaleFunction);

  848.         PPunchStrength = xml->getpar127("punch_strength", PPunchStrength);

  849.         PPunchTime     = xml->getpar127("punch_time", PPunchTime);

  850.         PPunchStretch  = xml->getpar127("punch_stretch", PPunchStretch);

  851.         PPunchVelocitySensing = xml->getpar127("punch_velocity_sensing",

  852.                                                PPunchVelocitySensing);

  853. 

  854.         xml->enterbranch("AMPLITUDE_ENVELOPE");

  855.         AmpEnvelope->getfromXML(xml);

  856.         xml->exitbranch();

  857. 

  858.         xml->enterbranch("AMPLITUDE_LFO");

  859.         AmpLfo->getfromXML(xml);

  860.         xml->exitbranch();

  861. 

  862.         xml->exitbranch();

  863.     }

  864. 

  865.     if(xml->enterbranch("FREQUENCY_PARAMETERS")) {

  866.         Pfixedfreq    = xml->getpar127("fixed_freq", Pfixedfreq);

  867.         PfixedfreqET  = xml->getpar127("fixed_freq_et", PfixedfreqET);

  868.         PDetune       = xml->getpar("detune", PDetune, 0, 16383);

  869.         PCoarseDetune = xml->getpar("coarse_detune", PCoarseDetune, 0, 16383);

  870.         PDetuneType   = xml->getpar127("detune_type", PDetuneType);

  871. 

  872.         xml->enterbranch("FREQUENCY_ENVELOPE");

  873.         FreqEnvelope->getfromXML(xml);

  874.         xml->exitbranch();

  875. 

  876.         xml->enterbranch("FREQUENCY_LFO");

  877.         FreqLfo->getfromXML(xml);

  878.         xml->exitbranch();

  879.         xml->exitbranch();

  880.     }

  881. 

  882.     if(xml->enterbranch("FILTER_PARAMETERS")) {

  883.         PFilterVelocityScale = xml->getpar127("velocity_sensing_amplitude",

  884.                                               PFilterVelocityScale);

  885.         PFilterVelocityScaleFunction = xml->getpar127(

  886.             "velocity_sensing",

  887.             PFilterVelocityScaleFunction);

  888. 

  889.         xml->enterbranch("FILTER");

  890.         GlobalFilter->getfromXML(xml);

  891.         xml->exitbranch();

  892. 

  893.         xml->enterbranch("FILTER_ENVELOPE");

  894.         FilterEnvelope->getfromXML(xml);

  895.         xml->exitbranch();

  896. 

  897.         xml->enterbranch("FILTER_LFO");

  898.         FilterLfo->getfromXML(xml);

  899.         xml->exitbranch();

  900.         xml->exitbranch();

  901.     }

  902. }