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.
65 Commits
16 Branches
16GB
Tree: a5dcf3cb80
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a5dcf3cb80'
${ noResults }
Carla/source/backend/native/zynaddsubfx/Synth/ADnote.cpp

1803 lines
65KB
Raw Blame History 

  1. /*

  2.   ZynAddSubFX - a software synthesizer

  3. 

  4.   ADnote.cpp - The "additive" synthesizer

  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 <cmath>

  23. #include <cstdlib>

  24. #include <cstdio>

  25. #include <cstring>

  26. 

  27. #include "../globals.h"

  28. #include "../Misc/Util.h"

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

  30. #include "OscilGen.h"

  31. #include "ADnote.h"

  32. 

  33. 

  34. ADnote::ADnote(ADnoteParameters *pars,

  35.                Controller *ctl_,

  36.                float freq,

  37.                float velocity,

  38.                int portamento_,

  39.                int midinote_,

  40.                bool besilent)

  41.     :SynthNote(freq, velocity, portamento_, midinote, besilent)

  42. {

  43.     tmpwavel = new float [synth->buffersize];

  44.     tmpwaver = new float [synth->buffersize];

  45.     bypassl  = new float [synth->buffersize];

  46.     bypassr  = new float [synth->buffersize];

  47. 

  48.     partparams = pars;

  49.     ctl = ctl_;

  50.     portamento  = portamento_;

  51.     midinote    = midinote_;

  52.     NoteEnabled = ON;

  53.     basefreq    = freq;

  54.     if(velocity > 1.0f)

  55.         velocity = 1.0f;

  56.     this->velocity = velocity;

  57.     time   = 0.0f;

  58.     stereo = pars->GlobalPar.PStereo;

  59. 

  60.     NoteGlobalPar.Detune = getdetune(pars->GlobalPar.PDetuneType,

  61.                                      pars->GlobalPar.PCoarseDetune,

  62.                                      pars->GlobalPar.PDetune);

  63.     bandwidthDetuneMultiplier = pars->getBandwidthDetuneMultiplier();

  64. 

  65.     if(pars->GlobalPar.PPanning == 0)

  66.         NoteGlobalPar.Panning = RND;

  67.     else

  68.         NoteGlobalPar.Panning = pars->GlobalPar.PPanning / 128.0f;

  69. 

  70. 

  71.     NoteGlobalPar.FilterCenterPitch = pars->GlobalPar.GlobalFilter->getfreq() //center freq

  72.                                       + pars->GlobalPar.PFilterVelocityScale

  73.                                       / 127.0f * 6.0f                                  //velocity sensing

  74.                                       * (VelF(velocity,

  75.                                               pars->GlobalPar.

  76.                                               PFilterVelocityScaleFunction) - 1);

  77. 

  78.     if(pars->GlobalPar.PPunchStrength != 0) {

  79.         NoteGlobalPar.Punch.Enabled = 1;

  80.         NoteGlobalPar.Punch.t = 1.0f; //start from 1.0f and to 0.0f

  81.         NoteGlobalPar.Punch.initialvalue =

  82.             ((powf(10, 1.5f * pars->GlobalPar.PPunchStrength / 127.0f) - 1.0f)

  83.              * VelF(velocity,

  84.                     pars->GlobalPar.PPunchVelocitySensing));

  85.         float time =

  86.             powf(10, 3.0f * pars->GlobalPar.PPunchTime / 127.0f) / 10000.0f;   //0.1f .. 100 ms

  87.         float stretch = powf(440.0f / freq,

  88.                              pars->GlobalPar.PPunchStretch / 64.0f);

  89.         NoteGlobalPar.Punch.dt = 1.0f / (time * synth->samplerate_f * stretch);

  90.     }

  91.     else

  92.         NoteGlobalPar.Punch.Enabled = 0;

  93. 

  94.     for(int nvoice = 0; nvoice < NUM_VOICES; ++nvoice) {

  95.         pars->VoicePar[nvoice].OscilSmp->newrandseed(prng());

  96.         NoteVoicePar[nvoice].OscilSmp = NULL;

  97.         NoteVoicePar[nvoice].FMSmp    = NULL;

  98.         NoteVoicePar[nvoice].VoiceOut = NULL;

  99. 

  100.         NoteVoicePar[nvoice].FMVoice = -1;

  101.         unison_size[nvoice] = 1;

  102. 

  103.         if(pars->VoicePar[nvoice].Enabled == 0) {

  104.             NoteVoicePar[nvoice].Enabled = OFF;

  105.             continue; //the voice is disabled

  106.         }

  107. 

  108.         unison_stereo_spread[nvoice] =

  109.             pars->VoicePar[nvoice].Unison_stereo_spread / 127.0f;

  110.         int unison = pars->VoicePar[nvoice].Unison_size;

  111.         if(unison < 1)

  112.             unison = 1;

  113. 

  114.         //compute unison

  115.         unison_size[nvoice] = unison;

  116. 

  117.         unison_base_freq_rap[nvoice] = new float[unison];

  118.         unison_freq_rap[nvoice]      = new float[unison];

  119.         unison_invert_phase[nvoice]  = new bool[unison];

  120.         float unison_spread = pars->getUnisonFrequencySpreadCents(

  121.             nvoice);

  122.         float unison_real_spread = powf(2.0f, (unison_spread * 0.5f) / 1200.0f);

  123.         float unison_vibratto_a  = pars->VoicePar[nvoice].Unison_vibratto

  124.                                    / 127.0f;                                     //0.0f .. 1.0f

  125. 

  126. 

  127.         switch(unison) {

  128.             case 1:

  129.                 unison_base_freq_rap[nvoice][0] = 1.0f; //if the unison is not used, always make the only subvoice to have the default note

  130.                 break;

  131.             case 2: { //unison for 2 subvoices

  132.                 unison_base_freq_rap[nvoice][0] = 1.0f / unison_real_spread;

  133.                 unison_base_freq_rap[nvoice][1] = unison_real_spread;

  134.             };

  135.                 break;

  136.             default: { //unison for more than 2 subvoices

  137.                 float unison_values[unison];

  138.                 float min = -1e-6, max = 1e-6;

  139.                 for(int k = 0; k < unison; ++k) {

  140.                     float step = (k / (float) (unison - 1)) * 2.0f - 1.0f; //this makes the unison spread more uniform

  141.                     float val  = step + (RND * 2.0f - 1.0f) / (unison - 1);

  142.                     unison_values[k] = limit(val, min, max);

  143.                 }

  144.                 float diff = max - min;

  145.                 for(int k = 0; k < unison; ++k) {

  146.                     unison_values[k] =

  147.                         (unison_values[k] - (max + min) * 0.5f) / diff;             //the lowest value will be -1 and the highest will be 1

  148.                     unison_base_freq_rap[nvoice][k] =

  149.                         powf(2.0f, (unison_spread * unison_values[k]) / 1200);

  150.                 }

  151.             };

  152.         }

  153. 

  154.         //unison vibrattos

  155.         if(unison > 1)

  156.             for(int k = 0; k < unison; ++k) //reduce the frequency difference for larger vibrattos

  157.                 unison_base_freq_rap[nvoice][k] = 1.0f

  158.                                                   + (unison_base_freq_rap[

  159.                                                          nvoice][k] - 1.0f)

  160.                                                   * (1.0f - unison_vibratto_a);

  161.         unison_vibratto[nvoice].step      = new float[unison];

  162.         unison_vibratto[nvoice].position  = new float[unison];

  163.         unison_vibratto[nvoice].amplitude =

  164.             (unison_real_spread - 1.0f) * unison_vibratto_a;

  165. 

  166.         float increments_per_second = synth->samplerate_f / synth->buffersize_f;

  167.         float vibratto_base_period  = 0.25f

  168.                                       * powf(

  169.             2.0f,

  170.             (1.0f

  171.              - pars->VoicePar[nvoice].

  172.              Unison_vibratto_speed

  173.              / 127.0f) * 4.0f);

  174.         for(int k = 0; k < unison; ++k) {

  175.             unison_vibratto[nvoice].position[k] = RND * 1.8f - 0.9f;

  176.             //make period to vary randomly from 50% to 200% vibratto base period

  177.             float vibratto_period = vibratto_base_period

  178.                                     * powf(2.0f, RND * 2.0f - 1.0f);

  179. 

  180.             float m = 4.0f / (vibratto_period * increments_per_second);

  181.             if(RND < 0.5f)

  182.                 m = -m;

  183.             unison_vibratto[nvoice].step[k] = m;

  184.         }

  185. 

  186.         if(unison == 1) { //no vibratto for a single voice

  187.             unison_vibratto[nvoice].step[0]     = 0.0f;

  188.             unison_vibratto[nvoice].position[0] = 0.0f;

  189.             unison_vibratto[nvoice].amplitude   = 0.0f;

  190.         }

  191. 

  192.         //phase invert for unison

  193.         unison_invert_phase[nvoice][0] = false;

  194.         if(unison != 1) {

  195.             int inv = pars->VoicePar[nvoice].Unison_invert_phase;

  196.             switch(inv) {

  197.                 case 0: for(int k = 0; k < unison; ++k)

  198.                         unison_invert_phase[nvoice][k] = false;

  199.                     break;

  200.                 case 1: for(int k = 0; k < unison; ++k)

  201.                         unison_invert_phase[nvoice][k] = (RND > 0.5f);

  202.                     break;

  203.                 default: for(int k = 0; k < unison; ++k)

  204.                         unison_invert_phase[nvoice][k] =

  205.                             (k % inv == 0) ? true : false;

  206.                     break;

  207.             }

  208.         }

  209. 

  210. 

  211.         oscfreqhi[nvoice]   = new int[unison];

  212.         oscfreqlo[nvoice]   = new float[unison];

  213.         oscfreqhiFM[nvoice] = new unsigned int[unison];

  214.         oscfreqloFM[nvoice] = new float[unison];

  215.         oscposhi[nvoice]    = new int[unison];

  216.         oscposlo[nvoice]    = new float[unison];

  217.         oscposhiFM[nvoice]  = new unsigned int[unison];

  218.         oscposloFM[nvoice]  = new float[unison];

  219. 

  220.         NoteVoicePar[nvoice].Enabled     = ON;

  221.         NoteVoicePar[nvoice].fixedfreq   = pars->VoicePar[nvoice].Pfixedfreq;

  222.         NoteVoicePar[nvoice].fixedfreqET = pars->VoicePar[nvoice].PfixedfreqET;

  223. 

  224.         //use the Globalpars.detunetype if the detunetype is 0

  225.         if(pars->VoicePar[nvoice].PDetuneType != 0) {

  226.             NoteVoicePar[nvoice].Detune = getdetune(

  227.                 pars->VoicePar[nvoice].PDetuneType,

  228.                 pars->VoicePar[nvoice].

  229.                 PCoarseDetune,

  230.                 8192); //coarse detune

  231.             NoteVoicePar[nvoice].FineDetune = getdetune(

  232.                 pars->VoicePar[nvoice].PDetuneType,

  233.                 0,

  234.                 pars->VoicePar[nvoice].PDetune); //fine detune

  235.         }

  236.         else {

  237.             NoteVoicePar[nvoice].Detune = getdetune(

  238.                 pars->GlobalPar.PDetuneType,

  239.                 pars->VoicePar[nvoice].

  240.                 PCoarseDetune,

  241.                 8192); //coarse detune

  242.             NoteVoicePar[nvoice].FineDetune = getdetune(

  243.                 pars->GlobalPar.PDetuneType,

  244.                 0,

  245.                 pars->VoicePar[nvoice].PDetune); //fine detune

  246.         }

  247.         if(pars->VoicePar[nvoice].PFMDetuneType != 0)

  248.             NoteVoicePar[nvoice].FMDetune = getdetune(

  249.                 pars->VoicePar[nvoice].PFMDetuneType,

  250.                 pars->VoicePar[nvoice].

  251.                 PFMCoarseDetune,

  252.                 pars->VoicePar[nvoice].PFMDetune);

  253.         else

  254.             NoteVoicePar[nvoice].FMDetune = getdetune(

  255.                 pars->GlobalPar.PDetuneType,

  256.                 pars->VoicePar[nvoice].

  257.                 PFMCoarseDetune,

  258.                 pars->VoicePar[nvoice].PFMDetune);

  259. 

  260. 

  261. 

  262.         for(int k = 0; k < unison; ++k) {

  263.             oscposhi[nvoice][k]   = 0;

  264.             oscposlo[nvoice][k]   = 0.0f;

  265.             oscposhiFM[nvoice][k] = 0;

  266.             oscposloFM[nvoice][k] = 0.0f;

  267.         }

  268. 

  269.         //the extra points contains the first point

  270.         NoteVoicePar[nvoice].OscilSmp =

  271.             new float[synth->oscilsize + OSCIL_SMP_EXTRA_SAMPLES];

  272. 

  273.         //Get the voice's oscil or external's voice oscil

  274.         int vc = nvoice;

  275.         if(pars->VoicePar[nvoice].Pextoscil != -1)

  276.             vc = pars->VoicePar[nvoice].Pextoscil;

  277.         if(!pars->GlobalPar.Hrandgrouping)

  278.             pars->VoicePar[vc].OscilSmp->newrandseed(prng());

  279.         int oscposhi_start =

  280.             pars->VoicePar[vc].OscilSmp->get(NoteVoicePar[nvoice].OscilSmp,

  281.                                              getvoicebasefreq(nvoice),

  282.                                              pars->VoicePar[nvoice].Presonance);

  283. 

  284.         //I store the first elments to the last position for speedups

  285.         for(int i = 0; i < OSCIL_SMP_EXTRA_SAMPLES; ++i)

  286.             NoteVoicePar[nvoice].OscilSmp[synth->oscilsize

  287.                                           + i] =

  288.                 NoteVoicePar[nvoice].OscilSmp[i];

  289. 

  290.         oscposhi_start +=

  291.             (int)((pars->VoicePar[nvoice].Poscilphase

  292.                    - 64.0f) / 128.0f * synth->oscilsize + synth->oscilsize * 4);

  293.         oscposhi_start %= synth->oscilsize;

  294. 

  295.         for(int k = 0; k < unison; ++k) {

  296.             oscposhi[nvoice][k] = oscposhi_start;

  297.             oscposhi_start      = (int)(RND * (synth->oscilsize - 1)); //put random starting point for other subvoices

  298.         }

  299. 

  300.         NoteVoicePar[nvoice].FreqLfo      = NULL;

  301.         NoteVoicePar[nvoice].FreqEnvelope = NULL;

  302. 

  303.         NoteVoicePar[nvoice].AmpLfo      = NULL;

  304.         NoteVoicePar[nvoice].AmpEnvelope = NULL;

  305. 

  306.         NoteVoicePar[nvoice].VoiceFilterL   = NULL;

  307.         NoteVoicePar[nvoice].VoiceFilterR   = NULL;

  308.         NoteVoicePar[nvoice].FilterEnvelope = NULL;

  309.         NoteVoicePar[nvoice].FilterLfo      = NULL;

  310. 

  311.         NoteVoicePar[nvoice].FilterCenterPitch =

  312.             pars->VoicePar[nvoice].VoiceFilter->getfreq();

  313.         NoteVoicePar[nvoice].filterbypass =

  314.             pars->VoicePar[nvoice].Pfilterbypass;

  315. 

  316.         switch(pars->VoicePar[nvoice].PFMEnabled) {

  317.             case 1:

  318.                 NoteVoicePar[nvoice].FMEnabled = MORPH;

  319.                 break;

  320.             case 2:

  321.                 NoteVoicePar[nvoice].FMEnabled = RING_MOD;

  322.                 break;

  323.             case 3:

  324.                 NoteVoicePar[nvoice].FMEnabled = PHASE_MOD;

  325.                 break;

  326.             case 4:

  327.                 NoteVoicePar[nvoice].FMEnabled = FREQ_MOD;

  328.                 break;

  329.             case 5:

  330.                 NoteVoicePar[nvoice].FMEnabled = PITCH_MOD;

  331.                 break;

  332.             default:

  333.                 NoteVoicePar[nvoice].FMEnabled = NONE;

  334.         }

  335. 

  336.         NoteVoicePar[nvoice].FMVoice = pars->VoicePar[nvoice].PFMVoice;

  337.         NoteVoicePar[nvoice].FMFreqEnvelope = NULL;

  338.         NoteVoicePar[nvoice].FMAmpEnvelope  = NULL;

  339. 

  340.         //Compute the Voice's modulator volume (incl. damping)

  341.         float fmvoldamp = powf(440.0f / getvoicebasefreq(

  342.                                    nvoice),

  343.                                pars->VoicePar[nvoice].PFMVolumeDamp / 64.0f

  344.                                - 1.0f);

  345.         switch(NoteVoicePar[nvoice].FMEnabled) {

  346.             case PHASE_MOD:

  347.                 fmvoldamp =

  348.                     powf(440.0f / getvoicebasefreq(

  349.                              nvoice), pars->VoicePar[nvoice].PFMVolumeDamp

  350.                          / 64.0f);

  351.                 NoteVoicePar[nvoice].FMVolume =

  352.                     (expf(pars->VoicePar[nvoice].PFMVolume / 127.0f

  353.                           * FM_AMP_MULTIPLIER) - 1.0f) * fmvoldamp * 4.0f;

  354.                 break;

  355.             case FREQ_MOD:

  356.                 NoteVoicePar[nvoice].FMVolume =

  357.                     (expf(pars->VoicePar[nvoice].PFMVolume / 127.0f

  358.                           * FM_AMP_MULTIPLIER) - 1.0f) * fmvoldamp * 4.0f;

  359.                 break;

  360.             //    case PITCH_MOD:NoteVoicePar[nvoice].FMVolume=(pars->VoicePar[nvoice].PFMVolume/127.0f*8.0f)*fmvoldamp;//???????????

  361.             //	          break;

  362.             default:

  363.                 if(fmvoldamp > 1.0f)

  364.                     fmvoldamp = 1.0f;

  365.                 NoteVoicePar[nvoice].FMVolume =

  366.                     pars->VoicePar[nvoice].PFMVolume

  367.                     / 127.0f * fmvoldamp;

  368.         }

  369. 

  370.         //Voice's modulator velocity sensing

  371.         NoteVoicePar[nvoice].FMVolume *=

  372.             VelF(velocity,

  373.                  partparams->VoicePar[nvoice].PFMVelocityScaleFunction);

  374. 

  375.         FMoldsmp[nvoice] = new float [unison];

  376.         for(int k = 0; k < unison; ++k)

  377.             FMoldsmp[nvoice][k] = 0.0f;                     //this is for FM (integration)

  378. 

  379.         firsttick[nvoice] = 1;

  380.         NoteVoicePar[nvoice].DelayTicks =

  381.             (int)((expf(pars->VoicePar[nvoice].PDelay / 127.0f

  382.                         * logf(50.0f))

  383.                    - 1.0f) / synth->buffersize_f / 10.0f * synth->samplerate_f);

  384.     }

  385. 

  386.     max_unison = 1;

  387.     for(int nvoice = 0; nvoice < NUM_VOICES; ++nvoice)

  388.         if(unison_size[nvoice] > max_unison)

  389.             max_unison = unison_size[nvoice];

  390. 

  391. 

  392.     tmpwave_unison = new float *[max_unison];

  393.     for(int k = 0; k < max_unison; ++k) {

  394.         tmpwave_unison[k] = new float[synth->buffersize];

  395.         memset(tmpwave_unison[k], 0, synth->bufferbytes);

  396.     }

  397. 

  398.     initparameters();

  399. }

  400. 

  401. // ADlegatonote: This function is (mostly) a copy of ADnote(...) and

  402. // initparameters() stuck together with some lines removed so that it

  403. // only alter the already playing note (to perform legato). It is

  404. // possible I left stuff that is not required for this.

  405. void ADnote::legatonote(float freq, float velocity, int portamento_,

  406.                         int midinote_, bool externcall)

  407. {

  408.     ADnoteParameters *pars = partparams;

  409. 

  410.     // Manage legato stuff

  411.     if(legato.update(freq, velocity, portamento_, midinote_, externcall))

  412.         return;

  413. 

  414.     portamento = portamento_;

  415.     midinote   = midinote_;

  416.     basefreq   = freq;

  417. 

  418.     if(velocity > 1.0f)

  419.         velocity = 1.0f;

  420.     this->velocity = velocity;

  421. 

  422.     NoteGlobalPar.Detune = getdetune(pars->GlobalPar.PDetuneType,

  423.                                      pars->GlobalPar.PCoarseDetune,

  424.                                      pars->GlobalPar.PDetune);

  425.     bandwidthDetuneMultiplier = pars->getBandwidthDetuneMultiplier();

  426. 

  427.     if(pars->GlobalPar.PPanning == 0)

  428.         NoteGlobalPar.Panning = RND;

  429.     else

  430.         NoteGlobalPar.Panning = pars->GlobalPar.PPanning / 128.0f;

  431. 

  432.     //center freq

  433.     NoteGlobalPar.FilterCenterPitch = pars->GlobalPar.GlobalFilter->getfreq()

  434.                                       + pars->GlobalPar.PFilterVelocityScale

  435.                                       / 127.0f * 6.0f          //velocity sensing

  436.                                       * (VelF(velocity,

  437.                                               pars->GlobalPar.

  438.                                               PFilterVelocityScaleFunction) - 1);

  439. 

  440. 

  441.     for(int nvoice = 0; nvoice < NUM_VOICES; ++nvoice) {

  442.         if(NoteVoicePar[nvoice].Enabled == OFF)

  443.             continue;  //(gf) Stay the same as first note in legato.

  444. 

  445.         NoteVoicePar[nvoice].fixedfreq   = pars->VoicePar[nvoice].Pfixedfreq;

  446.         NoteVoicePar[nvoice].fixedfreqET = pars->VoicePar[nvoice].PfixedfreqET;

  447. 

  448.         //use the Globalpars.detunetype if the detunetype is 0

  449.         if(pars->VoicePar[nvoice].PDetuneType != 0) {

  450.             NoteVoicePar[nvoice].Detune = getdetune(

  451.                 pars->VoicePar[nvoice].PDetuneType,

  452.                 pars->VoicePar[nvoice].PCoarseDetune,

  453.                 8192); //coarse detune

  454.             NoteVoicePar[nvoice].FineDetune = getdetune(

  455.                 pars->VoicePar[nvoice].PDetuneType,

  456.                 0,

  457.                 pars->VoicePar[nvoice].PDetune); //fine detune

  458.         }

  459.         else {

  460.             NoteVoicePar[nvoice].Detune = getdetune(

  461.                 pars->GlobalPar.PDetuneType,

  462.                 pars->VoicePar[nvoice].PCoarseDetune,

  463.                 8192); //coarse detune

  464.             NoteVoicePar[nvoice].FineDetune = getdetune(

  465.                 pars->GlobalPar.PDetuneType,

  466.                 0,

  467.                 pars->VoicePar[nvoice].PDetune); //fine detune

  468.         }

  469.         if(pars->VoicePar[nvoice].PFMDetuneType != 0)

  470.             NoteVoicePar[nvoice].FMDetune = getdetune(

  471.                 pars->VoicePar[nvoice].PFMDetuneType,

  472.                 pars->VoicePar[nvoice].PFMCoarseDetune,

  473.                 pars->VoicePar[nvoice].PFMDetune);

  474.         else

  475.             NoteVoicePar[nvoice].FMDetune = getdetune(

  476.                 pars->GlobalPar.PDetuneType,

  477.                 pars->VoicePar[nvoice].PFMCoarseDetune,

  478.                 pars->VoicePar[nvoice].PFMDetune);

  479. 

  480. 

  481.         //Get the voice's oscil or external's voice oscil

  482.         int vc = nvoice;

  483.         if(pars->VoicePar[nvoice].Pextoscil != -1)

  484.             vc = pars->VoicePar[nvoice].Pextoscil;

  485.         if(!pars->GlobalPar.Hrandgrouping)

  486.             pars->VoicePar[vc].OscilSmp->newrandseed(prng());

  487. 

  488.         pars->VoicePar[vc].OscilSmp->get(NoteVoicePar[nvoice].OscilSmp,

  489.                                          getvoicebasefreq(nvoice),

  490.                                          pars->VoicePar[nvoice].Presonance); //(gf)Modif of the above line.

  491. 

  492.         //I store the first elments to the last position for speedups

  493.         for(int i = 0; i < OSCIL_SMP_EXTRA_SAMPLES; ++i)

  494.             NoteVoicePar[nvoice].OscilSmp[synth->oscilsize

  495.                                           + i] =

  496.                 NoteVoicePar[nvoice].OscilSmp[i];

  497. 

  498. 

  499.         NoteVoicePar[nvoice].FilterCenterPitch =

  500.             pars->VoicePar[nvoice].VoiceFilter->getfreq();

  501.         NoteVoicePar[nvoice].filterbypass =

  502.             pars->VoicePar[nvoice].Pfilterbypass;

  503. 

  504. 

  505.         NoteVoicePar[nvoice].FMVoice = pars->VoicePar[nvoice].PFMVoice;

  506. 

  507.         //Compute the Voice's modulator volume (incl. damping)

  508.         float fmvoldamp = powf(440.0f / getvoicebasefreq(nvoice),

  509.                                pars->VoicePar[nvoice].PFMVolumeDamp / 64.0f

  510.                                - 1.0f);

  511. 

  512.         switch(NoteVoicePar[nvoice].FMEnabled) {

  513.             case PHASE_MOD:

  514.                 fmvoldamp =

  515.                     powf(440.0f / getvoicebasefreq(

  516.                              nvoice), pars->VoicePar[nvoice].PFMVolumeDamp

  517.                          / 64.0f);

  518.                 NoteVoicePar[nvoice].FMVolume =

  519.                     (expf(pars->VoicePar[nvoice].PFMVolume / 127.0f

  520.                           * FM_AMP_MULTIPLIER) - 1.0f) * fmvoldamp * 4.0f;

  521.                 break;

  522.             case FREQ_MOD:

  523.                 NoteVoicePar[nvoice].FMVolume =

  524.                     (expf(pars->VoicePar[nvoice].PFMVolume / 127.0f

  525.                           * FM_AMP_MULTIPLIER) - 1.0f) * fmvoldamp * 4.0f;

  526.                 break;

  527.             //    case PITCH_MOD:NoteVoicePar[nvoice].FMVolume=(pars->VoicePar[nvoice].PFMVolume/127.0f*8.0f)*fmvoldamp;//???????????

  528.             //	          break;

  529.             default:

  530.                 if(fmvoldamp > 1.0f)

  531.                     fmvoldamp = 1.0f;

  532.                 NoteVoicePar[nvoice].FMVolume =

  533.                     pars->VoicePar[nvoice].PFMVolume

  534.                     / 127.0f * fmvoldamp;

  535.         }

  536. 

  537.         //Voice's modulator velocity sensing

  538.         NoteVoicePar[nvoice].FMVolume *=

  539.             VelF(velocity,

  540.                  partparams->VoicePar[nvoice].PFMVelocityScaleFunction);

  541. 

  542.         NoteVoicePar[nvoice].DelayTicks =

  543.             (int)((expf(pars->VoicePar[nvoice].PDelay / 127.0f

  544.                         * logf(50.0f))

  545.                    - 1.0f) / synth->buffersize_f / 10.0f * synth->samplerate_f);

  546.     }

  547. 

  548.     ///    initparameters();

  549. 

  550.     ///////////////

  551.     // Altered content of initparameters():

  552. 

  553.     int tmp[NUM_VOICES];

  554. 

  555.     NoteGlobalPar.Volume = 4.0f

  556.                            * powf(0.1f, 3.0f

  557.                                   * (1.0f - partparams->GlobalPar.PVolume

  558.                                      / 96.0f))                                      //-60 dB .. 0 dB

  559.                            * VelF(

  560.         velocity,

  561.         partparams->GlobalPar.

  562.         PAmpVelocityScaleFunction);                                                      //velocity sensing

  563. 

  564.     globalnewamplitude = NoteGlobalPar.Volume

  565.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

  566.                          * NoteGlobalPar.AmpLfo->amplfoout();

  567. 

  568.     NoteGlobalPar.FilterQ = partparams->GlobalPar.GlobalFilter->getq();

  569.     NoteGlobalPar.FilterFreqTracking =

  570.         partparams->GlobalPar.GlobalFilter->getfreqtracking(basefreq);

  571. 

  572.     // Forbids the Modulation Voice to be greater or equal than voice

  573.     for(int i = 0; i < NUM_VOICES; ++i)

  574.         if(NoteVoicePar[i].FMVoice >= i)

  575.             NoteVoicePar[i].FMVoice = -1;

  576. 

  577.     // Voice Parameter init

  578.     for(unsigned nvoice = 0; nvoice < NUM_VOICES; ++nvoice) {

  579.         if(NoteVoicePar[nvoice].Enabled == 0)

  580.             continue;

  581. 

  582.         NoteVoicePar[nvoice].noisetype = partparams->VoicePar[nvoice].Type;

  583.         /* Voice Amplitude Parameters Init */

  584.         NoteVoicePar[nvoice].Volume =

  585.             powf(0.1f, 3.0f

  586.                  * (1.0f - partparams->VoicePar[nvoice].PVolume / 127.0f))             // -60 dB .. 0 dB

  587.             * VelF(velocity,

  588.                    partparams->VoicePar[nvoice].PAmpVelocityScaleFunction); //velocity

  589. 

  590.         if(partparams->VoicePar[nvoice].PVolumeminus != 0)

  591.             NoteVoicePar[nvoice].Volume = -NoteVoicePar[nvoice].Volume;

  592. 

  593.         if(partparams->VoicePar[nvoice].PPanning == 0)

  594.             NoteVoicePar[nvoice].Panning = RND;  // random panning

  595.         else

  596.             NoteVoicePar[nvoice].Panning =

  597.                 partparams->VoicePar[nvoice].PPanning / 128.0f;

  598. 

  599.         newamplitude[nvoice] = 1.0f;

  600.         if((partparams->VoicePar[nvoice].PAmpEnvelopeEnabled != 0)

  601.            && (NoteVoicePar[nvoice].AmpEnvelope != NULL))

  602.             newamplitude[nvoice] *= NoteVoicePar[nvoice].AmpEnvelope->envout_dB();

  603. 

  604. 

  605.         if((partparams->VoicePar[nvoice].PAmpLfoEnabled != 0)

  606.            && (NoteVoicePar[nvoice].AmpLfo != NULL))

  607.             newamplitude[nvoice] *= NoteVoicePar[nvoice].AmpLfo->amplfoout();

  608. 

  609. 

  610. 

  611.         NoteVoicePar[nvoice].FilterFreqTracking =

  612.             partparams->VoicePar[nvoice].VoiceFilter->getfreqtracking(basefreq);

  613. 

  614.         /* Voice Modulation Parameters Init */

  615.         if((NoteVoicePar[nvoice].FMEnabled != NONE)

  616.            && (NoteVoicePar[nvoice].FMVoice < 0)) {

  617.             partparams->VoicePar[nvoice].FMSmp->newrandseed(prng());

  618. 

  619.             //Perform Anti-aliasing only on MORPH or RING MODULATION

  620. 

  621.             int vc = nvoice;

  622.             if(partparams->VoicePar[nvoice].PextFMoscil != -1)

  623.                 vc = partparams->VoicePar[nvoice].PextFMoscil;

  624. 

  625.             if(!partparams->GlobalPar.Hrandgrouping)

  626.                 partparams->VoicePar[vc].FMSmp->newrandseed(prng());

  627. 

  628.             for(int i = 0; i < OSCIL_SMP_EXTRA_SAMPLES; ++i)

  629.                 NoteVoicePar[nvoice].FMSmp[synth->oscilsize + i] =

  630.                     NoteVoicePar[nvoice].FMSmp[i];

  631.         }

  632. 

  633.         FMnewamplitude[nvoice] = NoteVoicePar[nvoice].FMVolume

  634.                                  * ctl->fmamp.relamp;

  635. 

  636.         if((partparams->VoicePar[nvoice].PFMAmpEnvelopeEnabled != 0)

  637.            && (NoteVoicePar[nvoice].FMAmpEnvelope != NULL))

  638.             FMnewamplitude[nvoice] *=

  639.                 NoteVoicePar[nvoice].FMAmpEnvelope->envout_dB();

  640.     }

  641. 

  642.     for(int nvoice = 0; nvoice < NUM_VOICES; ++nvoice) {

  643.         for(unsigned i = nvoice + 1; i < NUM_VOICES; ++i)

  644.             tmp[i] = 0;

  645.         for(unsigned i = nvoice + 1; i < NUM_VOICES; ++i)

  646.             if((NoteVoicePar[i].FMVoice == nvoice) && (tmp[i] == 0))

  647.                 tmp[i] = 1;

  648.     }

  649. }

  650. 

  651. 

  652. /*

  653.  * Kill a voice of ADnote

  654.  */

  655. void ADnote::KillVoice(int nvoice)

  656. {

  657.     delete [] oscfreqhi[nvoice];

  658.     delete [] oscfreqlo[nvoice];

  659.     delete [] oscfreqhiFM[nvoice];

  660.     delete [] oscfreqloFM[nvoice];

  661.     delete [] oscposhi[nvoice];

  662.     delete [] oscposlo[nvoice];

  663.     delete [] oscposhiFM[nvoice];

  664.     delete [] oscposloFM[nvoice];

  665. 

  666.     delete [] unison_base_freq_rap[nvoice];

  667.     delete [] unison_freq_rap[nvoice];

  668.     delete [] unison_invert_phase[nvoice];

  669.     delete [] FMoldsmp[nvoice];

  670.     delete [] unison_vibratto[nvoice].step;

  671.     delete [] unison_vibratto[nvoice].position;

  672. 

  673.     NoteVoicePar[nvoice].kill();

  674. }

  675. 

  676. /*

  677.  * Kill the note

  678.  */

  679. void ADnote::KillNote()

  680. {

  681.     for(unsigned nvoice = 0; nvoice < NUM_VOICES; ++nvoice) {

  682.         if(NoteVoicePar[nvoice].Enabled == ON)

  683.             KillVoice(nvoice);

  684. 

  685.         if(NoteVoicePar[nvoice].VoiceOut)

  686.             delete NoteVoicePar[nvoice].VoiceOut;

  687.         NoteVoicePar[nvoice].VoiceOut = NULL;

  688.     }

  689. 

  690.     NoteGlobalPar.kill();

  691. 

  692.     NoteEnabled = OFF;

  693. }

  694. 

  695. ADnote::~ADnote()

  696. {

  697.     if(NoteEnabled == ON)

  698.         KillNote();

  699.     delete [] tmpwavel;

  700.     delete [] tmpwaver;

  701.     delete [] bypassl;

  702.     delete [] bypassr;

  703.     for(int k = 0; k < max_unison; ++k)

  704.         delete[] tmpwave_unison[k];

  705.     delete[] tmpwave_unison;

  706. }

  707. 

  708. 

  709. /*

  710.  * Init the parameters

  711.  */

  712. void ADnote::initparameters()

  713. {

  714.     int tmp[NUM_VOICES];

  715. 

  716.     // Global Parameters

  717.     NoteGlobalPar.initparameters(partparams->GlobalPar, basefreq, velocity,

  718.                                  stereo);

  719. 

  720.     NoteGlobalPar.AmpEnvelope->envout_dB(); //discard the first envelope output

  721.     globalnewamplitude = NoteGlobalPar.Volume

  722.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

  723.                          * NoteGlobalPar.AmpLfo->amplfoout();

  724. 

  725.     // Forbids the Modulation Voice to be greater or equal than voice

  726.     for(int i = 0; i < NUM_VOICES; ++i)

  727.         if(NoteVoicePar[i].FMVoice >= i)

  728.             NoteVoicePar[i].FMVoice = -1;

  729. 

  730.     // Voice Parameter init

  731.     for(int nvoice = 0; nvoice < NUM_VOICES; ++nvoice) {

  732.         Voice &vce = NoteVoicePar[nvoice];

  733.         ADnoteVoiceParam &param = partparams->VoicePar[nvoice];

  734. 

  735.         if(vce.Enabled == 0)

  736.             continue;

  737. 

  738.         vce.noisetype = param.Type;

  739.         /* Voice Amplitude Parameters Init */

  740.         vce.Volume = powf(0.1f, 3.0f * (1.0f - param.PVolume / 127.0f)) // -60dB..0dB

  741.                      * VelF(velocity, param.PAmpVelocityScaleFunction);

  742. 

  743.         if(param.PVolumeminus)

  744.             vce.Volume = -vce.Volume;

  745. 

  746.         if(param.PPanning == 0)

  747.             vce.Panning = RND;  // random panning

  748.         else

  749.             vce.Panning = param.PPanning / 128.0f;

  750. 

  751.         newamplitude[nvoice] = 1.0f;

  752.         if(param.PAmpEnvelopeEnabled) {

  753.             vce.AmpEnvelope = new Envelope(param.AmpEnvelope, basefreq);

  754.             vce.AmpEnvelope->envout_dB(); //discard the first envelope sample

  755.             newamplitude[nvoice] *= vce.AmpEnvelope->envout_dB();

  756.         }

  757. 

  758.         if(param.PAmpLfoEnabled) {

  759.             vce.AmpLfo = new LFO(param.AmpLfo, basefreq);

  760.             newamplitude[nvoice] *= vce.AmpLfo->amplfoout();

  761.         }

  762. 

  763.         /* Voice Frequency Parameters Init */

  764.         if(param.PFreqEnvelopeEnabled != 0)

  765.             vce.FreqEnvelope = new Envelope(param.FreqEnvelope, basefreq);

  766. 

  767.         if(param.PFreqLfoEnabled != 0)

  768.             vce.FreqLfo = new LFO(param.FreqLfo, basefreq);

  769. 

  770.         /* Voice Filter Parameters Init */

  771.         if(param.PFilterEnabled != 0) {

  772.             vce.VoiceFilterL = Filter::generate(param.VoiceFilter);

  773.             vce.VoiceFilterR = Filter::generate(param.VoiceFilter);

  774.         }

  775. 

  776.         if(param.PFilterEnvelopeEnabled != 0)

  777.             vce.FilterEnvelope = new Envelope(param.FilterEnvelope, basefreq);

  778. 

  779.         if(param.PFilterLfoEnabled != 0)

  780.             vce.FilterLfo = new LFO(param.FilterLfo, basefreq);

  781. 

  782.         vce.FilterFreqTracking =

  783.             param.VoiceFilter->getfreqtracking(basefreq);

  784. 

  785.         /* Voice Modulation Parameters Init */

  786.         if((vce.FMEnabled != NONE) && (vce.FMVoice < 0)) {

  787.             param.FMSmp->newrandseed(prng());

  788.             vce.FMSmp = new float[synth->oscilsize + OSCIL_SMP_EXTRA_SAMPLES];

  789. 

  790.             //Perform Anti-aliasing only on MORPH or RING MODULATION

  791. 

  792.             int vc = nvoice;

  793.             if(param.PextFMoscil != -1)

  794.                 vc = param.PextFMoscil;

  795. 

  796.             float tmp = 1.0f;

  797.             if((partparams->VoicePar[vc].FMSmp->Padaptiveharmonics != 0)

  798.                || (vce.FMEnabled == MORPH)

  799.                || (vce.FMEnabled == RING_MOD))

  800.                 tmp = getFMvoicebasefreq(nvoice);

  801. 

  802.             if(!partparams->GlobalPar.Hrandgrouping)

  803.                 partparams->VoicePar[vc].FMSmp->newrandseed(prng());

  804. 

  805.             for(int k = 0; k < unison_size[nvoice]; ++k)

  806.                 oscposhiFM[nvoice][k] = (oscposhi[nvoice][k]

  807.                                          + partparams->VoicePar[vc].FMSmp->get(

  808.                                              vce.FMSmp, tmp))

  809.                                         % synth->oscilsize;

  810. 

  811.             for(int i = 0; i < OSCIL_SMP_EXTRA_SAMPLES; ++i)

  812.                 vce.FMSmp[synth->oscilsize + i] = vce.FMSmp[i];

  813.             int oscposhiFM_add =

  814.                 (int)((param.PFMoscilphase

  815.                        - 64.0f) / 128.0f * synth->oscilsize

  816.                       + synth->oscilsize * 4);

  817.             for(int k = 0; k < unison_size[nvoice]; ++k) {

  818.                 oscposhiFM[nvoice][k] += oscposhiFM_add;

  819.                 oscposhiFM[nvoice][k] %= synth->oscilsize;

  820.             }

  821.         }

  822. 

  823.         if(param.PFMFreqEnvelopeEnabled != 0)

  824.             vce.FMFreqEnvelope = new Envelope(param.FMFreqEnvelope, basefreq);

  825. 

  826.         FMnewamplitude[nvoice] = vce.FMVolume * ctl->fmamp.relamp;

  827. 

  828.         if(param.PFMAmpEnvelopeEnabled != 0) {

  829.             vce.FMAmpEnvelope = new Envelope(param.FMAmpEnvelope,

  830.                                              basefreq);

  831.             FMnewamplitude[nvoice] *= vce.FMAmpEnvelope->envout_dB();

  832.         }

  833.     }

  834. 

  835.     for(int nvoice = 0; nvoice < NUM_VOICES; ++nvoice) {

  836.         for(int i = nvoice + 1; i < NUM_VOICES; ++i)

  837.             tmp[i] = 0;

  838.         for(int i = nvoice + 1; i < NUM_VOICES; ++i)

  839.             if((NoteVoicePar[i].FMVoice == nvoice) && (tmp[i] == 0)) {

  840.                 NoteVoicePar[nvoice].VoiceOut = new float[synth->buffersize];

  841.                 tmp[i] = 1;

  842.             }

  843. 

  844.         if(NoteVoicePar[nvoice].VoiceOut)

  845.             memset(NoteVoicePar[nvoice].VoiceOut, 0, synth->bufferbytes);

  846.     }

  847. }

  848. 

  849. 

  850. /*

  851.  * Computes the relative frequency of each unison voice and it's vibratto

  852.  * This must be called before setfreq* functions

  853.  */

  854. void ADnote::compute_unison_freq_rap(int nvoice) {

  855.     if(unison_size[nvoice] == 1) { //no unison

  856.         unison_freq_rap[nvoice][0] = 1.0f;

  857.         return;

  858.     }

  859.     float relbw = ctl->bandwidth.relbw * bandwidthDetuneMultiplier;

  860.     for(int k = 0; k < unison_size[nvoice]; ++k) {

  861.         float pos  = unison_vibratto[nvoice].position[k];

  862.         float step = unison_vibratto[nvoice].step[k];

  863.         pos += step;

  864.         if(pos <= -1.0f) {

  865.             pos  = -1.0f;

  866.             step = -step;

  867.         }

  868.         if(pos >= 1.0f) {

  869.             pos  = 1.0f;

  870.             step = -step;

  871.         }

  872.         float vibratto_val = (pos - 0.333333333f * pos * pos * pos) * 1.5f; //make the vibratto lfo smoother

  873.         unison_freq_rap[nvoice][k] = 1.0f

  874.                                      + ((unison_base_freq_rap[nvoice][k]

  875.                                          - 1.0f) + vibratto_val

  876.                                         * unison_vibratto[nvoice].amplitude)

  877.                                      * relbw;

  878. 

  879.         unison_vibratto[nvoice].position[k] = pos;

  880.         step = unison_vibratto[nvoice].step[k] = step;

  881.     }

  882. }

  883. 

  884. 

  885. /*

  886.  * Computes the frequency of an oscillator

  887.  */

  888. void ADnote::setfreq(int nvoice, float in_freq)

  889. {

  890.     for(int k = 0; k < unison_size[nvoice]; ++k) {

  891.         float freq  = fabs(in_freq) * unison_freq_rap[nvoice][k];

  892.         float speed = freq * synth->oscilsize_f / synth->samplerate_f;

  893.         if(speed > synth->oscilsize_f)

  894.             speed = synth->oscilsize_f;

  895. 

  896.         F2I(speed, oscfreqhi[nvoice][k]);

  897.         oscfreqlo[nvoice][k] = speed - floor(speed);

  898.     }

  899. }

  900. 

  901. /*

  902.  * Computes the frequency of an modullator oscillator

  903.  */

  904. void ADnote::setfreqFM(int nvoice, float in_freq)

  905. {

  906.     for(int k = 0; k < unison_size[nvoice]; ++k) {

  907.         float freq  = fabs(in_freq) * unison_freq_rap[nvoice][k];

  908.         float speed = freq * synth->oscilsize_f / synth->samplerate_f;

  909.         if(speed > synth->samplerate_f)

  910.             speed = synth->samplerate_f;

  911. 

  912.         F2I(speed, oscfreqhiFM[nvoice][k]);

  913.         oscfreqloFM[nvoice][k] = speed - floor(speed);

  914.     }

  915. }

  916. 

  917. /*

  918.  * Get Voice base frequency

  919.  */

  920. float ADnote::getvoicebasefreq(int nvoice) const

  921. {

  922.     float detune = NoteVoicePar[nvoice].Detune / 100.0f

  923.                    + NoteVoicePar[nvoice].FineDetune / 100.0f

  924.                    * ctl->bandwidth.relbw * bandwidthDetuneMultiplier

  925.                    + NoteGlobalPar.Detune / 100.0f;

  926. 

  927.     if(NoteVoicePar[nvoice].fixedfreq == 0)

  928.         return this->basefreq * powf(2, detune / 12.0f);

  929.     else { //the fixed freq is enabled

  930.         float fixedfreq   = 440.0f;

  931.         int   fixedfreqET = NoteVoicePar[nvoice].fixedfreqET;

  932.         if(fixedfreqET != 0) { //if the frequency varies according the keyboard note

  933.             float tmp =

  934.                 (midinote

  935.                  - 69.0f) / 12.0f

  936.                 * (powf(2.0f, (fixedfreqET - 1) / 63.0f) - 1.0f);

  937.             if(fixedfreqET <= 64)

  938.                 fixedfreq *= powf(2.0f, tmp);

  939.             else

  940.                 fixedfreq *= powf(3.0f, tmp);

  941.         }

  942.         return fixedfreq * powf(2.0f, detune / 12.0f);

  943.     }

  944. }

  945. 

  946. /*

  947.  * Get Voice's Modullator base frequency

  948.  */

  949. float ADnote::getFMvoicebasefreq(int nvoice) const

  950. {

  951.     float detune = NoteVoicePar[nvoice].FMDetune / 100.0f;

  952.     return getvoicebasefreq(nvoice) * powf(2, detune / 12.0f);

  953. }

  954. 

  955. /*

  956.  * Computes all the parameters for each tick

  957.  */

  958. void ADnote::computecurrentparameters()

  959. {

  960.     int   nvoice;

  961.     float voicefreq, voicepitch, filterpitch, filterfreq, FMfreq,

  962.           FMrelativepitch, globalpitch, globalfilterpitch;

  963.     globalpitch = 0.01f * (NoteGlobalPar.FreqEnvelope->envout()

  964.                            + NoteGlobalPar.FreqLfo->lfoout()

  965.                            * ctl->modwheel.relmod);

  966.     globaloldamplitude = globalnewamplitude;

  967.     globalnewamplitude = NoteGlobalPar.Volume

  968.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

  969.                          * NoteGlobalPar.AmpLfo->amplfoout();

  970. 

  971.     globalfilterpitch = NoteGlobalPar.FilterEnvelope->envout()

  972.                         + NoteGlobalPar.FilterLfo->lfoout()

  973.                         + NoteGlobalPar.FilterCenterPitch;

  974. 

  975.     float tmpfilterfreq = globalfilterpitch + ctl->filtercutoff.relfreq

  976.                           + NoteGlobalPar.FilterFreqTracking;

  977. 

  978.     tmpfilterfreq = Filter::getrealfreq(tmpfilterfreq);

  979. 

  980.     float globalfilterq = NoteGlobalPar.FilterQ * ctl->filterq.relq;

  981.     NoteGlobalPar.GlobalFilterL->setfreq_and_q(tmpfilterfreq, globalfilterq);

  982.     if(stereo != 0)

  983.         NoteGlobalPar.GlobalFilterR->setfreq_and_q(tmpfilterfreq, globalfilterq);

  984. 

  985.     //compute the portamento, if it is used by this note

  986.     float portamentofreqrap = 1.0f;

  987.     if(portamento != 0) { //this voice use portamento

  988.         portamentofreqrap = ctl->portamento.freqrap;

  989.         if(ctl->portamento.used == 0) //the portamento has finished

  990.             portamento = 0;  //this note is no longer "portamented"

  991.     }

  992. 

  993.     //compute parameters for all voices

  994.     for(nvoice = 0; nvoice < NUM_VOICES; ++nvoice) {

  995.         if(NoteVoicePar[nvoice].Enabled != ON)

  996.             continue;

  997.         NoteVoicePar[nvoice].DelayTicks -= 1;

  998.         if(NoteVoicePar[nvoice].DelayTicks > 0)

  999.             continue;

  1000. 

  1001.         compute_unison_freq_rap(nvoice);

  1002. 

  1003.         /*******************/

  1004.         /* Voice Amplitude */

  1005.         /*******************/

  1006.         oldamplitude[nvoice] = newamplitude[nvoice];

  1007.         newamplitude[nvoice] = 1.0f;

  1008. 

  1009.         if(NoteVoicePar[nvoice].AmpEnvelope != NULL)

  1010.             newamplitude[nvoice] *= NoteVoicePar[nvoice].AmpEnvelope->envout_dB();

  1011. 

  1012.         if(NoteVoicePar[nvoice].AmpLfo != NULL)

  1013.             newamplitude[nvoice] *= NoteVoicePar[nvoice].AmpLfo->amplfoout();

  1014. 

  1015.         /****************/

  1016.         /* Voice Filter */

  1017.         /****************/

  1018.         if(NoteVoicePar[nvoice].VoiceFilterL != NULL) {

  1019.             filterpitch = NoteVoicePar[nvoice].FilterCenterPitch;

  1020. 

  1021.             if(NoteVoicePar[nvoice].FilterEnvelope != NULL)

  1022.                 filterpitch += NoteVoicePar[nvoice].FilterEnvelope->envout();

  1023. 

  1024.             if(NoteVoicePar[nvoice].FilterLfo != NULL)

  1025.                 filterpitch += NoteVoicePar[nvoice].FilterLfo->lfoout();

  1026. 

  1027.             filterfreq = filterpitch + NoteVoicePar[nvoice].FilterFreqTracking;

  1028.             filterfreq = Filter::getrealfreq(filterfreq);

  1029. 

  1030.             NoteVoicePar[nvoice].VoiceFilterL->setfreq(filterfreq);

  1031.             if(stereo && NoteVoicePar[nvoice].VoiceFilterR)

  1032.                 NoteVoicePar[nvoice].VoiceFilterR->setfreq(filterfreq);

  1033.         }

  1034. 

  1035.         if(NoteVoicePar[nvoice].noisetype == 0) { //compute only if the voice isn't noise

  1036.             /*******************/

  1037.             /* Voice Frequency */

  1038.             /*******************/

  1039.             voicepitch = 0.0f;

  1040.             if(NoteVoicePar[nvoice].FreqLfo != NULL)

  1041.                 voicepitch += NoteVoicePar[nvoice].FreqLfo->lfoout() / 100.0f

  1042.                               * ctl->bandwidth.relbw;

  1043. 

  1044.             if(NoteVoicePar[nvoice].FreqEnvelope != NULL)

  1045.                 voicepitch += NoteVoicePar[nvoice].FreqEnvelope->envout()

  1046.                               / 100.0f;

  1047.             voicefreq = getvoicebasefreq(nvoice)

  1048.                         * powf(2, (voicepitch + globalpitch) / 12.0f);                //Hz frequency

  1049.             voicefreq *= ctl->pitchwheel.relfreq; //change the frequency by the controller

  1050.             setfreq(nvoice, voicefreq * portamentofreqrap);

  1051. 

  1052.             /***************/

  1053.             /*  Modulator */

  1054.             /***************/

  1055.             if(NoteVoicePar[nvoice].FMEnabled != NONE) {

  1056.                 FMrelativepitch = NoteVoicePar[nvoice].FMDetune / 100.0f;

  1057.                 if(NoteVoicePar[nvoice].FMFreqEnvelope != NULL)

  1058.                     FMrelativepitch +=

  1059.                         NoteVoicePar[nvoice].FMFreqEnvelope->envout() / 100;

  1060.                 FMfreq =

  1061.                     powf(2.0f, FMrelativepitch

  1062.                          / 12.0f) * voicefreq * portamentofreqrap;

  1063.                 setfreqFM(nvoice, FMfreq);

  1064. 

  1065.                 FMoldamplitude[nvoice] = FMnewamplitude[nvoice];

  1066.                 FMnewamplitude[nvoice] = NoteVoicePar[nvoice].FMVolume

  1067.                                          * ctl->fmamp.relamp;

  1068.                 if(NoteVoicePar[nvoice].FMAmpEnvelope != NULL)

  1069.                     FMnewamplitude[nvoice] *=

  1070.                         NoteVoicePar[nvoice].FMAmpEnvelope->envout_dB();

  1071.             }

  1072.         }

  1073.     }

  1074.     time += synth->buffersize_f / synth->samplerate_f;

  1075. }

  1076. 

  1077. 

  1078. /*

  1079.  * Fadein in a way that removes clicks but keep sound "punchy"

  1080.  */

  1081. inline void ADnote::fadein(float *smps) const

  1082. {

  1083.     int zerocrossings = 0;

  1084.     for(int i = 1; i < synth->buffersize; ++i)

  1085.         if((smps[i - 1] < 0.0f) && (smps[i] > 0.0f))

  1086.             zerocrossings++;  //this is only the possitive crossings

  1087. 

  1088.     float tmp = (synth->buffersize_f - 1.0f) / (zerocrossings + 1) / 3.0f;

  1089.     if(tmp < 8.0f)

  1090.         tmp = 8.0f;

  1091. 

  1092.     int n;

  1093.     F2I(tmp, n); //how many samples is the fade-in

  1094.     if(n > synth->buffersize)

  1095.         n = synth->buffersize;

  1096.     for(int i = 0; i < n; ++i) { //fade-in

  1097.         float tmp = 0.5f - cosf((float)i / (float) n * PI) * 0.5f;

  1098.         smps[i] *= tmp;

  1099.     }

  1100. }

  1101. 

  1102. /*

  1103.  * Computes the Oscillator (Without Modulation) - LinearInterpolation

  1104.  */

  1105. inline void ADnote::ComputeVoiceOscillator_LinearInterpolation(int nvoice)

  1106. {

  1107.     int   i, poshi;

  1108.     float poslo;

  1109. 

  1110.     for(int k = 0; k < unison_size[nvoice]; ++k) {

  1111.         poshi = oscposhi[nvoice][k];

  1112.         poslo = oscposlo[nvoice][k];

  1113.         int    freqhi = oscfreqhi[nvoice][k];

  1114.         float  freqlo = oscfreqlo[nvoice][k];

  1115.         float *smps   = NoteVoicePar[nvoice].OscilSmp;

  1116.         float *tw     = tmpwave_unison[k];

  1117.         for(i = 0; i < synth->buffersize; ++i) {

  1118.             tw[i]  = smps[poshi] * (1.0f - poslo) + smps[poshi + 1] * poslo;

  1119.             poslo += freqlo;

  1120.             if(poslo >= 1.0f) {

  1121.                 poslo -= 1.0f;

  1122.                 poshi++;

  1123.             }

  1124.             poshi += freqhi;

  1125.             poshi &= synth->oscilsize - 1;

  1126.         }

  1127.         oscposhi[nvoice][k] = poshi;

  1128.         oscposlo[nvoice][k] = poslo;

  1129.     }

  1130. }

  1131. 

  1132. 

  1133. 

  1134. /*

  1135.  * Computes the Oscillator (Without Modulation) - CubicInterpolation

  1136.  *

  1137.  The differences from the Linear are to little to deserve to be used. This is because I am using a large synth->oscilsize (>512)

  1138. inline void ADnote::ComputeVoiceOscillator_CubicInterpolation(int nvoice){

  1139.     int i,poshi;

  1140.     float poslo;

  1141. 

  1142.     poshi=oscposhi[nvoice];

  1143.     poslo=oscposlo[nvoice];

  1144.     float *smps=NoteVoicePar[nvoice].OscilSmp;

  1145.     float xm1,x0,x1,x2,a,b,c;

  1146.     for (i=0;i<synth->buffersize;i++){

  1147.     xm1=smps[poshi];

  1148.     x0=smps[poshi+1];

  1149.     x1=smps[poshi+2];

  1150.     x2=smps[poshi+3];

  1151.     a=(3.0f * (x0-x1) - xm1 + x2) / 2.0f;

  1152.     b = 2.0f*x1 + xm1 - (5.0f*x0 + x2) / 2.0f;

  1153.     c = (x1 - xm1) / 2.0f;

  1154.     tmpwave[i]=(((a * poslo) + b) * poslo + c) * poslo + x0;

  1155.     printf("a\n");

  1156.     //tmpwave[i]=smps[poshi]*(1.0f-poslo)+smps[poshi+1]*poslo;

  1157.     poslo+=oscfreqlo[nvoice];

  1158.     if (poslo>=1.0f) {

  1159.             poslo-=1.0f;

  1160.         poshi++;

  1161.     };

  1162.         poshi+=oscfreqhi[nvoice];

  1163.         poshi&=synth->oscilsize-1;

  1164.     };

  1165.     oscposhi[nvoice]=poshi;

  1166.     oscposlo[nvoice]=poslo;

  1167. };

  1168. */

  1169. /*

  1170.  * Computes the Oscillator (Morphing)

  1171.  */

  1172. inline void ADnote::ComputeVoiceOscillatorMorph(int nvoice)

  1173. {

  1174.     int   i;

  1175.     float amp;

  1176.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

  1177.     if(FMnewamplitude[nvoice] > 1.0f)

  1178.         FMnewamplitude[nvoice] = 1.0f;

  1179.     if(FMoldamplitude[nvoice] > 1.0f)

  1180.         FMoldamplitude[nvoice] = 1.0f;

  1181. 

  1182.     if(NoteVoicePar[nvoice].FMVoice >= 0) {

  1183.         //if I use VoiceOut[] as modullator

  1184.         int FMVoice = NoteVoicePar[nvoice].FMVoice;

  1185.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1186.             float *tw = tmpwave_unison[k];

  1187.             for(i = 0; i < synth->buffersize; ++i) {

  1188.                 amp = INTERPOLATE_AMPLITUDE(FMoldamplitude[nvoice],

  1189.                                             FMnewamplitude[nvoice],

  1190.                                             i,

  1191.                                             synth->buffersize);

  1192.                 tw[i] = tw[i]

  1193.                         * (1.0f

  1194.                            - amp) + amp * NoteVoicePar[FMVoice].VoiceOut[i];

  1195.             }

  1196.         }

  1197.     }

  1198.     else

  1199.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1200.             int    poshiFM  = oscposhiFM[nvoice][k];

  1201.             float  posloFM  = oscposloFM[nvoice][k];

  1202.             int    freqhiFM = oscfreqhiFM[nvoice][k];

  1203.             float  freqloFM = oscfreqloFM[nvoice][k];

  1204.             float *tw = tmpwave_unison[k];

  1205. 

  1206.             for(i = 0; i < synth->buffersize; ++i) {

  1207.                 amp = INTERPOLATE_AMPLITUDE(FMoldamplitude[nvoice],

  1208.                                             FMnewamplitude[nvoice],

  1209.                                             i,

  1210.                                             synth->buffersize);

  1211.                 tw[i] = tw[i] * (1.0f - amp) + amp

  1212.                         * (NoteVoicePar[nvoice].FMSmp[poshiFM] * (1 - posloFM)

  1213.                            + NoteVoicePar[nvoice].FMSmp[poshiFM + 1] * posloFM);

  1214.                 posloFM += freqloFM;

  1215.                 if(posloFM >= 1.0f) {

  1216.                     posloFM -= 1.0f;

  1217.                     poshiFM++;

  1218.                 }

  1219.                 poshiFM += freqhiFM;

  1220.                 poshiFM &= synth->oscilsize - 1;

  1221.             }

  1222.             oscposhiFM[nvoice][k] = poshiFM;

  1223.             oscposloFM[nvoice][k] = posloFM;

  1224.         }

  1225. }

  1226. 

  1227. /*

  1228.  * Computes the Oscillator (Ring Modulation)

  1229.  */

  1230. inline void ADnote::ComputeVoiceOscillatorRingModulation(int nvoice)

  1231. {

  1232.     int   i;

  1233.     float amp;

  1234.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

  1235.     if(FMnewamplitude[nvoice] > 1.0f)

  1236.         FMnewamplitude[nvoice] = 1.0f;

  1237.     if(FMoldamplitude[nvoice] > 1.0f)

  1238.         FMoldamplitude[nvoice] = 1.0f;

  1239.     if(NoteVoicePar[nvoice].FMVoice >= 0)

  1240.         // if I use VoiceOut[] as modullator

  1241.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1242.             float *tw = tmpwave_unison[k];

  1243.             for(i = 0; i < synth->buffersize; ++i) {

  1244.                 amp = INTERPOLATE_AMPLITUDE(FMoldamplitude[nvoice],

  1245.                                             FMnewamplitude[nvoice],

  1246.                                             i,

  1247.                                             synth->buffersize);

  1248.                 int FMVoice = NoteVoicePar[nvoice].FMVoice;

  1249.                 tw[i] *= (1.0f - amp) + amp * NoteVoicePar[FMVoice].VoiceOut[i];

  1250.             }

  1251.         }

  1252.     else

  1253.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1254.             int    poshiFM  = oscposhiFM[nvoice][k];

  1255.             float  posloFM  = oscposloFM[nvoice][k];

  1256.             int    freqhiFM = oscfreqhiFM[nvoice][k];

  1257.             float  freqloFM = oscfreqloFM[nvoice][k];

  1258.             float *tw = tmpwave_unison[k];

  1259. 

  1260.             for(i = 0; i < synth->buffersize; ++i) {

  1261.                 amp = INTERPOLATE_AMPLITUDE(FMoldamplitude[nvoice],

  1262.                                             FMnewamplitude[nvoice],

  1263.                                             i,

  1264.                                             synth->buffersize);

  1265.                 tw[i] *= (NoteVoicePar[nvoice].FMSmp[poshiFM] * (1.0f - posloFM)

  1266.                           + NoteVoicePar[nvoice].FMSmp[poshiFM

  1267.                                                        + 1] * posloFM) * amp

  1268.                          + (1.0f - amp);

  1269.                 posloFM += freqloFM;

  1270.                 if(posloFM >= 1.0f) {

  1271.                     posloFM -= 1.0f;

  1272.                     poshiFM++;

  1273.                 }

  1274.                 poshiFM += freqhiFM;

  1275.                 poshiFM &= synth->oscilsize - 1;

  1276.             }

  1277.             oscposhiFM[nvoice][k] = poshiFM;

  1278.             oscposloFM[nvoice][k] = posloFM;

  1279.         }

  1280. }

  1281. 

  1282. 

  1283. 

  1284. /*

  1285.  * Computes the Oscillator (Phase Modulation or Frequency Modulation)

  1286.  */

  1287. inline void ADnote::ComputeVoiceOscillatorFrequencyModulation(int nvoice,

  1288.                                                               int FMmode)

  1289. {

  1290.     int   carposhi = 0;

  1291.     int   i, FMmodfreqhi = 0;

  1292.     float FMmodfreqlo = 0, carposlo = 0;

  1293. 

  1294.     if(NoteVoicePar[nvoice].FMVoice >= 0)

  1295.         //if I use VoiceOut[] as modulator

  1296.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1297.             float *tw = tmpwave_unison[k];

  1298.             memcpy(tw, NoteVoicePar[NoteVoicePar[nvoice].FMVoice].VoiceOut,

  1299.                    synth->bufferbytes);

  1300.         }

  1301.     else

  1302.         //Compute the modulator and store it in tmpwave_unison[][]

  1303.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1304.             int    poshiFM  = oscposhiFM[nvoice][k];

  1305.             float  posloFM  = oscposloFM[nvoice][k];

  1306.             int    freqhiFM = oscfreqhiFM[nvoice][k];

  1307.             float  freqloFM = oscfreqloFM[nvoice][k];

  1308.             float *tw = tmpwave_unison[k];

  1309. 

  1310.             for(i = 0; i < synth->buffersize; ++i) {

  1311.                 tw[i] =

  1312.                     (NoteVoicePar[nvoice].FMSmp[poshiFM] * (1.0f - posloFM)

  1313.                      + NoteVoicePar[nvoice].FMSmp[poshiFM + 1] * posloFM);

  1314.                 posloFM += freqloFM;

  1315.                 if(posloFM >= 1.0f) {

  1316.                     posloFM = fmod(posloFM, 1.0f);

  1317.                     poshiFM++;

  1318.                 }

  1319.                 poshiFM += freqhiFM;

  1320.                 poshiFM &= synth->oscilsize - 1;

  1321.             }

  1322.             oscposhiFM[nvoice][k] = poshiFM;

  1323.             oscposloFM[nvoice][k] = posloFM;

  1324.         }

  1325.     // Amplitude interpolation

  1326.     if(ABOVE_AMPLITUDE_THRESHOLD(FMoldamplitude[nvoice],

  1327.                                  FMnewamplitude[nvoice]))

  1328.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1329.             float *tw = tmpwave_unison[k];

  1330.             for(i = 0; i < synth->buffersize; ++i)

  1331.                 tw[i] *= INTERPOLATE_AMPLITUDE(FMoldamplitude[nvoice],

  1332.                                                FMnewamplitude[nvoice],

  1333.                                                i,

  1334.                                                synth->buffersize);

  1335.         }

  1336.     else

  1337.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1338.             float *tw = tmpwave_unison[k];

  1339.             for(i = 0; i < synth->buffersize; ++i)

  1340.                 tw[i] *= FMnewamplitude[nvoice];

  1341.         }

  1342. 

  1343. 

  1344.     //normalize: makes all sample-rates, oscil_sizes to produce same sound

  1345.     if(FMmode != 0) { //Frequency modulation

  1346.         float normalize = synth->oscilsize_f / 262144.0f * 44100.0f

  1347.                           / synth->samplerate_f;

  1348.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1349.             float *tw    = tmpwave_unison[k];

  1350.             float  fmold = FMoldsmp[nvoice][k];

  1351.             for(i = 0; i < synth->buffersize; ++i) {

  1352.                 fmold = fmod(fmold + tw[i] * normalize, synth->oscilsize);

  1353.                 tw[i] = fmold;

  1354.             }

  1355.             FMoldsmp[nvoice][k] = fmold;

  1356.         }

  1357.     }

  1358.     else {  //Phase modulation

  1359.         float normalize = synth->oscilsize_f / 262144.0f;

  1360.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1361.             float *tw = tmpwave_unison[k];

  1362.             for(i = 0; i < synth->buffersize; ++i)

  1363.                 tw[i] *= normalize;

  1364.         }

  1365.     }

  1366. 

  1367.     //do the modulation

  1368.     for(int k = 0; k < unison_size[nvoice]; ++k) {

  1369.         float *tw     = tmpwave_unison[k];

  1370.         int    poshi  = oscposhi[nvoice][k];

  1371.         float  poslo  = oscposlo[nvoice][k];

  1372.         int    freqhi = oscfreqhi[nvoice][k];

  1373.         float  freqlo = oscfreqlo[nvoice][k];

  1374. 

  1375.         for(i = 0; i < synth->buffersize; ++i) {

  1376.             F2I(tw[i], FMmodfreqhi);

  1377.             FMmodfreqlo = fmod(tw[i] + 0.0000000001f, 1.0f);

  1378.             if(FMmodfreqhi < 0)

  1379.                 FMmodfreqlo++;

  1380. 

  1381.             //carrier

  1382.             carposhi = poshi + FMmodfreqhi;

  1383.             carposlo = poslo + FMmodfreqlo;

  1384. 

  1385.             if(carposlo >= 1.0f) {

  1386.                 carposhi++;

  1387.                 carposlo = fmod(carposlo, 1.0f);

  1388.             }

  1389.             carposhi &= (synth->oscilsize - 1);

  1390. 

  1391.             tw[i] = NoteVoicePar[nvoice].OscilSmp[carposhi]

  1392.                     * (1.0f - carposlo)

  1393.                     + NoteVoicePar[nvoice].OscilSmp[carposhi

  1394.                                                     + 1] * carposlo;

  1395. 

  1396.             poslo += freqlo;

  1397.             if(poslo >= 1.0f) {

  1398.                 poslo = fmod(poslo, 1.0f);

  1399.                 poshi++;

  1400.             }

  1401. 

  1402.             poshi += freqhi;

  1403.             poshi &= synth->oscilsize - 1;

  1404.         }

  1405.         oscposhi[nvoice][k] = poshi;

  1406.         oscposlo[nvoice][k] = poslo;

  1407.     }

  1408. }

  1409. 

  1410. 

  1411. /*Calculeaza Oscilatorul cu PITCH MODULATION*/

  1412. inline void ADnote::ComputeVoiceOscillatorPitchModulation(int /*nvoice*/)

  1413. {

  1414. //TODO

  1415. }

  1416. 

  1417. /*

  1418.  * Computes the Noise

  1419.  */

  1420. inline void ADnote::ComputeVoiceNoise(int nvoice)

  1421. {

  1422.     for(int k = 0; k < unison_size[nvoice]; ++k) {

  1423.         float *tw = tmpwave_unison[k];

  1424.         for(int i = 0; i < synth->buffersize; ++i)

  1425.             tw[i] = RND * 2.0f - 1.0f;

  1426.     }

  1427. }

  1428. 

  1429. 

  1430. 

  1431. /*

  1432.  * Compute the ADnote samples

  1433.  * Returns 0 if the note is finished

  1434.  */

  1435. int ADnote::noteout(float *outl, float *outr)

  1436. {

  1437.     memcpy(outl, denormalkillbuf, synth->bufferbytes);

  1438.     memcpy(outr, denormalkillbuf, synth->bufferbytes);

  1439. 

  1440.     if(NoteEnabled == OFF)

  1441.         return 0;

  1442. 

  1443.     memset(bypassl, 0, synth->bufferbytes);

  1444.     memset(bypassr, 0, synth->bufferbytes);

  1445.     computecurrentparameters();

  1446. 

  1447.     for(unsigned nvoice = 0; nvoice < NUM_VOICES; ++nvoice) {

  1448.         if((NoteVoicePar[nvoice].Enabled != ON)

  1449.            || (NoteVoicePar[nvoice].DelayTicks > 0))

  1450.             continue;

  1451.         if(NoteVoicePar[nvoice].noisetype == 0) //voice mode=sound

  1452.             switch(NoteVoicePar[nvoice].FMEnabled) {

  1453.                 case MORPH:

  1454.                     ComputeVoiceOscillatorMorph(nvoice);

  1455.                     break;

  1456.                 case RING_MOD:

  1457.                     ComputeVoiceOscillatorRingModulation(nvoice);

  1458.                     break;

  1459.                 case PHASE_MOD:

  1460.                     ComputeVoiceOscillatorFrequencyModulation(nvoice, 0);

  1461.                     break;

  1462.                 case FREQ_MOD:

  1463.                     ComputeVoiceOscillatorFrequencyModulation(nvoice, 1);

  1464.                     break;

  1465.                 //case PITCH_MOD:ComputeVoiceOscillatorPitchModulation(nvoice);break;

  1466.                 default:

  1467.                     ComputeVoiceOscillator_LinearInterpolation(nvoice);

  1468.                     //if (config.cfg.Interpolation) ComputeVoiceOscillator_CubicInterpolation(nvoice);

  1469.             }

  1470.         else

  1471.             ComputeVoiceNoise(nvoice);

  1472.         // Voice Processing

  1473. 

  1474. 

  1475.         //mix subvoices into voice

  1476.         memset(tmpwavel, 0, synth->bufferbytes);

  1477.         if(stereo)

  1478.             memset(tmpwaver, 0, synth->bufferbytes);

  1479.         for(int k = 0; k < unison_size[nvoice]; ++k) {

  1480.             float *tw = tmpwave_unison[k];

  1481.             if(stereo) {

  1482.                 float stereo_pos = 0;

  1483.                 if(unison_size[nvoice] > 1)

  1484.                     stereo_pos = k

  1485.                                  / (float)(unison_size[nvoice]

  1486.                                            - 1) * 2.0f - 1.0f;

  1487.                 float stereo_spread = unison_stereo_spread[nvoice] * 2.0f; //between 0 and 2.0f

  1488.                 if(stereo_spread > 1.0f) {

  1489.                     float stereo_pos_1 = (stereo_pos >= 0.0f) ? 1.0f : -1.0f;

  1490.                     stereo_pos =

  1491.                         (2.0f

  1492.                          - stereo_spread) * stereo_pos

  1493.                         + (stereo_spread - 1.0f) * stereo_pos_1;

  1494.                 }

  1495.                 else

  1496.                     stereo_pos *= stereo_spread;

  1497. 

  1498.                 if(unison_size[nvoice] == 1)

  1499.                     stereo_pos = 0.0f;

  1500.                 float panning = (stereo_pos + 1.0f) * 0.5f;

  1501. 

  1502. 

  1503.                 float lvol = (1.0f - panning) * 2.0f;

  1504.                 if(lvol > 1.0f)

  1505.                     lvol = 1.0f;

  1506. 

  1507.                 float rvol = panning * 2.0f;

  1508.                 if(rvol > 1.0f)

  1509.                     rvol = 1.0f;

  1510. 

  1511.                 if(unison_invert_phase[nvoice][k]) {

  1512.                     lvol = -lvol;

  1513.                     rvol = -rvol;

  1514.                 }

  1515. 

  1516.                 for(int i = 0; i < synth->buffersize; ++i)

  1517.                     tmpwavel[i] += tw[i] * lvol;

  1518.                 for(int i = 0; i < synth->buffersize; ++i)

  1519.                     tmpwaver[i] += tw[i] * rvol;

  1520.             }

  1521.             else

  1522.                 for(int i = 0; i < synth->buffersize; ++i)

  1523.                     tmpwavel[i] += tw[i];

  1524.         }

  1525. 

  1526. 

  1527.         float unison_amplitude = 1.0f / sqrt(unison_size[nvoice]); //reduce the amplitude for large unison sizes

  1528.         // Amplitude

  1529.         float oldam = oldamplitude[nvoice] * unison_amplitude;

  1530.         float newam = newamplitude[nvoice] * unison_amplitude;

  1531. 

  1532.         if(ABOVE_AMPLITUDE_THRESHOLD(oldam, newam)) {

  1533.             int rest = synth->buffersize;

  1534.             //test if the amplitude if raising and the difference is high

  1535.             if((newam > oldam) && ((newam - oldam) > 0.25f)) {

  1536.                 rest = 10;

  1537.                 if(rest > synth->buffersize)

  1538.                     rest = synth->buffersize;

  1539.                 for(int i = 0; i < synth->buffersize - rest; ++i)

  1540.                     tmpwavel[i] *= oldam;

  1541.                 if(stereo)

  1542.                     for(int i = 0; i < synth->buffersize - rest; ++i)

  1543.                         tmpwaver[i] *= oldam;

  1544.             }

  1545.             // Amplitude interpolation

  1546.             for(int i = 0; i < rest; ++i) {

  1547.                 float amp = INTERPOLATE_AMPLITUDE(oldam, newam, i, rest);

  1548.                 tmpwavel[i + (synth->buffersize - rest)] *= amp;

  1549.                 if(stereo)

  1550.                     tmpwaver[i + (synth->buffersize - rest)] *= amp;

  1551.             }

  1552.         }

  1553.         else {

  1554.             for(int i = 0; i < synth->buffersize; ++i)

  1555.                 tmpwavel[i] *= newam;

  1556.             if(stereo)

  1557.                 for(int i = 0; i < synth->buffersize; ++i)

  1558.                     tmpwaver[i] *= newam;

  1559.         }

  1560. 

  1561.         // Fade in

  1562.         if(firsttick[nvoice] != 0) {

  1563.             fadein(&tmpwavel[0]);

  1564.             if(stereo)

  1565.                 fadein(&tmpwaver[0]);

  1566.             firsttick[nvoice] = 0;

  1567.         }

  1568. 

  1569. 

  1570.         // Filter

  1571.         if(NoteVoicePar[nvoice].VoiceFilterL != NULL)

  1572.             NoteVoicePar[nvoice].VoiceFilterL->filterout(&tmpwavel[0]);

  1573.         if((stereo) && (NoteVoicePar[nvoice].VoiceFilterR != NULL))

  1574.             NoteVoicePar[nvoice].VoiceFilterR->filterout(&tmpwaver[0]);

  1575. 

  1576.         //check if the amplitude envelope is finished, if yes, the voice will be fadeout

  1577.         if(NoteVoicePar[nvoice].AmpEnvelope != NULL)

  1578.             if(NoteVoicePar[nvoice].AmpEnvelope->finished() != 0) {

  1579.                 for(int i = 0; i < synth->buffersize; ++i)

  1580.                     tmpwavel[i] *= 1.0f - (float)i / synth->buffersize_f;

  1581.                 if(stereo)

  1582.                     for(int i = 0; i < synth->buffersize; ++i)

  1583.                         tmpwaver[i] *= 1.0f - (float)i / synth->buffersize_f;

  1584.             }

  1585.         //the voice is killed later

  1586. 

  1587. 

  1588.         // Put the ADnote samples in VoiceOut (without appling Global volume, because I wish to use this voice as a modullator)

  1589.         if(NoteVoicePar[nvoice].VoiceOut != NULL) {

  1590.             if(stereo)

  1591.                 for(int i = 0; i < synth->buffersize; ++i)

  1592.                     NoteVoicePar[nvoice].VoiceOut[i] = tmpwavel[i]

  1593.                                                        + tmpwaver[i];

  1594.             else   //mono

  1595.                 for(int i = 0; i < synth->buffersize; ++i)

  1596.                     NoteVoicePar[nvoice].VoiceOut[i] = tmpwavel[i];

  1597.         }

  1598. 

  1599. 

  1600.         // Add the voice that do not bypass the filter to out

  1601.         if(NoteVoicePar[nvoice].filterbypass == 0) { //no bypass

  1602.             if(stereo)

  1603.                 for(int i = 0; i < synth->buffersize; ++i) { //stereo

  1604.                     outl[i] += tmpwavel[i] * NoteVoicePar[nvoice].Volume

  1605.                                * NoteVoicePar[nvoice].Panning * 2.0f;

  1606.                     outr[i] += tmpwaver[i] * NoteVoicePar[nvoice].Volume

  1607.                                * (1.0f - NoteVoicePar[nvoice].Panning) * 2.0f;

  1608.                 }

  1609.             else

  1610.                 for(int i = 0; i < synth->buffersize; ++i) //mono

  1611.                     outl[i] += tmpwavel[i] * NoteVoicePar[nvoice].Volume;

  1612.         }

  1613.         else {  //bypass the filter

  1614.             if(stereo)

  1615.                 for(int i = 0; i < synth->buffersize; ++i) { //stereo

  1616.                     bypassl[i] += tmpwavel[i] * NoteVoicePar[nvoice].Volume

  1617.                                   * NoteVoicePar[nvoice].Panning * 2.0f;

  1618.                     bypassr[i] += tmpwaver[i] * NoteVoicePar[nvoice].Volume

  1619.                                   * (1.0f

  1620.                                      - NoteVoicePar[nvoice].Panning) * 2.0f;

  1621.                 }

  1622.             else

  1623.                 for(int i = 0; i < synth->buffersize; ++i) //mono

  1624.                     bypassl[i] += tmpwavel[i] * NoteVoicePar[nvoice].Volume;

  1625.         }

  1626.         // chech if there is necesary to proces the voice longer (if the Amplitude envelope isn't finished)

  1627.         if(NoteVoicePar[nvoice].AmpEnvelope != NULL)

  1628.             if(NoteVoicePar[nvoice].AmpEnvelope->finished() != 0)

  1629.                 KillVoice(nvoice);

  1630.     }

  1631. 

  1632. 

  1633.     //Processing Global parameters

  1634.     NoteGlobalPar.GlobalFilterL->filterout(&outl[0]);

  1635. 

  1636.     if(stereo == 0) { //set the right channel=left channel

  1637.         memcpy(outr, outl, synth->bufferbytes);

  1638.         memcpy(bypassr, bypassl, synth->bufferbytes);

  1639.     }

  1640.     else

  1641.         NoteGlobalPar.GlobalFilterR->filterout(&outr[0]);

  1642. 

  1643.     for(int i = 0; i < synth->buffersize; ++i) {

  1644.         outl[i] += bypassl[i];

  1645.         outr[i] += bypassr[i];

  1646.     }

  1647. 

  1648.     if(ABOVE_AMPLITUDE_THRESHOLD(globaloldamplitude, globalnewamplitude))

  1649.         // Amplitude Interpolation

  1650.         for(int i = 0; i < synth->buffersize; ++i) {

  1651.             float tmpvol = INTERPOLATE_AMPLITUDE(globaloldamplitude,

  1652.                                                  globalnewamplitude,

  1653.                                                  i,

  1654.                                                  synth->buffersize);

  1655.             outl[i] *= tmpvol * NoteGlobalPar.Panning;

  1656.             outr[i] *= tmpvol * (1.0f - NoteGlobalPar.Panning);

  1657.         }

  1658.     else

  1659.         for(int i = 0; i < synth->buffersize; ++i) {

  1660.             outl[i] *= globalnewamplitude * NoteGlobalPar.Panning;

  1661.             outr[i] *= globalnewamplitude * (1.0f - NoteGlobalPar.Panning);

  1662.         }

  1663. 

  1664.     //Apply the punch

  1665.     if(NoteGlobalPar.Punch.Enabled != 0)

  1666.         for(int i = 0; i < synth->buffersize; ++i) {

  1667.             float punchamp = NoteGlobalPar.Punch.initialvalue

  1668.                              * NoteGlobalPar.Punch.t + 1.0f;

  1669.             outl[i] *= punchamp;

  1670.             outr[i] *= punchamp;

  1671.             NoteGlobalPar.Punch.t -= NoteGlobalPar.Punch.dt;

  1672.             if(NoteGlobalPar.Punch.t < 0.0f) {

  1673.                 NoteGlobalPar.Punch.Enabled = 0;

  1674.                 break;

  1675.             }

  1676.         }

  1677. 

  1678. 

  1679.     // Apply legato-specific sound signal modifications

  1680.     legato.apply(*this, outl, outr);

  1681. 

  1682. 

  1683.     // Check if the global amplitude is finished.

  1684.     // If it does, disable the note

  1685.     if(NoteGlobalPar.AmpEnvelope->finished()) {

  1686.         for(int i = 0; i < synth->buffersize; ++i) { //fade-out

  1687.             float tmp = 1.0f - (float)i / synth->buffersize_f;

  1688.             outl[i] *= tmp;

  1689.             outr[i] *= tmp;

  1690.         }

  1691.         KillNote();

  1692.     }

  1693.     return 1;

  1694. }

  1695. 

  1696. 

  1697. /*

  1698.  * Relase the key (NoteOff)

  1699.  */

  1700. void ADnote::relasekey()

  1701. {

  1702.     for(int nvoice = 0; nvoice < NUM_VOICES; ++nvoice)

  1703.         NoteVoicePar[nvoice].releasekey();

  1704.     NoteGlobalPar.FreqEnvelope->relasekey();

  1705.     NoteGlobalPar.FilterEnvelope->relasekey();

  1706.     NoteGlobalPar.AmpEnvelope->relasekey();

  1707. }

  1708. 

  1709. /*

  1710.  * Check if the note is finished

  1711.  */

  1712. int ADnote::finished() const

  1713. {

  1714.     if(NoteEnabled == ON)

  1715.         return 0;

  1716.     else

  1717.         return 1;

  1718. }

  1719. 

  1720. void ADnote::Voice::releasekey()

  1721. {

  1722.     if(!Enabled)

  1723.         return;

  1724.     if(AmpEnvelope)

  1725.         AmpEnvelope->relasekey();

  1726.     if(FreqEnvelope)

  1727.         FreqEnvelope->relasekey();

  1728.     if(FilterEnvelope)

  1729.         FilterEnvelope->relasekey();

  1730.     if(FMFreqEnvelope)

  1731.         FMFreqEnvelope->relasekey();

  1732.     if(FMAmpEnvelope)

  1733.         FMAmpEnvelope->relasekey();

  1734. }

  1735. 

  1736. template<class T>

  1737. static inline void nullify(T &t) {delete t; t = NULL; }

  1738. template<class T>

  1739. static inline void arrayNullify(T &t) {delete [] t; t = NULL; }

  1740. 

  1741. void ADnote::Voice::kill()

  1742. {

  1743.     arrayNullify(OscilSmp);

  1744.     nullify(FreqEnvelope);

  1745.     nullify(FreqLfo);

  1746.     nullify(AmpEnvelope);

  1747.     nullify(AmpLfo);

  1748.     nullify(VoiceFilterL);

  1749.     nullify(VoiceFilterR);

  1750.     nullify(FilterEnvelope);

  1751.     nullify(FilterLfo);

  1752.     nullify(FMFreqEnvelope);

  1753.     nullify(FMAmpEnvelope);

  1754. 

  1755.     if((FMEnabled != NONE) && (FMVoice < 0)) {

  1756.         delete[] FMSmp;

  1757.         FMSmp = NULL;

  1758.     }

  1759. 

  1760.     if(VoiceOut)

  1761.         memset(VoiceOut, 0, synth->bufferbytes);

  1762.     //do not delete, yet: perhaps is used by another voice

  1763. 

  1764.     Enabled = OFF;

  1765. }

  1766. 

  1767. void ADnote::Global::kill()

  1768. {

  1769.     nullify(FreqEnvelope);

  1770.     nullify(FreqLfo);

  1771.     nullify(AmpEnvelope);

  1772.     nullify(AmpLfo);

  1773.     nullify(GlobalFilterL);

  1774.     nullify(GlobalFilterR);

  1775.     nullify(FilterEnvelope);

  1776.     nullify(FilterLfo);

  1777. }

  1778. 

  1779. void ADnote::Global::initparameters(const ADnoteGlobalParam &param,

  1780.                                     float basefreq, float velocity,

  1781.                                     bool stereo)

  1782. {

  1783.     FreqEnvelope = new Envelope(param.FreqEnvelope, basefreq);

  1784.     FreqLfo      = new LFO(param.FreqLfo, basefreq);

  1785. 

  1786.     AmpEnvelope = new Envelope(param.AmpEnvelope, basefreq);

  1787.     AmpLfo      = new LFO(param.AmpLfo, basefreq);

  1788. 

  1789.     Volume = 4.0f * powf(0.1f, 3.0f * (1.0f - param.PVolume / 96.0f)) //-60 dB .. 0 dB

  1790.              * VelF(velocity, param.PAmpVelocityScaleFunction);     //sensing

  1791. 

  1792.     GlobalFilterL = Filter::generate(param.GlobalFilter);

  1793.     if(stereo)

  1794.         GlobalFilterR = Filter::generate(param.GlobalFilter);

  1795.     else

  1796.         GlobalFilterR = NULL;

  1797. 

  1798.     FilterEnvelope = new Envelope(param.FilterEnvelope, basefreq);

  1799.     FilterLfo      = new LFO(param.FilterLfo, basefreq);

  1800.     FilterQ = param.GlobalFilter->getq();

  1801.     FilterFreqTracking = param.GlobalFilter->getfreqtracking(basefreq);

  1802. }