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

1854 lines
69KB
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. #include <cassert>

  27. #include <stdint.h>

  28. 

  29. #include "../globals.h"

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

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

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

  33. #include "../Params/ADnoteParameters.h"

  34. #include "../Params/FilterParams.h"

  35. #include "OscilGen.h"

  36. #include "ADnote.h"

  37. 

  38. ADnote::ADnote(ADnoteParameters *pars_, SynthParams &spars)

  39.     :SynthNote(spars), pars(*pars_)

  40. {

  41.     tmpwavel = memory.valloc<float>(synth.buffersize);

  42.     tmpwaver = memory.valloc<float>(synth.buffersize);

  43.     bypassl  = memory.valloc<float>(synth.buffersize);

  44.     bypassr  = memory.valloc<float>(synth.buffersize);

  45. 

  46.     ADnoteParameters &pars = *pars_;

  47.     portamento  = spars.portamento;

  48.     midinote    = spars.note;

  49.     NoteEnabled = ON;

  50.     basefreq    = spars.frequency;

  51.     velocity    = spars.velocity;

  52.     stereo = pars.GlobalPar.PStereo;

  53. 

  54.     NoteGlobalPar.Detune = getdetune(pars.GlobalPar.PDetuneType,

  55.                                      pars.GlobalPar.PCoarseDetune,

  56.                                      pars.GlobalPar.PDetune);

  57.     bandwidthDetuneMultiplier = pars.getBandwidthDetuneMultiplier();

  58. 

  59.     if(pars.GlobalPar.PPanning == 0)

  60.         NoteGlobalPar.Panning = RND;

  61.     else

  62.         NoteGlobalPar.Panning = pars.GlobalPar.PPanning / 128.0f;

  63. 

  64. 

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

  66.                                       + pars.GlobalPar.PFilterVelocityScale

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

  68.                                       * (VelF(velocity,

  69.                                               pars.GlobalPar.

  70.                                               PFilterVelocityScaleFunction) - 1);

  71. 

  72.     NoteGlobalPar.Fadein_adjustment =

  73.         pars.GlobalPar.Fadein_adjustment / (float)FADEIN_ADJUSTMENT_SCALE;

  74.     NoteGlobalPar.Fadein_adjustment *= NoteGlobalPar.Fadein_adjustment;

  75.     if(pars.GlobalPar.PPunchStrength != 0) {

  76.         NoteGlobalPar.Punch.Enabled = 1;

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

  78.         NoteGlobalPar.Punch.initialvalue =

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

  80.              * VelF(velocity,

  81.                     pars.GlobalPar.PPunchVelocitySensing));

  82.         float time =

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

  84.         float stretch = powf(440.0f / spars.frequency,

  85.                              pars.GlobalPar.PPunchStretch / 64.0f);

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

  87.     }

  88.     else

  89.         NoteGlobalPar.Punch.Enabled = 0;

  90. 

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

  92.         for (int i = 0; i < 14; i++)

  93.             pinking[nvoice][i] = 0.0;

  94. 

  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) {

  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. 	// Since noise unison of greater than two is touch goofy...

  115. 	if (pars.VoicePar[nvoice].Type != 0 && unison > 2)

  116. 	    unison = 2;

  117. 

  118.         //compute unison

  119.         unison_size[nvoice] = unison;

  120. 

  121.         unison_base_freq_rap[nvoice] = memory.valloc<float>(unison);

  122.         unison_freq_rap[nvoice]      = memory.valloc<float>(unison);

  123.         unison_invert_phase[nvoice]  = memory.valloc<bool>(unison);

  124.         float unison_spread =

  125.             pars.getUnisonFrequencySpreadCents(nvoice);

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

  127.         float unison_vibratto_a  =

  128.             pars.VoicePar[nvoice].Unison_vibratto / 127.0f; //0.0f .. 1.0f

  129. 

  130. 

  131.         switch(unison) {

  132.             case 1:

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

  134.                 break;

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

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

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

  138.             };

  139.                 break;

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

  141.                 float unison_values[unison];

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

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

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

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

  146.                     unison_values[k] = val;

  147.                     if (min > val) {

  148.                         min = val;

  149.                     }

  150.                     if (max < val) {

  151.                         max = val;

  152.                     }

  153.                 }

  154.                 float diff = max - min;

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

  156.                     unison_values[k] =

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

  158.                     unison_base_freq_rap[nvoice][k] =

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

  160.                 }

  161.             };

  162.         }

  163. 

  164.         //unison vibrattos

  165.         if(unison > 1)

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

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

  168.                                                   + (unison_base_freq_rap[

  169.                                                          nvoice][k] - 1.0f)

  170.                                                   * (1.0f - unison_vibratto_a);

  171.         unison_vibratto[nvoice].step      = memory.valloc<float>(unison);

  172.         unison_vibratto[nvoice].position  = memory.valloc<float>(unison);

  173.         unison_vibratto[nvoice].amplitude =

  174.             (unison_real_spread - 1.0f) * unison_vibratto_a;

  175. 

  176.         float increments_per_second = synth.samplerate_f / synth.buffersize_f;

  177.         const float vib_speed = pars.VoicePar[nvoice].Unison_vibratto_speed / 127.0f;

  178.         float vibratto_base_period  = 0.25f * powf(2.0f, (1.0f - vib_speed) * 4.0f);

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

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

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

  182.             float vibratto_period = vibratto_base_period

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

  184. 

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

  186.             if(RND < 0.5f)

  187.                 m = -m;

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

  189.         }

  190. 

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

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

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

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

  195.         }

  196. 

  197.         //phase invert for unison

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

  199.         if(unison != 1) {

  200.             int inv = pars.VoicePar[nvoice].Unison_invert_phase;

  201.             switch(inv) {

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

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

  204.                     break;

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

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

  207.                     break;

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

  209.                         unison_invert_phase[nvoice][k] =

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

  211.                     break;

  212.             }

  213.         }

  214. 

  215. 

  216.         oscfreqhi[nvoice]   = memory.valloc<int>(unison);

  217.         oscfreqlo[nvoice]   = memory.valloc<float>(unison);

  218.         oscfreqhiFM[nvoice] = memory.valloc<unsigned int>(unison);

  219.         oscfreqloFM[nvoice] = memory.valloc<float>(unison);

  220.         oscposhi[nvoice]    = memory.valloc<int>(unison);

  221.         oscposlo[nvoice]    = memory.valloc<float>(unison);

  222.         oscposhiFM[nvoice]  = memory.valloc<unsigned int>(unison);

  223.         oscposloFM[nvoice]  = memory.valloc<float>(unison);

  224. 

  225.         NoteVoicePar[nvoice].Enabled     = ON;

  226.         NoteVoicePar[nvoice].fixedfreq   = pars.VoicePar[nvoice].Pfixedfreq;

  227.         NoteVoicePar[nvoice].fixedfreqET = pars.VoicePar[nvoice].PfixedfreqET;

  228. 

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

  230.         if(pars.VoicePar[nvoice].PDetuneType != 0) {

  231.             NoteVoicePar[nvoice].Detune = getdetune(

  232.                 pars.VoicePar[nvoice].PDetuneType,

  233.                 pars.VoicePar[nvoice].

  234.                 PCoarseDetune,

  235.                 8192); //coarse detune

  236.             NoteVoicePar[nvoice].FineDetune = getdetune(

  237.                 pars.VoicePar[nvoice].PDetuneType,

  238.                 0,

  239.                 pars.VoicePar[nvoice].PDetune); //fine detune

  240.         }

  241.         else {

  242.             NoteVoicePar[nvoice].Detune = getdetune(

  243.                 pars.GlobalPar.PDetuneType,

  244.                 pars.VoicePar[nvoice].

  245.                 PCoarseDetune,

  246.                 8192); //coarse detune

  247.             NoteVoicePar[nvoice].FineDetune = getdetune(

  248.                 pars.GlobalPar.PDetuneType,

  249.                 0,

  250.                 pars.VoicePar[nvoice].PDetune); //fine detune

  251.         }

  252.         if(pars.VoicePar[nvoice].PFMDetuneType != 0)

  253.             NoteVoicePar[nvoice].FMDetune = getdetune(

  254.                 pars.VoicePar[nvoice].PFMDetuneType,

  255.                 pars.VoicePar[nvoice].

  256.                 PFMCoarseDetune,

  257.                 pars.VoicePar[nvoice].PFMDetune);

  258.         else

  259.             NoteVoicePar[nvoice].FMDetune = getdetune(

  260.                 pars.GlobalPar.PDetuneType,

  261.                 pars.VoicePar[nvoice].

  262.                 PFMCoarseDetune,

  263.                 pars.VoicePar[nvoice].PFMDetune);

  264. 

  265. 

  266. 

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

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

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

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

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

  272.         }

  273. 

  274.         //the extra points contains the first point

  275.         NoteVoicePar[nvoice].OscilSmp =

  276.             memory.valloc<float>(synth.oscilsize + OSCIL_SMP_EXTRA_SAMPLES);

  277. 

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

  279.         int vc = nvoice;

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

  281.             vc = pars.VoicePar[nvoice].Pextoscil;

  282.         if(!pars.GlobalPar.Hrandgrouping)

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

  284.         int oscposhi_start =

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

  286.                                              getvoicebasefreq(nvoice),

  287.                                              pars.VoicePar[nvoice].Presonance);

  288. 

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

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

  291.             NoteVoicePar[nvoice].OscilSmp[synth.oscilsize

  292.                                           + i] =

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

  294. 

  295.         oscposhi_start +=

  296.             (int)((pars.VoicePar[nvoice].Poscilphase

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

  298.         oscposhi_start %= synth.oscilsize;

  299. 

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

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

  302.             //put random starting point for other subvoices

  303.             oscposhi_start      =

  304.                 (int)(RND * pars.VoicePar[nvoice].Unison_phase_randomness /

  305.                         127.0f * (synth.oscilsize - 1));

  306.         }

  307. 

  308.         NoteVoicePar[nvoice].FreqLfo      = NULL;

  309.         NoteVoicePar[nvoice].FreqEnvelope = NULL;

  310. 

  311.         NoteVoicePar[nvoice].AmpLfo      = NULL;

  312.         NoteVoicePar[nvoice].AmpEnvelope = NULL;

  313. 

  314.         NoteVoicePar[nvoice].VoiceFilterL   = NULL;

  315.         NoteVoicePar[nvoice].VoiceFilterR   = NULL;

  316.         NoteVoicePar[nvoice].FilterEnvelope = NULL;

  317.         NoteVoicePar[nvoice].FilterLfo      = NULL;

  318. 

  319.         NoteVoicePar[nvoice].FilterCenterPitch =

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

  321.             + pars.VoicePar[nvoice].PFilterVelocityScale

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

  323.             * (VelF(velocity,

  324.                     pars.VoicePar[nvoice].PFilterVelocityScaleFunction) - 1);

  325.         NoteVoicePar[nvoice].filterbypass =

  326.             pars.VoicePar[nvoice].Pfilterbypass;

  327. 

  328.         switch(pars.VoicePar[nvoice].PFMEnabled) {

  329.             case 1:

  330.                 NoteVoicePar[nvoice].FMEnabled = MORPH;

  331.                 break;

  332.             case 2:

  333.                 NoteVoicePar[nvoice].FMEnabled = RING_MOD;

  334.                 break;

  335.             case 3:

  336.                 NoteVoicePar[nvoice].FMEnabled = PHASE_MOD;

  337.                 break;

  338.             case 4:

  339.                 NoteVoicePar[nvoice].FMEnabled = FREQ_MOD;

  340.                 break;

  341.             case 5:

  342.                 NoteVoicePar[nvoice].FMEnabled = PITCH_MOD;

  343.                 break;

  344.             default:

  345.                 NoteVoicePar[nvoice].FMEnabled = NONE;

  346.         }

  347. 

  348.         NoteVoicePar[nvoice].FMVoice = pars.VoicePar[nvoice].PFMVoice;

  349.         NoteVoicePar[nvoice].FMFreqEnvelope = NULL;

  350.         NoteVoicePar[nvoice].FMAmpEnvelope  = NULL;

  351. 

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

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

  354.                                    nvoice),

  355.                                pars.VoicePar[nvoice].PFMVolumeDamp / 64.0f

  356.                                - 1.0f);

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

  358.             case PHASE_MOD:

  359.                 fmvoldamp =

  360.                     powf(440.0f / getvoicebasefreq(

  361.                              nvoice), pars.VoicePar[nvoice].PFMVolumeDamp

  362.                          / 64.0f);

  363.                 NoteVoicePar[nvoice].FMVolume =

  364.                     (expf(pars.VoicePar[nvoice].PFMVolume / 127.0f

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

  366.                 break;

  367.             case FREQ_MOD:

  368.                 NoteVoicePar[nvoice].FMVolume =

  369.                     (expf(pars.VoicePar[nvoice].PFMVolume / 127.0f

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

  371.                 break;

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

  373.             //	          break;

  374.             default:

  375.                 if(fmvoldamp > 1.0f)

  376.                     fmvoldamp = 1.0f;

  377.                 NoteVoicePar[nvoice].FMVolume =

  378.                     pars.VoicePar[nvoice].PFMVolume

  379.                     / 127.0f * fmvoldamp;

  380.         }

  381. 

  382.         //Voice's modulator velocity sensing

  383.         NoteVoicePar[nvoice].FMVolume *=

  384.             VelF(velocity,

  385.                  pars.VoicePar[nvoice].PFMVelocityScaleFunction);

  386. 

  387.         FMoldsmp[nvoice] = memory.valloc<float>(unison);

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

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

  390. 

  391.         firsttick[nvoice] = 1;

  392.         NoteVoicePar[nvoice].DelayTicks =

  393.             (int)((expf(pars.VoicePar[nvoice].PDelay / 127.0f

  394.                         * logf(50.0f))

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

  396.     }

  397. 

  398.     max_unison = 1;

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

  400.         if(unison_size[nvoice] > max_unison)

  401.             max_unison = unison_size[nvoice];

  402. 

  403. 

  404.     tmpwave_unison = memory.valloc<float*>(max_unison);

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

  406.         tmpwave_unison[k] = memory.valloc<float>(synth.buffersize);

  407.         memset(tmpwave_unison[k], 0, synth.bufferbytes);

  408.     }

  409. 

  410.     initparameters();

  411. }

  412. 

  413. SynthNote *ADnote::cloneLegato(void)

  414. {

  415.     SynthParams sp{memory, ctl, synth, time, legato.param.freq, velocity, 

  416.                    (bool)portamento, legato.param.midinote, true};

  417.     return memory.alloc<ADnote>(&pars, sp);

  418. }

  419. 

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

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

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

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

  424. void ADnote::legatonote(LegatoParams lpars)

  425. {

  426.     //ADnoteParameters &pars = *partparams;

  427. 

  428.     // Manage legato stuff

  429.     if(legato.update(lpars))

  430.         return;

  431. 

  432.     portamento = lpars.portamento;

  433.     midinote   = lpars.midinote;

  434.     basefreq   = lpars.frequency;

  435. 

  436.     if(velocity > 1.0f)

  437.         velocity = 1.0f;

  438.     velocity = lpars.velocity;

  439. 

  440.     NoteGlobalPar.Detune = getdetune(pars.GlobalPar.PDetuneType,

  441.                                      pars.GlobalPar.PCoarseDetune,

  442.                                      pars.GlobalPar.PDetune);

  443.     bandwidthDetuneMultiplier = pars.getBandwidthDetuneMultiplier();

  444. 

  445.     if(pars.GlobalPar.PPanning == 0)

  446.         NoteGlobalPar.Panning = RND;

  447.     else

  448.         NoteGlobalPar.Panning = pars.GlobalPar.PPanning / 128.0f;

  449. 

  450.     //center freq

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

  452.                                       + pars.GlobalPar.PFilterVelocityScale

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

  454.                                       * (VelF(velocity,

  455.                                               pars.GlobalPar.

  456.                                               PFilterVelocityScaleFunction) - 1);

  457. 

  458. 

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

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

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

  462. 

  463.         NoteVoicePar[nvoice].fixedfreq   = pars.VoicePar[nvoice].Pfixedfreq;

  464.         NoteVoicePar[nvoice].fixedfreqET = pars.VoicePar[nvoice].PfixedfreqET;

  465. 

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

  467.         if(pars.VoicePar[nvoice].PDetuneType != 0) {

  468.             NoteVoicePar[nvoice].Detune = getdetune(

  469.                 pars.VoicePar[nvoice].PDetuneType,

  470.                 pars.VoicePar[nvoice].PCoarseDetune,

  471.                 8192); //coarse detune

  472.             NoteVoicePar[nvoice].FineDetune = getdetune(

  473.                 pars.VoicePar[nvoice].PDetuneType,

  474.                 0,

  475.                 pars.VoicePar[nvoice].PDetune); //fine detune

  476.         }

  477.         else {

  478.             NoteVoicePar[nvoice].Detune = getdetune(

  479.                 pars.GlobalPar.PDetuneType,

  480.                 pars.VoicePar[nvoice].PCoarseDetune,

  481.                 8192); //coarse detune

  482.             NoteVoicePar[nvoice].FineDetune = getdetune(

  483.                 pars.GlobalPar.PDetuneType,

  484.                 0,

  485.                 pars.VoicePar[nvoice].PDetune); //fine detune

  486.         }

  487.         if(pars.VoicePar[nvoice].PFMDetuneType != 0)

  488.             NoteVoicePar[nvoice].FMDetune = getdetune(

  489.                 pars.VoicePar[nvoice].PFMDetuneType,

  490.                 pars.VoicePar[nvoice].PFMCoarseDetune,

  491.                 pars.VoicePar[nvoice].PFMDetune);

  492.         else

  493.             NoteVoicePar[nvoice].FMDetune = getdetune(

  494.                 pars.GlobalPar.PDetuneType,

  495.                 pars.VoicePar[nvoice].PFMCoarseDetune,

  496.                 pars.VoicePar[nvoice].PFMDetune);

  497. 

  498. 

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

  500.         int vc = nvoice;

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

  502.             vc = pars.VoicePar[nvoice].Pextoscil;

  503.         if(!pars.GlobalPar.Hrandgrouping)

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

  505. 

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

  507.                                          getvoicebasefreq(nvoice),

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

  509. 

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

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

  512.             NoteVoicePar[nvoice].OscilSmp[synth.oscilsize

  513.                                           + i] =

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

  515. 

  516. 

  517.         NoteVoicePar[nvoice].FilterCenterPitch =

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

  519.             + pars.VoicePar[nvoice].PFilterVelocityScale

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

  521.             * (VelF(velocity,

  522.                     pars.VoicePar[nvoice].PFilterVelocityScaleFunction) - 1);

  523. 

  524.         NoteVoicePar[nvoice].filterbypass =

  525.             pars.VoicePar[nvoice].Pfilterbypass;

  526. 

  527. 

  528.         NoteVoicePar[nvoice].FMVoice = pars.VoicePar[nvoice].PFMVoice;

  529. 

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

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

  532.                                pars.VoicePar[nvoice].PFMVolumeDamp / 64.0f

  533.                                - 1.0f);

  534. 

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

  536.             case PHASE_MOD:

  537.                 fmvoldamp =

  538.                     powf(440.0f / getvoicebasefreq(

  539.                              nvoice), pars.VoicePar[nvoice].PFMVolumeDamp

  540.                          / 64.0f);

  541.                 NoteVoicePar[nvoice].FMVolume =

  542.                     (expf(pars.VoicePar[nvoice].PFMVolume / 127.0f

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

  544.                 break;

  545.             case FREQ_MOD:

  546.                 NoteVoicePar[nvoice].FMVolume =

  547.                     (expf(pars.VoicePar[nvoice].PFMVolume / 127.0f

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

  549.                 break;

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

  551.             //	          break;

  552.             default:

  553.                 if(fmvoldamp > 1.0f)

  554.                     fmvoldamp = 1.0f;

  555.                 NoteVoicePar[nvoice].FMVolume =

  556.                     pars.VoicePar[nvoice].PFMVolume

  557.                     / 127.0f * fmvoldamp;

  558.         }

  559. 

  560.         //Voice's modulator velocity sensing

  561.         NoteVoicePar[nvoice].FMVolume *=

  562.             VelF(velocity,

  563.                  pars.VoicePar[nvoice].PFMVelocityScaleFunction);

  564. 

  565.         NoteVoicePar[nvoice].DelayTicks =

  566.             (int)((expf(pars.VoicePar[nvoice].PDelay / 127.0f

  567.                         * logf(50.0f))

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

  569.     }

  570. 

  571.     ///    initparameters();

  572. 

  573.     ///////////////

  574.     // Altered content of initparameters():

  575. 

  576.     int tmp[NUM_VOICES];

  577. 

  578.     NoteGlobalPar.Volume = 4.0f

  579.                            * powf(0.1f, 3.0f

  580.                                   * (1.0f - pars.GlobalPar.PVolume

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

  582.                            * VelF(

  583.         velocity,

  584.         pars.GlobalPar.PAmpVelocityScaleFunction); //velocity sensing

  585. 

  586.     globalnewamplitude = NoteGlobalPar.Volume

  587.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  589. 

  590.     NoteGlobalPar.FilterQ = pars.GlobalPar.GlobalFilter->getq();

  591.     NoteGlobalPar.FilterFreqTracking =

  592.         pars.GlobalPar.GlobalFilter->getfreqtracking(basefreq);

  593. 

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

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

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

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

  598. 

  599.     // Voice Parameter init

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

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

  602.             continue;

  603. 

  604.         NoteVoicePar[nvoice].noisetype = pars.VoicePar[nvoice].Type;

  605.         /* Voice Amplitude Parameters Init */

  606.         NoteVoicePar[nvoice].Volume =

  607.             powf(0.1f, 3.0f

  608.                  * (1.0f - pars.VoicePar[nvoice].PVolume / 127.0f))             // -60 dB .. 0 dB

  609.             * VelF(velocity,

  610.                    pars.VoicePar[nvoice].PAmpVelocityScaleFunction); //velocity

  611. 

  612.         if(pars.VoicePar[nvoice].PVolumeminus != 0)

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

  614. 

  615.         if(pars.VoicePar[nvoice].PPanning == 0)

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

  617.         else

  618.             NoteVoicePar[nvoice].Panning =

  619.                 pars.VoicePar[nvoice].PPanning / 128.0f;

  620. 

  621.         newamplitude[nvoice] = 1.0f;

  622.         if(pars.VoicePar[nvoice].PAmpEnvelopeEnabled

  623.            && NoteVoicePar[nvoice].AmpEnvelope)

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

  625. 

  626. 

  627.         if(pars.VoicePar[nvoice].PAmpLfoEnabled && NoteVoicePar[nvoice].AmpLfo)

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

  629. 

  630. 

  631. 

  632.         NoteVoicePar[nvoice].FilterFreqTracking =

  633.             pars.VoicePar[nvoice].VoiceFilter->getfreqtracking(basefreq);

  634. 

  635.         /* Voice Modulation Parameters Init */

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

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

  638.             pars.VoicePar[nvoice].FMSmp->newrandseed(prng());

  639. 

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

  641. 

  642.             int vc = nvoice;

  643.             if(pars.VoicePar[nvoice].PextFMoscil != -1)

  644.                 vc = pars.VoicePar[nvoice].PextFMoscil;

  645. 

  646.             if(!pars.GlobalPar.Hrandgrouping)

  647.                 pars.VoicePar[vc].FMSmp->newrandseed(prng());

  648. 

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

  650.                 NoteVoicePar[nvoice].FMSmp[synth.oscilsize + i] =

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

  652.         }

  653. 

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

  655.                                  * ctl.fmamp.relamp;

  656. 

  657.         if(pars.VoicePar[nvoice].PFMAmpEnvelopeEnabled

  658.            && NoteVoicePar[nvoice].FMAmpEnvelope)

  659.             FMnewamplitude[nvoice] *=

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

  661.     }

  662. 

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

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

  665.             tmp[i] = 0;

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

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

  668.                 tmp[i] = 1;

  669.     }

  670. }

  671. 

  672. 

  673. /*

  674.  * Kill a voice of ADnote

  675.  */

  676. void ADnote::KillVoice(int nvoice)

  677. {

  678.     memory.devalloc(oscfreqhi[nvoice]);

  679.     memory.devalloc(oscfreqlo[nvoice]);

  680.     memory.devalloc(oscfreqhiFM[nvoice]);

  681.     memory.devalloc(oscfreqloFM[nvoice]);

  682.     memory.devalloc(oscposhi[nvoice]);

  683.     memory.devalloc(oscposlo[nvoice]);

  684.     memory.devalloc(oscposhiFM[nvoice]);

  685.     memory.devalloc(oscposloFM[nvoice]);

  686. 

  687.     memory.devalloc(unison_base_freq_rap[nvoice]);

  688.     memory.devalloc(unison_freq_rap[nvoice]);

  689.     memory.devalloc(unison_invert_phase[nvoice]);

  690.     memory.devalloc(FMoldsmp[nvoice]);

  691.     memory.devalloc(unison_vibratto[nvoice].step);

  692.     memory.devalloc(unison_vibratto[nvoice].position);

  693. 

  694.     NoteVoicePar[nvoice].kill(memory, synth);

  695. }

  696. 

  697. /*

  698.  * Kill the note

  699.  */

  700. void ADnote::KillNote()

  701. {

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

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

  704.             KillVoice(nvoice);

  705. 

  706.         if(NoteVoicePar[nvoice].VoiceOut)

  707.             memory.dealloc(NoteVoicePar[nvoice].VoiceOut);

  708.     }

  709. 

  710.     NoteGlobalPar.kill(memory);

  711. 

  712.     NoteEnabled = OFF;

  713. }

  714. 

  715. ADnote::~ADnote()

  716. {

  717.     if(NoteEnabled == ON)

  718.         KillNote();

  719.     memory.devalloc(tmpwavel);

  720.     memory.devalloc(tmpwaver);

  721.     memory.devalloc(bypassl);

  722.     memory.devalloc(bypassr);

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

  724.         memory.devalloc(tmpwave_unison[k]);

  725.     memory.devalloc(tmpwave_unison);

  726. }

  727. 

  728. 

  729. /*

  730.  * Init the parameters

  731.  */

  732. void ADnote::initparameters()

  733. {

  734.     int tmp[NUM_VOICES];

  735.     //ADnoteParameters &pars = *partparams;

  736. 

  737.     // Global Parameters

  738.     NoteGlobalPar.initparameters(pars.GlobalPar, synth,

  739.                                  time,

  740.                                  memory, basefreq, velocity,

  741.                                  stereo);

  742. 

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

  744.     globalnewamplitude = NoteGlobalPar.Volume

  745.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  747. 

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

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

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

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

  752. 

  753.     // Voice Parameter init

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

  755.         Voice &vce = NoteVoicePar[nvoice];

  756.         ADnoteVoiceParam &param = pars.VoicePar[nvoice];

  757. 

  758.         if(vce.Enabled == 0)

  759.             continue;

  760. 

  761.         vce.noisetype = param.Type;

  762.         /* Voice Amplitude Parameters Init */

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

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

  765. 

  766.         if(param.PVolumeminus)

  767.             vce.Volume = -vce.Volume;

  768. 

  769.         if(param.PPanning == 0)

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

  771.         else

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

  773. 

  774.         newamplitude[nvoice] = 1.0f;

  775.         if(param.PAmpEnvelopeEnabled) {

  776.             vce.AmpEnvelope = memory.alloc<Envelope>(*param.AmpEnvelope, basefreq, synth.dt());

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

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

  779.         }

  780. 

  781.         if(param.PAmpLfoEnabled) {

  782.             vce.AmpLfo = memory.alloc<LFO>(*param.AmpLfo, basefreq, time);

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

  784.         }

  785. 

  786.         /* Voice Frequency Parameters Init */

  787.         if(param.PFreqEnvelopeEnabled)

  788.             vce.FreqEnvelope = memory.alloc<Envelope>(*param.FreqEnvelope, basefreq, synth.dt());

  789. 

  790.         if(param.PFreqLfoEnabled)

  791.             vce.FreqLfo = memory.alloc<LFO>(*param.FreqLfo, basefreq, time);

  792. 

  793.         /* Voice Filter Parameters Init */

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

  795.             vce.VoiceFilterL = Filter::generate(memory, param.VoiceFilter,

  796.                     synth.samplerate, synth.buffersize);

  797.             vce.VoiceFilterR = Filter::generate(memory, param.VoiceFilter,

  798.                     synth.samplerate, synth.buffersize);

  799.         }

  800. 

  801.         if(param.PFilterEnvelopeEnabled)

  802.             vce.FilterEnvelope = memory.alloc<Envelope>(*param.FilterEnvelope, basefreq, synth.dt());

  803. 

  804.         if(param.PFilterLfoEnabled)

  805.             vce.FilterLfo = memory.alloc<LFO>(*param.FilterLfo, basefreq, time);

  806. 

  807.         vce.FilterFreqTracking =

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

  809. 

  810.         /* Voice Modulation Parameters Init */

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

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

  813.             vce.FMSmp = memory.valloc<float>(synth.oscilsize + OSCIL_SMP_EXTRA_SAMPLES);

  814. 

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

  816. 

  817.             int vc = nvoice;

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

  819.                 vc = param.PextFMoscil;

  820. 

  821.             float tmp = 1.0f;

  822.             if((pars.VoicePar[vc].FMSmp->Padaptiveharmonics != 0)

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

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

  825.                 tmp = getFMvoicebasefreq(nvoice);

  826. 

  827.             if(!pars.GlobalPar.Hrandgrouping)

  828.                 pars.VoicePar[vc].FMSmp->newrandseed(prng());

  829. 

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

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

  832.                                          + pars.VoicePar[vc].FMSmp->get(

  833.                                              vce.FMSmp, tmp))

  834.                                         % synth.oscilsize;

  835. 

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

  837.                 vce.FMSmp[synth.oscilsize + i] = vce.FMSmp[i];

  838.             int oscposhiFM_add =

  839.                 (int)((param.PFMoscilphase

  840.                        - 64.0f) / 128.0f * synth.oscilsize

  841.                       + synth.oscilsize * 4);

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

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

  844.                 oscposhiFM[nvoice][k] %= synth.oscilsize;

  845.             }

  846.         }

  847. 

  848.         if(param.PFMFreqEnvelopeEnabled)

  849.             vce.FMFreqEnvelope = memory.alloc<Envelope>(*param.FMFreqEnvelope, basefreq, synth.dt());

  850. 

  851.         FMnewamplitude[nvoice] = vce.FMVolume * ctl.fmamp.relamp;

  852. 

  853.         if(param.PFMAmpEnvelopeEnabled ) {

  854.             vce.FMAmpEnvelope =

  855.                 memory.alloc<Envelope>(*param.FMAmpEnvelope, basefreq, synth.dt());

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

  857.         }

  858.     }

  859. 

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

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

  862.             tmp[i] = 0;

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

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

  865.                 NoteVoicePar[nvoice].VoiceOut =

  866.                     memory.valloc<float>(synth.buffersize);

  867.                 tmp[i] = 1;

  868.             }

  869. 

  870.         if(NoteVoicePar[nvoice].VoiceOut)

  871.             memset(NoteVoicePar[nvoice].VoiceOut, 0, synth.bufferbytes);

  872.     }

  873. }

  874. 

  875. 

  876. /*

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

  878.  * This must be called before setfreq* functions

  879.  */

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

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

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

  883.         return;

  884.     }

  885.     float relbw = ctl.bandwidth.relbw * bandwidthDetuneMultiplier;

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

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

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

  889.         pos += step;

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

  891.             pos  = -1.0f;

  892.             step = -step;

  893.         }

  894.         if(pos >= 1.0f) {

  895.             pos  = 1.0f;

  896.             step = -step;

  897.         }

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

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

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

  901.                                          - 1.0f) + vibratto_val

  902.                                         * unison_vibratto[nvoice].amplitude)

  903.                                      * relbw;

  904. 

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

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

  907.     }

  908. }

  909. 

  910. 

  911. /*

  912.  * Computes the frequency of an oscillator

  913.  */

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

  915. {

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

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

  918.         float speed = freq * synth.oscilsize_f / synth.samplerate_f;

  919.         if(speed > synth.oscilsize_f)

  920.             speed = synth.oscilsize_f;

  921. 

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

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

  924.     }

  925. }

  926. 

  927. /*

  928.  * Computes the frequency of an modullator oscillator

  929.  */

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

  931. {

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

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

  934.         float speed = freq * synth.oscilsize_f / synth.samplerate_f;

  935.         if(speed > synth.samplerate_f)

  936.             speed = synth.samplerate_f;

  937. 

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

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

  940.     }

  941. }

  942. 

  943. /*

  944.  * Get Voice base frequency

  945.  */

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

  947. {

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

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

  950.                    * ctl.bandwidth.relbw * bandwidthDetuneMultiplier

  951.                    + NoteGlobalPar.Detune / 100.0f;

  952. 

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

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

  955.     else { //the fixed freq is enabled

  956.         float fixedfreq   = 440.0f;

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

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

  959.             float tmp =

  960.                 (midinote

  961.                  - 69.0f) / 12.0f

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

  963.             if(fixedfreqET <= 64)

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

  965.             else

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

  967.         }

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

  969.     }

  970. }

  971. 

  972. /*

  973.  * Get Voice's Modullator base frequency

  974.  */

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

  976. {

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

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

  979. }

  980. 

  981. /*

  982.  * Computes all the parameters for each tick

  983.  */

  984. void ADnote::computecurrentparameters()

  985. {

  986.     int   nvoice;

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

  988.           FMrelativepitch, globalpitch, globalfilterpitch;

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

  990.                            + NoteGlobalPar.FreqLfo->lfoout()

  991.                            * ctl.modwheel.relmod);

  992.     globaloldamplitude = globalnewamplitude;

  993.     globalnewamplitude = NoteGlobalPar.Volume

  994.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  996. 

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

  998.                         + NoteGlobalPar.FilterLfo->lfoout()

  999.                         + NoteGlobalPar.FilterCenterPitch;

  1000. 

  1001.     float tmpfilterfreq = globalfilterpitch + ctl.filtercutoff.relfreq

  1002.                           + NoteGlobalPar.FilterFreqTracking;

  1003. 

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

  1005. 

  1006.     float globalfilterq = NoteGlobalPar.FilterQ * ctl.filterq.relq;

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

  1008.     if(stereo != 0)

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

  1010. 

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

  1012.     float portamentofreqrap = 1.0f;

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

  1014.         portamentofreqrap = ctl.portamento.freqrap;

  1015.         if(ctl.portamento.used == 0) //the portamento has finished

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

  1017.     }

  1018. 

  1019.     //compute parameters for all voices

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

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

  1022.             continue;

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

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

  1025.             continue;

  1026. 

  1027.         compute_unison_freq_rap(nvoice);

  1028. 

  1029.         /*******************/

  1030.         /* Voice Amplitude */

  1031.         /*******************/

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

  1033.         newamplitude[nvoice] = 1.0f;

  1034. 

  1035.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

  1037. 

  1038.         if(NoteVoicePar[nvoice].AmpLfo)

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

  1040. 

  1041.         /****************/

  1042.         /* Voice Filter */

  1043.         /****************/

  1044.         if(NoteVoicePar[nvoice].VoiceFilterL) {

  1045.             filterpitch = NoteVoicePar[nvoice].FilterCenterPitch;

  1046. 

  1047.             if(NoteVoicePar[nvoice].FilterEnvelope)

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

  1049. 

  1050.             if(NoteVoicePar[nvoice].FilterLfo)

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

  1052. 

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

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

  1055. 

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

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

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

  1059.         }

  1060. 

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

  1062.             /*******************/

  1063.             /* Voice Frequency */

  1064.             /*******************/

  1065.             voicepitch = 0.0f;

  1066.             if(NoteVoicePar[nvoice].FreqLfo)

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

  1068.                               * ctl.bandwidth.relbw;

  1069. 

  1070.             if(NoteVoicePar[nvoice].FreqEnvelope)

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

  1072.                               / 100.0f;

  1073.             voicefreq = getvoicebasefreq(nvoice)

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

  1075.             voicefreq *= ctl.pitchwheel.relfreq; //change the frequency by the controller

  1076.             setfreq(nvoice, voicefreq * portamentofreqrap);

  1077. 

  1078.             /***************/

  1079.             /*  Modulator */

  1080.             /***************/

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

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

  1083.                 if(NoteVoicePar[nvoice].FMFreqEnvelope)

  1084.                     FMrelativepitch +=

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

  1086.                 FMfreq =

  1087.                     powf(2.0f, FMrelativepitch

  1088.                          / 12.0f) * voicefreq * portamentofreqrap;

  1089.                 setfreqFM(nvoice, FMfreq);

  1090. 

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

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

  1093.                                          * ctl.fmamp.relamp;

  1094.                 if(NoteVoicePar[nvoice].FMAmpEnvelope)

  1095.                     FMnewamplitude[nvoice] *=

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

  1097.             }

  1098.         }

  1099.     }

  1100. }

  1101. 

  1102. 

  1103. /*

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

  1105.  */

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

  1107. {

  1108.     int zerocrossings = 0;

  1109.     for(int i = 1; i < synth.buffersize; ++i)

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

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

  1112. 

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

  1114.     if(tmp < 8.0f)

  1115.         tmp = 8.0f;

  1116.     tmp *= NoteGlobalPar.Fadein_adjustment;

  1117. 

  1118.     int n;

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

  1120.     if(n > synth.buffersize)

  1121.         n = synth.buffersize;

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

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

  1124.         smps[i] *= tmp;

  1125.     }

  1126. }

  1127. 

  1128. /*

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

  1130.  */

  1131. 

  1132. /* As the code here is a bit odd due to optimization, here is what happens

  1133.  * First the current possition and frequency are retrieved from the running

  1134.  * state. These are broken up into high and low portions to indicate how many

  1135.  * samples are skipped in one step and how many fractional samples are skipped.

  1136.  * Outside of this method the fractional samples are just handled with floating

  1137.  * point code, but that's a bit slower than it needs to be. In this code the low

  1138.  * portions are known to exist between 0.0 and 1.0 and it is known that they are

  1139.  * stored in single precision floating point IEEE numbers. This implies that

  1140.  * a maximum of 24 bits are significant. The below code does your standard

  1141.  * linear interpolation that you'll see throughout this codebase, but by

  1142.  * sticking to integers for tracking the overflow of the low portion, around 15%

  1143.  * of the execution time was shaved off in the ADnote test.

  1144.  */

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

  1146. {

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

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

  1149.         int    poslo  = oscposlo[nvoice][k] * (1<<24);

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

  1151.         int    freqlo = oscfreqlo[nvoice][k] * (1<<24);

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

  1153.         float *tw     = tmpwave_unison[k];

  1154.         assert(oscfreqlo[nvoice][k] < 1.0f);

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

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

  1157.             poslo += freqlo;

  1158.             poshi += freqhi + (poslo>>24);

  1159.             poslo &= 0xffffff;

  1160.             poshi &= synth.oscilsize - 1;

  1161.         }

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

  1163.         oscposlo[nvoice][k] = poslo/(1.0f*(1<<24));

  1164.     }

  1165. }

  1166. 

  1167. 

  1168. 

  1169. /*

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

  1171.  *

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

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

  1174.     int i,poshi;

  1175.     float poslo;

  1176. 

  1177.     poshi=oscposhi[nvoice];

  1178.     poslo=oscposlo[nvoice];

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

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

  1181.     for (i=0;i<synth.buffersize;i++){

  1182.     xm1=smps[poshi];

  1183.     x0=smps[poshi+1];

  1184.     x1=smps[poshi+2];

  1185.     x2=smps[poshi+3];

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

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

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

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

  1190.     printf("a\n");

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

  1192.     poslo+=oscfreqlo[nvoice];

  1193.     if (poslo>=1.0f) {

  1194.             poslo-=1.0f;

  1195.         poshi++;

  1196.     };

  1197.         poshi+=oscfreqhi[nvoice];

  1198.         poshi&=synth.oscilsize-1;

  1199.     };

  1200.     oscposhi[nvoice]=poshi;

  1201.     oscposlo[nvoice]=poslo;

  1202. };

  1203. */

  1204. /*

  1205.  * Computes the Oscillator (Morphing)

  1206.  */

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

  1208. {

  1209.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1211.         FMnewamplitude[nvoice] = 1.0f;

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

  1213.         FMoldamplitude[nvoice] = 1.0f;

  1214. 

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

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

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

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

  1219.             float *tw = tmpwave_unison[k];

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

  1221.                 float amp = INTERPOLATE_AMPLITUDE(FMoldamplitude[nvoice],

  1222.                                             FMnewamplitude[nvoice],

  1223.                                             i,

  1224.                                             synth.buffersize);

  1225.                 tw[i] = tw[i]

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

  1227.             }

  1228.         }

  1229.     }

  1230.     else

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

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

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

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

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

  1236.             float *tw = tmpwave_unison[k];

  1237. 

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

  1239.                 float amp = INTERPOLATE_AMPLITUDE(FMoldamplitude[nvoice],

  1240.                                             FMnewamplitude[nvoice],

  1241.                                             i,

  1242.                                             synth.buffersize);

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

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

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

  1246.                 posloFM += freqloFM;

  1247.                 if(posloFM >= 1.0f) {

  1248.                     posloFM -= 1.0f;

  1249.                     poshiFM++;

  1250.                 }

  1251.                 poshiFM += freqhiFM;

  1252.                 poshiFM &= synth.oscilsize - 1;

  1253.             }

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

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

  1256.         }

  1257. }

  1258. 

  1259. /*

  1260.  * Computes the Oscillator (Ring Modulation)

  1261.  */

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

  1263. {

  1264.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1266.         FMnewamplitude[nvoice] = 1.0f;

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

  1268.         FMoldamplitude[nvoice] = 1.0f;

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

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

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

  1272.             float *tw = tmpwave_unison[k];

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

  1274.                 float amp = INTERPOLATE_AMPLITUDE(FMoldamplitude[nvoice],

  1275.                                             FMnewamplitude[nvoice],

  1276.                                             i,

  1277.                                             synth.buffersize);

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

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

  1280.             }

  1281.         }

  1282.     else

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

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

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

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

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

  1288.             float *tw = tmpwave_unison[k];

  1289. 

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

  1291.                 float amp = INTERPOLATE_AMPLITUDE(FMoldamplitude[nvoice],

  1292.                                             FMnewamplitude[nvoice],

  1293.                                             i,

  1294.                                             synth.buffersize);

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

  1296.                           + NoteVoicePar[nvoice].FMSmp[poshiFM

  1297.                                                        + 1] * posloFM) * amp

  1298.                          + (1.0f - amp);

  1299.                 posloFM += freqloFM;

  1300.                 if(posloFM >= 1.0f) {

  1301.                     posloFM -= 1.0f;

  1302.                     poshiFM++;

  1303.                 }

  1304.                 poshiFM += freqhiFM;

  1305.                 poshiFM &= synth.oscilsize - 1;

  1306.             }

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

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

  1309.         }

  1310. }

  1311. 

  1312. /*

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

  1314.  */

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

  1316.                                                               int FMmode)

  1317. {

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

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

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

  1321.             float *tw = tmpwave_unison[k];

  1322.             const float *smps = NoteVoicePar[NoteVoicePar[nvoice].FMVoice].VoiceOut;

  1323.             memcpy(tw, smps, synth.bufferbytes);

  1324.         }

  1325.     } else {

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

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

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

  1329.             int    posloFM  = oscposloFM[nvoice][k]  * (1<<24);

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

  1331.             int    freqloFM = oscfreqloFM[nvoice][k] * (1<<24);

  1332.             float *tw = tmpwave_unison[k];

  1333.             const float *smps = NoteVoicePar[nvoice].FMSmp;

  1334. 

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

  1336.                 tw[i] = (smps[poshiFM] * ((1<<24) - posloFM)

  1337.                      + smps[poshiFM + 1] * posloFM) / (1.0f*(1<<24));

  1338.                 posloFM += freqloFM;

  1339.                 if(posloFM >= (1<<24)) {

  1340.                     posloFM &= 0xffffff;//fmod(posloFM, 1.0f);

  1341.                     poshiFM++;

  1342.                 }

  1343.                 poshiFM += freqhiFM;

  1344.                 poshiFM &= synth.oscilsize - 1;

  1345.             }

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

  1347.             oscposloFM[nvoice][k] = posloFM/((1<<24)*1.0f);

  1348.         }

  1349.     }

  1350.     // Amplitude interpolation

  1351.     if(ABOVE_AMPLITUDE_THRESHOLD(FMoldamplitude[nvoice],

  1352.                                  FMnewamplitude[nvoice])) {

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

  1354.             float *tw = tmpwave_unison[k];

  1355.             for(int i = 0; i < synth.buffersize; ++i)

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

  1357.                                                FMnewamplitude[nvoice],

  1358.                                                i,

  1359.                                                synth.buffersize);

  1360.         }

  1361.     } else {

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

  1363.             float *tw = tmpwave_unison[k];

  1364.             for(int i = 0; i < synth.buffersize; ++i)

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

  1366.         }

  1367.     }

  1368. 

  1369. 

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

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

  1372.         const float normalize = synth.oscilsize_f / 262144.0f * 44100.0f

  1373.                           / synth.samplerate_f;

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

  1375.             float *tw    = tmpwave_unison[k];

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

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

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

  1379.                 tw[i] = fmold;

  1380.             }

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

  1382.         }

  1383.     }

  1384.     else {  //Phase modulation

  1385.         const float normalize = synth.oscilsize_f / 262144.0f;

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

  1387.             float *tw = tmpwave_unison[k];

  1388.             for(int i = 0; i < synth.buffersize; ++i)

  1389.                 tw[i] *= normalize;

  1390.         }

  1391.     }

  1392. 

  1393.     //do the modulation

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

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

  1396.         float *tw     = tmpwave_unison[k];

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

  1398.         int    poslo  = oscposlo[nvoice][k] * (1<<24);

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

  1400.         int    freqlo = oscfreqlo[nvoice][k] * (1<<24);

  1401. 

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

  1403.             int FMmodfreqhi = 0;

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

  1405.             float FMmodfreqlo = tw[i]-FMmodfreqhi;//fmod(tw[i] /*+ 0.0000000001f*/, 1.0f);

  1406.             if(FMmodfreqhi < 0)

  1407.                 FMmodfreqlo++;

  1408. 

  1409.             //carrier

  1410.             int carposhi = poshi + FMmodfreqhi;

  1411.             int carposlo = poslo + FMmodfreqlo;

  1412. 

  1413.             if(carposlo >= (1<<24)) {

  1414.                 carposhi++;

  1415.                 carposlo &= 0xffffff;//fmod(carposlo, 1.0f);

  1416.             }

  1417.             carposhi &= (synth.oscilsize - 1);

  1418. 

  1419.             tw[i] = (smps[carposhi] * ((1<<24) - carposlo)

  1420.                     + smps[carposhi + 1] * carposlo)/(1.0f*(1<<24));

  1421. 

  1422.             poslo += freqlo;

  1423.             if(poslo >= (1<<24)) {

  1424.                 poslo &= 0xffffff;//fmod(poslo, 1.0f);

  1425.                 poshi++;

  1426.             }

  1427. 

  1428.             poshi += freqhi;

  1429.             poshi &= synth.oscilsize - 1;

  1430.         }

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

  1432.         oscposlo[nvoice][k] = (poslo)/((1<<24)*1.0f);

  1433.     }

  1434. }

  1435. 

  1436. 

  1437. /*Calculeaza Oscilatorul cu PITCH MODULATION*/

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

  1439. {

  1440. //TODO

  1441. }

  1442. 

  1443. /*

  1444.  * Computes the Noise

  1445.  */

  1446. inline void ADnote::ComputeVoiceWhiteNoise(int nvoice)

  1447. {

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

  1449.         float *tw = tmpwave_unison[k];

  1450.         for(int i = 0; i < synth.buffersize; ++i)

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

  1452.     }

  1453. }

  1454. 

  1455. inline void ADnote::ComputeVoicePinkNoise(int nvoice)

  1456. {

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

  1458.         float *tw = tmpwave_unison[k];

  1459.         float *f = &pinking[nvoice][k > 0 ? 7 : 0];

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

  1461. 	    float white = (RND-0.5)/4.0;

  1462. 	    f[0] = 0.99886*f[0]+white*0.0555179;

  1463. 	    f[1] = 0.99332*f[1]+white*0.0750759;

  1464. 	    f[2] = 0.96900*f[2]+white*0.1538520;

  1465. 	    f[3] = 0.86650*f[3]+white*0.3104856;

  1466. 	    f[4] = 0.55000*f[4]+white*0.5329522;

  1467. 	    f[5] = -0.7616*f[5]-white*0.0168980;

  1468. 	    tw[i] = f[0]+f[1]+f[2]+f[3]+f[4]+f[5]+f[6]+white*0.5362;

  1469. 	    f[6] = white*0.115926;

  1470.         }

  1471.     }

  1472. }

  1473. 

  1474. 

  1475. 

  1476. /*

  1477.  * Compute the ADnote samples

  1478.  * Returns 0 if the note is finished

  1479.  */

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

  1481. {

  1482.     memcpy(outl, synth.denormalkillbuf, synth.bufferbytes);

  1483.     memcpy(outr, synth.denormalkillbuf, synth.bufferbytes);

  1484. 

  1485.     if(NoteEnabled == OFF)

  1486.         return 0;

  1487. 

  1488.     memset(bypassl, 0, synth.bufferbytes);

  1489.     memset(bypassr, 0, synth.bufferbytes);

  1490.     computecurrentparameters();

  1491. 

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

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

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

  1495.             continue;

  1496.         switch (NoteVoicePar[nvoice].noisetype) {

  1497.             case 0: //voice mode=sound

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

  1499.                     case MORPH:

  1500.                         ComputeVoiceOscillatorMorph(nvoice);

  1501.                         break;

  1502.                     case RING_MOD:

  1503.                         ComputeVoiceOscillatorRingModulation(nvoice);

  1504.                         break;

  1505.                     case PHASE_MOD:

  1506.                         ComputeVoiceOscillatorFrequencyModulation(nvoice, 0);

  1507.                         break;

  1508.                     case FREQ_MOD:

  1509.                         ComputeVoiceOscillatorFrequencyModulation(nvoice, 1);

  1510.                         break;

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

  1512.                     default:

  1513.                         ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1515.                 }

  1516.                 break;

  1517.             case 1:

  1518.                 ComputeVoiceWhiteNoise(nvoice);

  1519.                 break;

  1520.             default:

  1521.                 ComputeVoicePinkNoise(nvoice);

  1522.                 break;

  1523.         }

  1524.         // Voice Processing

  1525. 

  1526. 

  1527.         //mix subvoices into voice

  1528.         memset(tmpwavel, 0, synth.bufferbytes);

  1529.         if(stereo)

  1530.             memset(tmpwaver, 0, synth.bufferbytes);

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

  1532.             float *tw = tmpwave_unison[k];

  1533.             if(stereo) {

  1534.                 float stereo_pos = 0;

  1535.                 if(unison_size[nvoice] > 1)

  1536.                     stereo_pos = k

  1537.                                  / (float)(unison_size[nvoice]

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

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

  1540.                 if(stereo_spread > 1.0f) {

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

  1542.                     stereo_pos =

  1543.                         (2.0f

  1544.                          - stereo_spread) * stereo_pos

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

  1546.                 }

  1547.                 else

  1548.                     stereo_pos *= stereo_spread;

  1549. 

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

  1551.                     stereo_pos = 0.0f;

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

  1553. 

  1554. 

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

  1556.                 if(lvol > 1.0f)

  1557.                     lvol = 1.0f;

  1558. 

  1559.                 float rvol = panning * 2.0f;

  1560.                 if(rvol > 1.0f)

  1561.                     rvol = 1.0f;

  1562. 

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

  1564.                     lvol = -lvol;

  1565.                     rvol = -rvol;

  1566.                 }

  1567. 

  1568.                 for(int i = 0; i < synth.buffersize; ++i)

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

  1570.                 for(int i = 0; i < synth.buffersize; ++i)

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

  1572.             }

  1573.             else

  1574.                 for(int i = 0; i < synth.buffersize; ++i)

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

  1576.         }

  1577. 

  1578. 

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

  1580.         // Amplitude

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

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

  1583. 

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

  1585.             int rest = synth.buffersize;

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

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

  1588.                 rest = 10;

  1589.                 if(rest > synth.buffersize)

  1590.                     rest = synth.buffersize;

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

  1592.                     tmpwavel[i] *= oldam;

  1593.                 if(stereo)

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

  1595.                         tmpwaver[i] *= oldam;

  1596.             }

  1597.             // Amplitude interpolation

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

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

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

  1601.                 if(stereo)

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

  1603.             }

  1604.         }

  1605.         else {

  1606.             for(int i = 0; i < synth.buffersize; ++i)

  1607.                 tmpwavel[i] *= newam;

  1608.             if(stereo)

  1609.                 for(int i = 0; i < synth.buffersize; ++i)

  1610.                     tmpwaver[i] *= newam;

  1611.         }

  1612. 

  1613.         // Fade in

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

  1615.             fadein(&tmpwavel[0]);

  1616.             if(stereo)

  1617.                 fadein(&tmpwaver[0]);

  1618.             firsttick[nvoice] = 0;

  1619.         }

  1620. 

  1621. 

  1622.         // Filter

  1623.         if(NoteVoicePar[nvoice].VoiceFilterL)

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

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

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

  1627. 

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

  1629.         if(NoteVoicePar[nvoice].AmpEnvelope)

  1630.             if(NoteVoicePar[nvoice].AmpEnvelope->finished()) {

  1631.                 for(int i = 0; i < synth.buffersize; ++i)

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

  1633.                 if(stereo)

  1634.                     for(int i = 0; i < synth.buffersize; ++i)

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

  1636.             }

  1637.         //the voice is killed later

  1638. 

  1639. 

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

  1641.         if(NoteVoicePar[nvoice].VoiceOut) {

  1642.             if(stereo)

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

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

  1645.                                                        + tmpwaver[i];

  1646.             else   //mono

  1647.                 for(int i = 0; i < synth.buffersize; ++i)

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

  1649.         }

  1650. 

  1651. 

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

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

  1654.             if(stereo)

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

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

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

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

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

  1660.                 }

  1661.             else

  1662.                 for(int i = 0; i < synth.buffersize; ++i) //mono

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

  1664.         }

  1665.         else {  //bypass the filter

  1666.             if(stereo)

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

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

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

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

  1671.                                   * (1.0f

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

  1673.                 }

  1674.             else

  1675.                 for(int i = 0; i < synth.buffersize; ++i) //mono

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

  1677.         }

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

  1679.         if(NoteVoicePar[nvoice].AmpEnvelope)

  1680.             if(NoteVoicePar[nvoice].AmpEnvelope->finished())

  1681.                 KillVoice(nvoice);

  1682.     }

  1683. 

  1684. 

  1685.     //Processing Global parameters

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

  1687. 

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

  1689.         memcpy(outr, outl, synth.bufferbytes);

  1690.         memcpy(bypassr, bypassl, synth.bufferbytes);

  1691.     }

  1692.     else

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

  1694. 

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

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

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

  1698.     }

  1699. 

  1700.     if(ABOVE_AMPLITUDE_THRESHOLD(globaloldamplitude, globalnewamplitude))

  1701.         // Amplitude Interpolation

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

  1703.             float tmpvol = INTERPOLATE_AMPLITUDE(globaloldamplitude,

  1704.                                                  globalnewamplitude,

  1705.                                                  i,

  1706.                                                  synth.buffersize);

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

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

  1709.         }

  1710.     else

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

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

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

  1714.         }

  1715. 

  1716.     //Apply the punch

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

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

  1719.             float punchamp = NoteGlobalPar.Punch.initialvalue

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

  1721.             outl[i] *= punchamp;

  1722.             outr[i] *= punchamp;

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

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

  1725.                 NoteGlobalPar.Punch.Enabled = 0;

  1726.                 break;

  1727.             }

  1728.         }

  1729. 

  1730. 

  1731.     // Apply legato-specific sound signal modifications

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

  1733. 

  1734. 

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

  1736.     // If it does, disable the note

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

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

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

  1740.             outl[i] *= tmp;

  1741.             outr[i] *= tmp;

  1742.         }

  1743.         KillNote();

  1744.     }

  1745.     return 1;

  1746. }

  1747. 

  1748. 

  1749. /*

  1750.  * Release the key (NoteOff)

  1751.  */

  1752. void ADnote::releasekey()

  1753. {

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

  1755.         NoteVoicePar[nvoice].releasekey();

  1756.     NoteGlobalPar.FreqEnvelope->releasekey();

  1757.     NoteGlobalPar.FilterEnvelope->releasekey();

  1758.     NoteGlobalPar.AmpEnvelope->releasekey();

  1759. }

  1760. 

  1761. /*

  1762.  * Check if the note is finished

  1763.  */

  1764. int ADnote::finished() const

  1765. {

  1766.     if(NoteEnabled == ON)

  1767.         return 0;

  1768.     else

  1769.         return 1;

  1770. }

  1771. 

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

  1773. {

  1774.     if(!Enabled)

  1775.         return;

  1776.     if(AmpEnvelope)

  1777.         AmpEnvelope->releasekey();

  1778.     if(FreqEnvelope)

  1779.         FreqEnvelope->releasekey();

  1780.     if(FilterEnvelope)

  1781.         FilterEnvelope->releasekey();

  1782.     if(FMFreqEnvelope)

  1783.         FMFreqEnvelope->releasekey();

  1784.     if(FMAmpEnvelope)

  1785.         FMAmpEnvelope->releasekey();

  1786. }

  1787. 

  1788. void ADnote::Voice::kill(Allocator &memory, const SYNTH_T &synth)

  1789. {

  1790.     memory.devalloc(OscilSmp);

  1791.     memory.dealloc(FreqEnvelope);

  1792.     memory.dealloc(FreqLfo);

  1793.     memory.dealloc(AmpEnvelope);

  1794.     memory.dealloc(AmpLfo);

  1795.     memory.dealloc(VoiceFilterL);

  1796.     memory.dealloc(VoiceFilterR);

  1797.     memory.dealloc(FilterEnvelope);

  1798.     memory.dealloc(FilterLfo);

  1799.     memory.dealloc(FMFreqEnvelope);

  1800.     memory.dealloc(FMAmpEnvelope);

  1801. 

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

  1803.         memory.devalloc(FMSmp);

  1804. 

  1805.     if(VoiceOut)

  1806.         memset(VoiceOut, 0, synth.bufferbytes);

  1807.     //the buffer can't be safely deleted as it may be

  1808.     //an input to another voice

  1809. 

  1810.     Enabled = OFF;

  1811. }

  1812. 

  1813. void ADnote::Global::kill(Allocator &memory)

  1814. {

  1815.     memory.dealloc(FreqEnvelope);

  1816.     memory.dealloc(FreqLfo);

  1817.     memory.dealloc(AmpEnvelope);

  1818.     memory.dealloc(AmpLfo);

  1819.     memory.dealloc(GlobalFilterL);

  1820.     memory.dealloc(GlobalFilterR);

  1821.     memory.dealloc(FilterEnvelope);

  1822.     memory.dealloc(FilterLfo);

  1823. }

  1824. 

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

  1826.                                     const SYNTH_T &synth,

  1827.                                     const AbsTime &time,

  1828.                                     class Allocator &memory,

  1829.                                     float basefreq, float velocity,

  1830.                                     bool stereo)

  1831. {

  1832.     FreqEnvelope = memory.alloc<Envelope>(*param.FreqEnvelope, basefreq, synth.dt());

  1833.     FreqLfo      = memory.alloc<LFO>(*param.FreqLfo, basefreq, time);

  1834. 

  1835.     AmpEnvelope = memory.alloc<Envelope>(*param.AmpEnvelope, basefreq, synth.dt());

  1836.     AmpLfo      = memory.alloc<LFO>(*param.AmpLfo, basefreq, time);

  1837. 

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

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

  1840. 

  1841.     GlobalFilterL = Filter::generate(memory, param.GlobalFilter,

  1842.             synth.samplerate, synth.buffersize);

  1843.     if(stereo)

  1844.         GlobalFilterR = Filter::generate(memory, param.GlobalFilter,

  1845.                 synth.samplerate, synth.buffersize);

  1846.     else

  1847.         GlobalFilterR = NULL;

  1848. 

  1849.     FilterEnvelope = memory.alloc<Envelope>(*param.FilterEnvelope, basefreq, synth.dt());

  1850.     FilterLfo      = memory.alloc<LFO>(*param.FilterLfo, basefreq, time);

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

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

  1853. }