falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3959 Commits
16 Branches
16GB
Tree: 510209d0ee
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '510209d0ee'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/Synth/ADnote.cpp

2004 lines
72KB
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

  9.   modify it under the terms of the GNU General Public License

  10.   as published by the Free Software Foundation; either version 2

  11.   of the License, or (at your option) any later version.

  12. */

  13. 

  14. #include <cmath>

  15. #include <cstdlib>

  16. #include <cstdio>

  17. #include <cstring>

  18. #include <cassert>

  19. #include <stdint.h>

  20. 

  21. #include "../globals.h"

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

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

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

  25. #include "../Containers/ScratchString.h"

  26. #include "ModFilter.h"

  27. #include "OscilGen.h"

  28. #include "ADnote.h"

  29. 

  30. namespace zyncarla {

  31. 

  32. ADnote::ADnote(ADnoteParameters *pars_, SynthParams &spars,

  33.         WatchManager *wm, const char *prefix)

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

  35. {

  36.     memory.beginTransaction();

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

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

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

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

  41. 

  42.     ADnoteParameters &pars = *pars_;

  43.     portamento  = spars.portamento;

  44.     midinote    = spars.note;

  45.     NoteEnabled = ON;

  46.     basefreq    = spars.frequency;

  47.     velocity    = spars.velocity;

  48.     stereo = pars.GlobalPar.PStereo;

  49. 

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

  51.                                      pars.GlobalPar.PCoarseDetune,

  52.                                      pars.GlobalPar.PDetune);

  53.     bandwidthDetuneMultiplier = pars.getBandwidthDetuneMultiplier();

  54. 

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

  56.         NoteGlobalPar.Panning = RND;

  57.     else

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

  59. 

  60. 

  61.     NoteGlobalPar.Fadein_adjustment =

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

  63.     NoteGlobalPar.Fadein_adjustment *= NoteGlobalPar.Fadein_adjustment;

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

  65.         NoteGlobalPar.Punch.Enabled = 1;

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

  67.         NoteGlobalPar.Punch.initialvalue =

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

  69.              * VelF(velocity,

  70.                     pars.GlobalPar.PPunchVelocitySensing));

  71.         float time =

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

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

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

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

  76.     }

  77.     else

  78.         NoteGlobalPar.Punch.Enabled = 0;

  79. 

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

  81.         setupVoice(nvoice);

  82. 

  83.     max_unison = 1;

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

  85.         if(unison_size[nvoice] > max_unison)

  86.             max_unison = unison_size[nvoice];

  87. 

  88. 

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

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

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

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

  93.     }

  94. 

  95.     initparameters(wm, prefix);

  96.     memory.endTransaction();

  97. }

  98. 

  99. void ADnote::setupVoice(int nvoice)

  100. {

  101.     auto &param = pars.VoicePar[nvoice];

  102.     auto &voice = NoteVoicePar[nvoice];

  103. 

  104. 

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

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

  107. 

  108.     param.OscilSmp->newrandseed(prng());

  109.     voice.OscilSmp = NULL;

  110.     voice.FMSmp    = NULL;

  111.     voice.VoiceOut = NULL;

  112. 

  113.     voice.FMVoice = -1;

  114.     unison_size[nvoice] = 1;

  115. 

  116.     if(!pars.VoicePar[nvoice].Enabled) {

  117.         voice.Enabled = OFF;

  118.         return;   //the voice is disabled

  119.     }

  120. 

  121.     const int BendAdj = pars.VoicePar[nvoice].PBendAdjust - 64;

  122.     if (BendAdj % 24 == 0)

  123.         voice.BendAdjust = BendAdj / 24;

  124.     else

  125.         voice.BendAdjust = BendAdj / 24.0f;

  126. 

  127.     const float offset_val = (param.POffsetHz - 64)/64.0f;

  128.     voice.OffsetHz   = 15.0f*(offset_val * sqrtf(fabsf(offset_val)));

  129. 

  130.     unison_stereo_spread[nvoice] =

  131.         pars.VoicePar[nvoice].Unison_stereo_spread / 127.0f;

  132. 

  133.     int unison = setupVoiceUnison(nvoice);

  134. 

  135. 

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

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

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

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

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

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

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

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

  144. 

  145.     voice.Enabled     = ON;

  146.     voice.fixedfreq   = pars.VoicePar[nvoice].Pfixedfreq;

  147.     voice.fixedfreqET = pars.VoicePar[nvoice].PfixedfreqET;

  148. 

  149.     setupVoiceDetune(nvoice);

  150. 

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

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

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

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

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

  156.     }

  157. 

  158.     //the extra points contains the first point

  159.     voice.OscilSmp =

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

  161. 

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

  163.     int vc = nvoice;

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

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

  166.     if(!pars.GlobalPar.Hrandgrouping)

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

  168.     int oscposhi_start =

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

  170.                 getvoicebasefreq(nvoice),

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

  172. 

  173.     // This code was planned for biasing the carrier in MOD_RING

  174.     // but that's on hold for the moment.  Disabled 'cos small

  175.     // machines run this stuff too.

  176.     //

  177.     // //Find range of generated wave

  178.     // float min = NoteVoicePar[nvoice].OscilSmp[0];

  179.     // float max = min;

  180.     // float *smpls = &(NoteVoicePar[nvoice].OscilSmp[1]);

  181.     // for (int i = synth.oscilsize-1; i--; smpls++)

  182.     //     if (*smpls > max)

  183.     //         max = *smpls;

  184.     //     else if (*smpls < min)

  185.     //         min = *smpls;

  186.     // NoteVoicePar[nvoice].OscilSmpMin = min;

  187.     // NoteVoicePar[nvoice].OscilSmpMax = max;

  188. 

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

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

  191.         voice.OscilSmp[synth.oscilsize + i] = voice.OscilSmp[i];

  192. 

  193.     voice.phase_offset = (int)((pars.VoicePar[nvoice].Poscilphase

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

  195.     oscposhi_start += NoteVoicePar[nvoice].phase_offset;

  196. 

  197.     int kth_start = oscposhi_start;

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

  199.         oscposhi[nvoice][k] = kth_start % synth.oscilsize;

  200.         //put random starting point for other subvoices

  201.         kth_start      = oscposhi_start +

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

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

  204.     }

  205. 

  206.     voice.FreqLfo      = NULL;

  207.     voice.FreqEnvelope = NULL;

  208. 

  209.     voice.AmpLfo      = NULL;

  210.     voice.AmpEnvelope = NULL;

  211. 

  212.     voice.Filter         = NULL;

  213.     voice.FilterEnvelope = NULL;

  214.     voice.FilterLfo      = NULL;

  215. 

  216.     voice.filterbypass = param.Pfilterbypass;

  217. 

  218.     setupVoiceMod(nvoice);

  219.     

  220.     voice.FMVoice = param.PFMVoice;

  221.     voice.FMFreqEnvelope = NULL;

  222.     voice.FMAmpEnvelope  = NULL;

  223. 

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

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

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

  227. 

  228.     firsttick[nvoice] = 1;

  229.     voice.DelayTicks =

  230.         (int)((expf(param.PDelay / 127.0f * logf(50.0f))

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

  232. }

  233. 

  234. int ADnote::setupVoiceUnison(int nvoice)

  235. {

  236.     int unison = pars.VoicePar[nvoice].Unison_size;

  237.     if(unison < 1)

  238.         unison = 1;

  239. 

  240.     bool is_pwm = pars.VoicePar[nvoice].PFMEnabled == PW_MOD;

  241. 

  242.     if (pars.VoicePar[nvoice].Type != 0) {

  243.         // Since noise unison of greater than two is touch goofy...

  244.         if (unison > 2)

  245.             unison = 2;

  246.     } else if (is_pwm) {

  247.         /* Pulse width mod uses pairs of subvoices. */

  248.         unison *= 2;

  249.         // This many is likely to sound like noise anyhow.

  250.         if (unison > 64)

  251.             unison = 64;

  252.     }

  253. 

  254.     //compute unison

  255.     unison_size[nvoice] = unison;

  256. 

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

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

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

  260.     const float unison_spread =

  261.         pars.getUnisonFrequencySpreadCents(nvoice);

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

  263.     const float unison_vibratto_a  =

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

  265. 

  266.     const int true_unison = unison / (is_pwm ? 2 : 1);

  267.     switch(true_unison) {

  268.         case 1:

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

  270.             break;

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

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

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

  274.                 };

  275.                 break;

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

  277.                      float unison_values[true_unison];

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

  279.                      for(int k = 0; k < true_unison; ++k) {

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

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

  282.                          unison_values[k] = val;

  283.                          if (min > val) {

  284.                              min = val;

  285.                          }

  286.                          if (max < val) {

  287.                              max = val;

  288.                          }

  289.                      }

  290.                      const float diff = max - min;

  291.                      for(int k = 0; k < true_unison; ++k) {

  292.                          unison_values[k] =

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

  294.                          unison_base_freq_rap[nvoice][k] =

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

  296.                      }

  297.                  };

  298.     }

  299.     if (is_pwm)

  300.         for (int i = true_unison - 1; i >= 0; i--) {

  301.             unison_base_freq_rap[nvoice][2*i + 1] =

  302.                 unison_base_freq_rap[nvoice][i];

  303.             unison_base_freq_rap[nvoice][2*i] =

  304.                 unison_base_freq_rap[nvoice][i];

  305.         }

  306. 

  307.     //unison vibrattos

  308.     if(unison > 2 || (!is_pwm && unison > 1))

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

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

  311.                 + (unison_base_freq_rap[

  312.                         nvoice][k] - 1.0f)

  313.                 * (1.0f - unison_vibratto_a);

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

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

  316.     unison_vibratto[nvoice].amplitude =

  317.         (unison_real_spread - 1.0f) * unison_vibratto_a;

  318. 

  319.     const float increments_per_second = synth.samplerate_f / synth.buffersize_f;

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

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

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

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

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

  325.         const float vibratto_period = vibratto_base_period

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

  327. 

  328.         const float m = (RND < 0.5f ? -1.0f : 1.0f) *

  329.             4.0f / (vibratto_period * increments_per_second);

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

  331. 

  332.         // Ugly, but the alternative is likely uglier.

  333.         if (is_pwm)

  334.             for (int i = 0; i < unison; i += 2) {

  335.                 unison_vibratto[nvoice].step[i+1] =

  336.                     unison_vibratto[nvoice].step[i];

  337.                 unison_vibratto[nvoice].position[i+1] =

  338.                     unison_vibratto[nvoice].position[i];

  339.             }

  340.     }

  341. 

  342.     if(unison <= 2) { //no vibratto for a single voice

  343.         if (is_pwm) {

  344.             unison_vibratto[nvoice].step[1]     = 0.0f;

  345.             unison_vibratto[nvoice].position[1] = 0.0f;

  346.         }

  347.         if (is_pwm || unison == 1) {

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

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

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

  351.         }

  352.     }

  353. 

  354.     //phase invert for unison

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

  356.     if(unison != 1) {

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

  358.         switch(inv) {

  359.             case 0:

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

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

  362.                 break;

  363.             case 1:

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

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

  366.                 break;

  367.             default:

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

  369.                     unison_invert_phase[nvoice][k] =

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

  371.                 break;

  372.         }

  373.     }

  374.     return unison;

  375. }

  376. 

  377. void ADnote::setupVoiceDetune(int nvoice)

  378. {

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

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

  381.         NoteVoicePar[nvoice].Detune = getdetune(

  382.                 pars.VoicePar[nvoice].PDetuneType,

  383.                 pars.VoicePar[nvoice].

  384.                 PCoarseDetune,

  385.                 8192); //coarse detune

  386.         NoteVoicePar[nvoice].FineDetune = getdetune(

  387.                 pars.VoicePar[nvoice].PDetuneType,

  388.                 0,

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

  390.     }

  391.     else {

  392.         NoteVoicePar[nvoice].Detune = getdetune(

  393.                 pars.GlobalPar.PDetuneType,

  394.                 pars.VoicePar[nvoice].

  395.                 PCoarseDetune,

  396.                 8192); //coarse detune

  397.         NoteVoicePar[nvoice].FineDetune = getdetune(

  398.                 pars.GlobalPar.PDetuneType,

  399.                 0,

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

  401.     }

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

  403.         NoteVoicePar[nvoice].FMDetune = getdetune(

  404.                 pars.VoicePar[nvoice].PFMDetuneType,

  405.                 pars.VoicePar[nvoice].

  406.                 PFMCoarseDetune,

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

  408.     else

  409.         NoteVoicePar[nvoice].FMDetune = getdetune(

  410.                 pars.GlobalPar.PDetuneType,

  411.                 pars.VoicePar[nvoice].

  412.                 PFMCoarseDetune,

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

  414. }

  415. 

  416. void ADnote::setupVoiceMod(int nvoice, bool first_run)

  417. {

  418.     auto &param = pars.VoicePar[nvoice];

  419.     auto &voice = NoteVoicePar[nvoice];

  420.     if (param.Type != 0)

  421.         voice.FMEnabled = NONE;

  422.     else

  423.         switch(param.PFMEnabled) {

  424.             case 1:

  425.                 voice.FMEnabled = MORPH;

  426.                 break;

  427.             case 2:

  428.                 voice.FMEnabled = RING_MOD;

  429.                 break;

  430.             case 3:

  431.                 voice.FMEnabled = PHASE_MOD;

  432.                 break;

  433.             case 4:

  434.                 voice.FMEnabled = FREQ_MOD;

  435.                 break;

  436.             case 5:

  437.                 voice.FMEnabled = PW_MOD;

  438.                 break;

  439.             default:

  440.                 voice.FMEnabled = NONE;

  441.         }

  442. 

  443.     voice.FMFreqFixed  = param.PFMFixedFreq;

  444. 

  445.     //Triggers when a user enables modulation on a running voice

  446.     if(!first_run && voice.FMEnabled != NONE && voice.FMSmp == NULL && voice.FMVoice < 0) {

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

  448.         voice.FMSmp = memory.valloc<float>(synth.oscilsize + OSCIL_SMP_EXTRA_SAMPLES);

  449.         memset(voice.FMSmp, 0, sizeof(float)*(synth.oscilsize + OSCIL_SMP_EXTRA_SAMPLES));

  450.         int vc = nvoice;

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

  452.             vc = param.PextFMoscil;

  453. 

  454.         float tmp = 1.0f;

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

  456.                 || (voice.FMEnabled == MORPH)

  457.                 || (voice.FMEnabled == RING_MOD))

  458.             tmp = getFMvoicebasefreq(nvoice);

  459. 

  460.         if(!pars.GlobalPar.Hrandgrouping)

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

  462. 

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

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

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

  466.                         voice.FMSmp, tmp))

  467.                 % synth.oscilsize;

  468. 

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

  470.             voice.FMSmp[synth.oscilsize + i] = voice.FMSmp[i];

  471.         int oscposhiFM_add =

  472.             (int)((param.PFMoscilphase

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

  474.                     + synth.oscilsize * 4);

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

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

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

  478.         }

  479.     }

  480. 

  481. 

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

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

  484.             param.PFMVolumeDamp / 64.0f - 1.0f);

  485.     const float fmvolume_ = param.PFMVolume / 127.0f;

  486.     switch(voice.FMEnabled) {

  487.         case PHASE_MOD:

  488.         case PW_MOD:

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

  490.                     param.PFMVolumeDamp / 64.0f);

  491.             voice.FMVolume = (expf(fmvolume_ * FM_AMP_MULTIPLIER) - 1.0f)

  492.                 * fmvoldamp * 4.0f;

  493.             break;

  494.         case FREQ_MOD:

  495.             voice.FMVolume = (expf(fmvolume_ * FM_AMP_MULTIPLIER) - 1.0f)

  496.                 * fmvoldamp * 4.0f;

  497.             break;

  498.         default:

  499.             if(fmvoldamp > 1.0f)

  500.                 fmvoldamp = 1.0f;

  501.             voice.FMVolume = fmvolume_ * fmvoldamp;

  502.     }

  503. 

  504.     //Voice's modulator velocity sensing

  505.     NoteVoicePar[nvoice].FMVolume *=

  506.         VelF(velocity, pars.VoicePar[nvoice].PFMVelocityScaleFunction);

  507. }

  508. 

  509. SynthNote *ADnote::cloneLegato(void)

  510. {

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

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

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

  514. }

  515. 

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

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

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

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

  520. void ADnote::legatonote(LegatoParams lpars)

  521. {

  522.     //ADnoteParameters &pars = *partparams;

  523. 

  524.     // Manage legato stuff

  525.     if(legato.update(lpars))

  526.         return;

  527. 

  528.     portamento = lpars.portamento;

  529.     midinote   = lpars.midinote;

  530.     basefreq   = lpars.frequency;

  531. 

  532.     if(velocity > 1.0f)

  533.         velocity = 1.0f;

  534.     velocity = lpars.velocity;

  535. 

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

  537.                                      pars.GlobalPar.PCoarseDetune,

  538.                                      pars.GlobalPar.PDetune);

  539.     bandwidthDetuneMultiplier = pars.getBandwidthDetuneMultiplier();

  540. 

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

  542.         NoteGlobalPar.Panning = RND;

  543.     else

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

  545. 

  546.     NoteGlobalPar.Filter->updateSense(velocity, 

  547.                 pars.GlobalPar.PFilterVelocityScale,

  548.                 pars.GlobalPar.PFilterVelocityScaleFunction);

  549. 

  550. 

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

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

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

  554. 

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

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

  557. 

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

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

  560.             NoteVoicePar[nvoice].Detune = getdetune(

  561.                 pars.VoicePar[nvoice].PDetuneType,

  562.                 pars.VoicePar[nvoice].PCoarseDetune,

  563.                 8192); //coarse detune

  564.             NoteVoicePar[nvoice].FineDetune = getdetune(

  565.                 pars.VoicePar[nvoice].PDetuneType,

  566.                 0,

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

  568.         }

  569.         else {

  570.             NoteVoicePar[nvoice].Detune = getdetune(

  571.                 pars.GlobalPar.PDetuneType,

  572.                 pars.VoicePar[nvoice].PCoarseDetune,

  573.                 8192); //coarse detune

  574.             NoteVoicePar[nvoice].FineDetune = getdetune(

  575.                 pars.GlobalPar.PDetuneType,

  576.                 0,

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

  578.         }

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

  580.             NoteVoicePar[nvoice].FMDetune = getdetune(

  581.                 pars.VoicePar[nvoice].PFMDetuneType,

  582.                 pars.VoicePar[nvoice].PFMCoarseDetune,

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

  584.         else

  585.             NoteVoicePar[nvoice].FMDetune = getdetune(

  586.                 pars.GlobalPar.PDetuneType,

  587.                 pars.VoicePar[nvoice].PFMCoarseDetune,

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

  589. 

  590. 

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

  592.         int vc = nvoice;

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

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

  595.         if(!pars.GlobalPar.Hrandgrouping)

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

  597. 

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

  599.                                          getvoicebasefreq(nvoice),

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

  601. 

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

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

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

  605.                                           + i] =

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

  607. 

  608.         auto &voiceFilter = NoteVoicePar[nvoice].Filter;

  609.         if(voiceFilter) {

  610.             const auto  &vce     = pars.VoicePar[nvoice];

  611.             voiceFilter->updateSense(velocity, vce.PFilterVelocityScale,

  612.                         vce.PFilterVelocityScaleFunction);

  613.         }

  614. 

  615.         NoteVoicePar[nvoice].filterbypass =

  616.             pars.VoicePar[nvoice].Pfilterbypass;

  617. 

  618. 

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

  620. 

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

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

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

  624.                                - 1.0f);

  625. 

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

  627.             case PHASE_MOD:

  628.             case PW_MOD:

  629.                 fmvoldamp =

  630.                     powf(440.0f / getvoicebasefreq(

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

  632.                          / 64.0f);

  633.                 NoteVoicePar[nvoice].FMVolume =

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

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

  636.                 break;

  637.             case FREQ_MOD:

  638.                 NoteVoicePar[nvoice].FMVolume =

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

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

  641.                 break;

  642.             default:

  643.                 if(fmvoldamp > 1.0f)

  644.                     fmvoldamp = 1.0f;

  645.                 NoteVoicePar[nvoice].FMVolume =

  646.                     pars.VoicePar[nvoice].PFMVolume

  647.                     / 127.0f * fmvoldamp;

  648.         }

  649. 

  650.         //Voice's modulator velocity sensing

  651.         NoteVoicePar[nvoice].FMVolume *=

  652.             VelF(velocity,

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

  654. 

  655.         NoteVoicePar[nvoice].DelayTicks =

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

  657.                         * logf(50.0f))

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

  659.     }

  660. 

  661.     ///    initparameters();

  662. 

  663.     ///////////////

  664.     // Altered content of initparameters():

  665. 

  666.     int tmp[NUM_VOICES];

  667. 

  668.     NoteGlobalPar.Volume = 4.0f

  669.                            * powf(0.1f, 3.0f

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

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

  672.                            * VelF(

  673.         velocity,

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

  675. 

  676.     globalnewamplitude = NoteGlobalPar.Volume

  677.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  679. 

  680.     {

  681.         auto        *filter  = NoteGlobalPar.Filter;

  682.         filter->updateSense(velocity, pars.GlobalPar.PFilterVelocityScale,

  683.                             pars.GlobalPar.PFilterVelocityScaleFunction);

  684.         filter->updateNoteFreq(basefreq);

  685.     }

  686. 

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

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

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

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

  691. 

  692.     // Voice Parameter init

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

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

  695.             continue;

  696. 

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

  698.         /* Voice Amplitude Parameters Init */

  699.         NoteVoicePar[nvoice].Volume =

  700.             powf(0.1f, 3.0f

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

  702.             * VelF(velocity,

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

  704.         if(pars.VoicePar[nvoice].PVolume == 0)

  705.             NoteVoicePar[nvoice].Volume = 0;

  706. 

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

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

  709. 

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

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

  712.         else

  713.             NoteVoicePar[nvoice].Panning =

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

  715. 

  716.         newamplitude[nvoice] = 1.0f;

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

  718.            && NoteVoicePar[nvoice].AmpEnvelope)

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

  720. 

  721. 

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

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

  724. 

  725.         auto *voiceFilter = NoteVoicePar[nvoice].Filter;

  726.         if(voiceFilter) {

  727.             voiceFilter->updateSense(velocity, pars.VoicePar[nvoice].PFilterVelocityScale,

  728.                                      pars.VoicePar[nvoice].PFilterVelocityScaleFunction);

  729.             voiceFilter->updateNoteFreq(basefreq);

  730.         }

  731. 

  732.         /* Voice Modulation Parameters Init */

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

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

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

  736. 

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

  738. 

  739.             int vc = nvoice;

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

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

  742. 

  743.             if(!pars.GlobalPar.Hrandgrouping)

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

  745. 

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

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

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

  749.         }

  750. 

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

  752.                                  * ctl.fmamp.relamp;

  753. 

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

  755.            && NoteVoicePar[nvoice].FMAmpEnvelope)

  756.             FMnewamplitude[nvoice] *=

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

  758.     }

  759. 

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

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

  762.             tmp[i] = 0;

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

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

  765.                 tmp[i] = 1;

  766.     }

  767. }

  768. 

  769. 

  770. /*

  771.  * Kill a voice of ADnote

  772.  */

  773. void ADnote::KillVoice(int nvoice)

  774. {

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

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

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

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

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

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

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

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

  783. 

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

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

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

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

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

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

  790. 

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

  792. }

  793. 

  794. /*

  795.  * Kill the note

  796.  */

  797. void ADnote::KillNote()

  798. {

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

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

  801.             KillVoice(nvoice);

  802. 

  803.         if(NoteVoicePar[nvoice].VoiceOut)

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

  805.     }

  806. 

  807.     NoteGlobalPar.kill(memory);

  808. 

  809.     NoteEnabled = OFF;

  810. }

  811. 

  812. ADnote::~ADnote()

  813. {

  814.     if(NoteEnabled == ON)

  815.         KillNote();

  816.     memory.devalloc(tmpwavel);

  817.     memory.devalloc(tmpwaver);

  818.     memory.devalloc(bypassl);

  819.     memory.devalloc(bypassr);

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

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

  822.     memory.devalloc(tmpwave_unison);

  823. }

  824. 

  825. 

  826. /*

  827.  * Init the parameters

  828.  */

  829. void ADnote::initparameters(WatchManager *wm, const char *prefix)

  830. {

  831.     int tmp[NUM_VOICES];

  832.     ScratchString pre = prefix;

  833.     //ADnoteParameters &pars = *partparams;

  834. 

  835.     // Global Parameters

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

  837.                                  time,

  838.                                  memory, basefreq, velocity,

  839.                                  stereo, wm, prefix);

  840. 

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

  842.     globalnewamplitude = NoteGlobalPar.Volume

  843.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  845. 

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

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

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

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

  850. 

  851.     // Voice Parameter init

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

  853.         Voice &vce = NoteVoicePar[nvoice];

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

  855. 

  856.         if(vce.Enabled == 0)

  857.             continue;

  858. 

  859.         vce.noisetype = param.Type;

  860.         /* Voice Amplitude Parameters Init */

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

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

  863.         if(param.PVolume == 0)

  864.             vce.Volume = 0;

  865. 

  866.         if(param.PVolumeminus)

  867.             vce.Volume = -vce.Volume;

  868. 

  869.         if(param.PPanning == 0)

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

  871.         else

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

  873. 

  874.         newamplitude[nvoice] = 1.0f;

  875.         if(param.PAmpEnvelopeEnabled) {

  876.             vce.AmpEnvelope = memory.alloc<Envelope>(*param.AmpEnvelope,

  877.                     basefreq, synth.dt(), wm,

  878.                     (pre+"VoicePar"+nvoice+"/AmpEnvelope/").c_str);

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

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

  881.         }

  882. 

  883.         if(param.PAmpLfoEnabled) {

  884.             vce.AmpLfo = memory.alloc<LFO>(*param.AmpLfo, basefreq, time, wm,

  885.                     (pre+"VoicePar"+nvoice+"/AmpLfo/").c_str);

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

  887.         }

  888. 

  889.         /* Voice Frequency Parameters Init */

  890.         if(param.PFreqEnvelopeEnabled)

  891.             vce.FreqEnvelope = memory.alloc<Envelope>(*param.FreqEnvelope,

  892.                     basefreq, synth.dt(), wm,

  893.                     (pre+"VoicePar"+nvoice+"/FreqEnvelope/").c_str);

  894. 

  895.         if(param.PFreqLfoEnabled)

  896.             vce.FreqLfo = memory.alloc<LFO>(*param.FreqLfo, basefreq, time, wm,

  897.                     (pre+"VoicePar"+nvoice+"/FreqLfo/").c_str);

  898. 

  899.         /* Voice Filter Parameters Init */

  900.         if(param.PFilterEnabled) {

  901.             vce.Filter = memory.alloc<ModFilter>(*param.VoiceFilter, synth, time, memory, stereo,

  902.                       basefreq);

  903.             vce.Filter->updateSense(velocity, param.PFilterVelocityScale,

  904.                     param.PFilterVelocityScaleFunction);

  905. 

  906. 

  907.             if(param.PFilterEnvelopeEnabled) {

  908.                 vce.FilterEnvelope =

  909.                     memory.alloc<Envelope>(*param.FilterEnvelope,

  910.                             basefreq, synth.dt(), wm,

  911.                             (pre+"VoicePar"+nvoice+"/FilterEnvelope/").c_str);

  912.                 vce.Filter->addMod(*vce.FilterEnvelope);

  913.             }

  914. 

  915.             if(param.PFilterLfoEnabled) {

  916.                 vce.FilterLfo = memory.alloc<LFO>(*param.FilterLfo, basefreq, time, wm,

  917.                         (pre+"VoicePar"+nvoice+"/FilterLfo/").c_str);

  918.                 vce.Filter->addMod(*vce.FilterLfo);

  919.             }

  920.         }

  921. 

  922.         /* Voice Modulation Parameters Init */

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

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

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

  926. 

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

  928. 

  929.             int vc = nvoice;

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

  931.                 vc = param.PextFMoscil;

  932. 

  933.             float tmp = 1.0f;

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

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

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

  937.                 tmp = getFMvoicebasefreq(nvoice);

  938. 

  939.             if(!pars.GlobalPar.Hrandgrouping)

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

  941. 

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

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

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

  945.                                              vce.FMSmp, tmp))

  946.                                         % synth.oscilsize;

  947. 

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

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

  950.             int oscposhiFM_add =

  951.                 (int)((param.PFMoscilphase

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

  953.                       + synth.oscilsize * 4);

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

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

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

  957.             }

  958.         }

  959. 

  960.         if(param.PFMFreqEnvelopeEnabled)

  961.             vce.FMFreqEnvelope = memory.alloc<Envelope>(*param.FMFreqEnvelope,

  962.                     basefreq, synth.dt(), wm,

  963.                     (pre+"VoicePar"+nvoice+"/FMFreqEnvelope/").c_str);

  964. 

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

  966. 

  967.         if(param.PFMAmpEnvelopeEnabled) {

  968.             vce.FMAmpEnvelope =

  969.                 memory.alloc<Envelope>(*param.FMAmpEnvelope,

  970.                         basefreq, synth.dt(), wm,

  971.                         (pre+"VoicePar"+nvoice+"/FMAmpEnvelope/").c_str);

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

  973.         }

  974.     }

  975. 

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

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

  978.             tmp[i] = 0;

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

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

  981.                 NoteVoicePar[nvoice].VoiceOut =

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

  983.                 tmp[i] = 1;

  984.             }

  985. 

  986.         if(NoteVoicePar[nvoice].VoiceOut)

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

  988.     }

  989. }

  990. 

  991. 

  992. /*

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

  994.  * This must be called before setfreq* functions

  995.  */

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

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

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

  999.         return;

  1000.     }

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

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

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

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

  1005.         pos += step;

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

  1007.             pos  = -1.0f;

  1008.             step = -step;

  1009.         }

  1010.         if(pos >= 1.0f) {

  1011.             pos  = 1.0f;

  1012.             step = -step;

  1013.         }

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

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

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

  1017.                                          - 1.0f) + vibratto_val

  1018.                                         * unison_vibratto[nvoice].amplitude)

  1019.                                      * relbw;

  1020. 

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

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

  1023.     }

  1024. }

  1025. 

  1026. 

  1027. /*

  1028.  * Computes the frequency of an oscillator

  1029.  */

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

  1031. {

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

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

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

  1035.         if(speed > synth.oscilsize_f)

  1036.             speed = synth.oscilsize_f;

  1037. 

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

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

  1040.     }

  1041. }

  1042. 

  1043. /*

  1044.  * Computes the frequency of an modullator oscillator

  1045.  */

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

  1047. {

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

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

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

  1051.         if(speed > synth.samplerate_f)

  1052.             speed = synth.samplerate_f;

  1053. 

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

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

  1056.     }

  1057. }

  1058. 

  1059. /*

  1060.  * Get Voice base frequency

  1061.  */

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

  1063. {

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

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

  1066.                    * ctl.bandwidth.relbw * bandwidthDetuneMultiplier

  1067.                    + NoteGlobalPar.Detune / 100.0f;

  1068. 

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

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

  1071.     else { //the fixed freq is enabled

  1072.         float fixedfreq   = 440.0f;

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

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

  1075.             float tmp =

  1076.                 (midinote

  1077.                  - 69.0f) / 12.0f

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

  1079.             if(fixedfreqET <= 64)

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

  1081.             else

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

  1083.         }

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

  1085.     }

  1086. }

  1087. 

  1088. /*

  1089.  * Get Voice's Modullator base frequency

  1090.  */

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

  1092. {

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

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

  1095. }

  1096. 

  1097. /*

  1098.  * Computes all the parameters for each tick

  1099.  */

  1100. void ADnote::computecurrentparameters()

  1101. {

  1102.     int   nvoice;

  1103.     float voicefreq, voicepitch, FMfreq,

  1104.           FMrelativepitch, globalpitch;

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

  1106.                            + NoteGlobalPar.FreqLfo->lfoout()

  1107.                            * ctl.modwheel.relmod);

  1108.     globaloldamplitude = globalnewamplitude;

  1109.     globalnewamplitude = NoteGlobalPar.Volume

  1110.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  1112. 

  1113.     NoteGlobalPar.Filter->update(ctl.filtercutoff.relfreq,

  1114.                                  ctl.filterq.relq);

  1115. 

  1116. 

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

  1118.     float portamentofreqrap = 1.0f;

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

  1120.         portamentofreqrap = ctl.portamento.freqrap;

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

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

  1123.     }

  1124. 

  1125.     //compute parameters for all voices

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

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

  1128.             continue;

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

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

  1131.             continue;

  1132. 

  1133.         compute_unison_freq_rap(nvoice);

  1134. 

  1135.         /*******************/

  1136.         /* Voice Amplitude */

  1137.         /*******************/

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

  1139.         newamplitude[nvoice] = 1.0f;

  1140. 

  1141.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

  1143. 

  1144.         if(NoteVoicePar[nvoice].AmpLfo)

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

  1146. 

  1147.         /****************/

  1148.         /* Voice Filter */

  1149.         /****************/

  1150.         auto *voiceFilter = NoteVoicePar[nvoice].Filter;

  1151.         if(voiceFilter) {

  1152.             voiceFilter->update(ctl.filtercutoff.relfreq,

  1153.                                 ctl.filterq.relq);

  1154.         }

  1155. 

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

  1157.             /*******************/

  1158.             /* Voice Frequency */

  1159.             /*******************/

  1160.             voicepitch = 0.0f;

  1161.             if(NoteVoicePar[nvoice].FreqLfo)

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

  1163.                               * ctl.bandwidth.relbw;

  1164. 

  1165.             if(NoteVoicePar[nvoice].FreqEnvelope)

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

  1167.                               / 100.0f;

  1168.             voicefreq = getvoicebasefreq(nvoice)

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

  1170.             voicefreq *=

  1171.                 powf(ctl.pitchwheel.relfreq, NoteVoicePar[nvoice].BendAdjust); //change the frequency by the controller

  1172.             setfreq(nvoice, voicefreq * portamentofreqrap + NoteVoicePar[nvoice].OffsetHz);

  1173. 

  1174.             /***************/

  1175.             /*  Modulator */

  1176.             /***************/

  1177. 

  1178. 

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

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

  1181.                 if(NoteVoicePar[nvoice].FMFreqEnvelope)

  1182.                     FMrelativepitch +=

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

  1184.                 if (NoteVoicePar[nvoice].FMFreqFixed)

  1185.                     FMfreq =

  1186.                         powf(2.0f, FMrelativepitch

  1187.                              / 12.0f) * 440.0f;

  1188.                 else

  1189.                     FMfreq =

  1190.                            powf(2.0f, FMrelativepitch

  1191.                                 / 12.0f) * voicefreq * portamentofreqrap;

  1192.                 setfreqFM(nvoice, FMfreq);

  1193. 

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

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

  1196.                                          * ctl.fmamp.relamp;

  1197.                 if(NoteVoicePar[nvoice].FMAmpEnvelope)

  1198.                     FMnewamplitude[nvoice] *=

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

  1200.             }

  1201.         }

  1202.     }

  1203. }

  1204. 

  1205. 

  1206. /*

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

  1208.  */

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

  1210. {

  1211.     int zerocrossings = 0;

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

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

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

  1215. 

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

  1217.     if(tmp < 8.0f)

  1218.         tmp = 8.0f;

  1219.     tmp *= NoteGlobalPar.Fadein_adjustment;

  1220. 

  1221.     int n;

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

  1223.     if(n > synth.buffersize)

  1224.         n = synth.buffersize;

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

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

  1227.         smps[i] *= tmp;

  1228.     }

  1229. }

  1230. 

  1231. /*

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

  1233.  */

  1234. 

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

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

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

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

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

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

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

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

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

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

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

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

  1247.  */

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

  1249. {

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

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

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

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

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

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

  1256.         float *tw     = tmpwave_unison[k];

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

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

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

  1260.             poslo += freqlo;

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

  1262.             poslo &= 0xffffff;

  1263.             poshi &= synth.oscilsize - 1;

  1264.         }

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

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

  1267.     }

  1268. }

  1269. 

  1270. 

  1271. 

  1272. /*

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

  1274.  *

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

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

  1277.     int i,poshi;

  1278.     float poslo;

  1279. 

  1280.     poshi=oscposhi[nvoice];

  1281.     poslo=oscposlo[nvoice];

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

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

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

  1285.     xm1=smps[poshi];

  1286.     x0=smps[poshi+1];

  1287.     x1=smps[poshi+2];

  1288.     x2=smps[poshi+3];

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

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

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

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

  1293.     printf("a\n");

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

  1295.     poslo+=oscfreqlo[nvoice];

  1296.     if (poslo>=1.0f) {

  1297.             poslo-=1.0f;

  1298.         poshi++;

  1299.     };

  1300.         poshi+=oscfreqhi[nvoice];

  1301.         poshi&=synth.oscilsize-1;

  1302.     };

  1303.     oscposhi[nvoice]=poshi;

  1304.     oscposlo[nvoice]=poslo;

  1305. };

  1306. */

  1307. /*

  1308.  * Computes the Oscillator (Morphing)

  1309.  */

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

  1311. {

  1312.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1314.         FMnewamplitude[nvoice] = 1.0f;

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

  1316.         FMoldamplitude[nvoice] = 1.0f;

  1317. 

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

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

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

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

  1322.             float *tw = tmpwave_unison[k];

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

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

  1325.                                             FMnewamplitude[nvoice],

  1326.                                             i,

  1327.                                             synth.buffersize);

  1328.                 tw[i] = tw[i]

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

  1330.             }

  1331.         }

  1332.     }

  1333.     else

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

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

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

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

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

  1339.             float *tw = tmpwave_unison[k];

  1340. 

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

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

  1343.                                             FMnewamplitude[nvoice],

  1344.                                             i,

  1345.                                             synth.buffersize);

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

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

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

  1349.                 posloFM += freqloFM;

  1350.                 if(posloFM >= 1.0f) {

  1351.                     posloFM -= 1.0f;

  1352.                     poshiFM++;

  1353.                 }

  1354.                 poshiFM += freqhiFM;

  1355.                 poshiFM &= synth.oscilsize - 1;

  1356.             }

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

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

  1359.         }

  1360. }

  1361. 

  1362. /*

  1363.  * Computes the Oscillator (Ring Modulation)

  1364.  */

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

  1366. {

  1367.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1369.         FMnewamplitude[nvoice] = 1.0f;

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

  1371.         FMoldamplitude[nvoice] = 1.0f;

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

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

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

  1375.             float *tw = tmpwave_unison[k];

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

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

  1378.                                             FMnewamplitude[nvoice],

  1379.                                             i,

  1380.                                             synth.buffersize);

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

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

  1383.             }

  1384.         }

  1385.     else

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

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

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

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

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

  1391.             float *tw = tmpwave_unison[k];

  1392. 

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

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

  1395.                                             FMnewamplitude[nvoice],

  1396.                                             i,

  1397.                                             synth.buffersize);

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

  1399.                           + NoteVoicePar[nvoice].FMSmp[poshiFM

  1400.                                                        + 1] * posloFM) * amp

  1401.                          + (1.0f - amp);

  1402.                 posloFM += freqloFM;

  1403.                 if(posloFM >= 1.0f) {

  1404.                     posloFM -= 1.0f;

  1405.                     poshiFM++;

  1406.                 }

  1407.                 poshiFM += freqhiFM;

  1408.                 poshiFM &= synth.oscilsize - 1;

  1409.             }

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

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

  1412.         }

  1413. }

  1414. 

  1415. /*

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

  1417.  */

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

  1419.                                                               int FMmode)

  1420. {

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

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

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

  1424.             float *tw = tmpwave_unison[k];

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

  1426.             if (FMmode == PW_MOD && (k & 1))

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

  1428.                     tw[i] = -smps[i];

  1429.             else

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

  1431.         }

  1432.     } else {

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

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

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

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

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

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

  1439.             float *tw = tmpwave_unison[k];

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

  1441. 

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

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

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

  1445.                 if (FMmode == PW_MOD && (k & 1))

  1446.                     tw[i] = -tw[i];

  1447. 

  1448.                 posloFM += freqloFM;

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

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

  1451.                     poshiFM++;

  1452.                 }

  1453.                 poshiFM += freqhiFM;

  1454.                 poshiFM &= synth.oscilsize - 1;

  1455.             }

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

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

  1458.         }

  1459.     }

  1460.     // Amplitude interpolation

  1461.     if(ABOVE_AMPLITUDE_THRESHOLD(FMoldamplitude[nvoice],

  1462.                                  FMnewamplitude[nvoice])) {

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

  1464.             float *tw = tmpwave_unison[k];

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

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

  1467.                                                FMnewamplitude[nvoice],

  1468.                                                i,

  1469.                                                synth.buffersize);

  1470.         }

  1471.     } else {

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

  1473.             float *tw = tmpwave_unison[k];

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

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

  1476.         }

  1477.     }

  1478. 

  1479. 

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

  1481.     if(FMmode == FREQ_MOD) { //Frequency modulation

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

  1483.                           / synth.samplerate_f;

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

  1485.             float *tw    = tmpwave_unison[k];

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

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

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

  1489.                 tw[i] = fmold;

  1490.             }

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

  1492.         }

  1493.     }

  1494.     else {  //Phase or PWM modulation

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

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

  1497.             float *tw = tmpwave_unison[k];

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

  1499.                 tw[i] *= normalize;

  1500.         }

  1501.     }

  1502. 

  1503.     //do the modulation

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

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

  1506.         float *tw     = tmpwave_unison[k];

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

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

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

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

  1511. 

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

  1513.             int FMmodfreqhi = 0;

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

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

  1516.             if(FMmodfreqhi < 0)

  1517.                 FMmodfreqlo++;

  1518. 

  1519.             //carrier

  1520.             int carposhi = poshi + FMmodfreqhi;

  1521.             int carposlo = poslo + FMmodfreqlo;

  1522.             if (FMmode == PW_MOD && (k & 1))

  1523.                 carposhi += NoteVoicePar[nvoice].phase_offset;

  1524. 

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

  1526.                 carposhi++;

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

  1528.             }

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

  1530. 

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

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

  1533. 

  1534.             poslo += freqlo;

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

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

  1537.                 poshi++;

  1538.             }

  1539. 

  1540.             poshi += freqhi;

  1541.             poshi &= synth.oscilsize - 1;

  1542.         }

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

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

  1545.     }

  1546. }

  1547. 

  1548. 

  1549. /*

  1550.  * Computes the Noise

  1551.  */

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

  1553. {

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

  1555.         float *tw = tmpwave_unison[k];

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

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

  1558.     }

  1559. }

  1560. 

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

  1562. {

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

  1564.         float *tw = tmpwave_unison[k];

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

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

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

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

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

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

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

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

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

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

  1575. 	    f[6] = white*0.115926;

  1576.         }

  1577.     }

  1578. }

  1579. 

  1580. inline void ADnote::ComputeVoiceDC(int nvoice)

  1581. {

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

  1583.         float *tw = tmpwave_unison[k];

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

  1585.             tw[i] = 1.0f;

  1586.     }

  1587. }

  1588. 

  1589. 

  1590. 

  1591. /*

  1592.  * Compute the ADnote samples

  1593.  * Returns 0 if the note is finished

  1594.  */

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

  1596. {

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

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

  1599. 

  1600.     if(NoteEnabled == OFF)

  1601.         return 0;

  1602. 

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

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

  1605. 

  1606.     //Update Changed Parameters From UI

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

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

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

  1610.             continue;

  1611.         setupVoiceDetune(nvoice);

  1612.         setupVoiceMod(nvoice, false);

  1613.     }

  1614. 

  1615.     computecurrentparameters();

  1616. 

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

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

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

  1620.             continue;

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

  1622.             case 0: //voice mode=sound

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

  1624.                     case MORPH:

  1625.                         ComputeVoiceOscillatorMorph(nvoice);

  1626.                         break;

  1627.                     case RING_MOD:

  1628.                         ComputeVoiceOscillatorRingModulation(nvoice);

  1629.                         break;

  1630.                     case FREQ_MOD:

  1631.                     case PHASE_MOD:

  1632.                     case PW_MOD:

  1633.                         ComputeVoiceOscillatorFrequencyModulation(nvoice,

  1634.                                                                   NoteVoicePar[nvoice].FMEnabled);

  1635.                         break;

  1636.                     default:

  1637.                         ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1639.                 }

  1640.                 break;

  1641.             case 1:

  1642.                 ComputeVoiceWhiteNoise(nvoice);

  1643.                 break;

  1644.             case 2:

  1645.                 ComputeVoicePinkNoise(nvoice);

  1646.                 break;

  1647.             default:

  1648.                 ComputeVoiceDC(nvoice);

  1649.                 break;

  1650.         }

  1651.         // Voice Processing

  1652. 

  1653. 

  1654.         //mix subvoices into voice

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

  1656.         if(stereo)

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

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

  1659.             float *tw = tmpwave_unison[k];

  1660.             if(stereo) {

  1661.                 float stereo_pos = 0;

  1662.                 bool is_pwm = NoteVoicePar[nvoice].FMEnabled == PW_MOD;

  1663.                 if (is_pwm) {

  1664.                     if(unison_size[nvoice] > 2)

  1665.                         stereo_pos = k/2

  1666.                             / (float)(unison_size[nvoice]/2

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

  1668.                 } else if(unison_size[nvoice] > 1) {

  1669.                     stereo_pos = k

  1670.                         / (float)(unison_size[nvoice]

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

  1672.                 }

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

  1674.                 if(stereo_spread > 1.0f) {

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

  1676.                     stereo_pos =

  1677.                         (2.0f

  1678.                          - stereo_spread) * stereo_pos

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

  1680.                 }

  1681.                 else

  1682.                     stereo_pos *= stereo_spread;

  1683. 

  1684.                 if(unison_size[nvoice] == 1 ||

  1685.                    (is_pwm && unison_size[nvoice] == 2))

  1686.                     stereo_pos = 0.0f;

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

  1688. 

  1689. 

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

  1691.                 if(lvol > 1.0f)

  1692.                     lvol = 1.0f;

  1693. 

  1694.                 float rvol = panning * 2.0f;

  1695.                 if(rvol > 1.0f)

  1696.                     rvol = 1.0f;

  1697. 

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

  1699.                     lvol = -lvol;

  1700.                     rvol = -rvol;

  1701.                 }

  1702. 

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

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

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

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

  1707.             }

  1708.             else

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

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

  1711.         }

  1712. 

  1713. 

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

  1715.         // Amplitude

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

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

  1718. 

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

  1720.             int rest = synth.buffersize;

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

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

  1723.                 rest = 10;

  1724.                 if(rest > synth.buffersize)

  1725.                     rest = synth.buffersize;

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

  1727.                     tmpwavel[i] *= oldam;

  1728.                 if(stereo)

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

  1730.                         tmpwaver[i] *= oldam;

  1731.             }

  1732.             // Amplitude interpolation

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

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

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

  1736.                 if(stereo)

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

  1738.             }

  1739.         }

  1740.         else {

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

  1742.                 tmpwavel[i] *= newam;

  1743.             if(stereo)

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

  1745.                     tmpwaver[i] *= newam;

  1746.         }

  1747. 

  1748.         // Fade in

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

  1750.             fadein(&tmpwavel[0]);

  1751.             if(stereo)

  1752.                 fadein(&tmpwaver[0]);

  1753.             firsttick[nvoice] = 0;

  1754.         }

  1755. 

  1756.         // Filter

  1757.         if(NoteVoicePar[nvoice].Filter) {

  1758.             if(stereo)

  1759.                 NoteVoicePar[nvoice].Filter->filter(tmpwavel, tmpwaver);

  1760.             else

  1761.                 NoteVoicePar[nvoice].Filter->filter(tmpwavel, 0);

  1762.         }

  1763. 

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

  1765.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

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

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

  1769.                 if(stereo)

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

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

  1772.             }

  1773.         //the voice is killed later

  1774. 

  1775. 

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

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

  1778.             if(stereo)

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

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

  1781.                                                        + tmpwaver[i];

  1782.             else   //mono

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

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

  1785.         }

  1786. 

  1787. 

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

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

  1790.             if(stereo)

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

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

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

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

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

  1796.                 }

  1797.             else

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

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

  1800.         }

  1801.         else {  //bypass the filter

  1802.             if(stereo)

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

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

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

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

  1807.                                   * (1.0f

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

  1809.                 }

  1810.             else

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

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

  1813.         }

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

  1815.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

  1817.                 KillVoice(nvoice);

  1818.     }

  1819. 

  1820. 

  1821.     //Processing Global parameters

  1822.     if(stereo) {

  1823.         NoteGlobalPar.Filter->filter(outl, outr);

  1824.     } else { //set the right channel=left channel

  1825.         NoteGlobalPar.Filter->filter(outl, 0);

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

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

  1828.     }

  1829. 

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

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

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

  1833.     }

  1834. 

  1835.     if(ABOVE_AMPLITUDE_THRESHOLD(globaloldamplitude, globalnewamplitude))

  1836.         // Amplitude Interpolation

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

  1838.             float tmpvol = INTERPOLATE_AMPLITUDE(globaloldamplitude,

  1839.                                                  globalnewamplitude,

  1840.                                                  i,

  1841.                                                  synth.buffersize);

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

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

  1844.         }

  1845.     else

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

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

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

  1849.         }

  1850. 

  1851.     //Apply the punch

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

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

  1854.             float punchamp = NoteGlobalPar.Punch.initialvalue

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

  1856.             outl[i] *= punchamp;

  1857.             outr[i] *= punchamp;

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

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

  1860.                 NoteGlobalPar.Punch.Enabled = 0;

  1861.                 break;

  1862.             }

  1863.         }

  1864. 

  1865. 

  1866.     // Apply legato-specific sound signal modifications

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

  1868. 

  1869. 

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

  1871.     // If it does, disable the note

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

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

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

  1875.             outl[i] *= tmp;

  1876.             outr[i] *= tmp;

  1877.         }

  1878.         KillNote();

  1879.     }

  1880.     return 1;

  1881. }

  1882. 

  1883. 

  1884. /*

  1885.  * Release the key (NoteOff)

  1886.  */

  1887. void ADnote::releasekey()

  1888. {

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

  1890.         NoteVoicePar[nvoice].releasekey();

  1891.     NoteGlobalPar.FreqEnvelope->releasekey();

  1892.     NoteGlobalPar.FilterEnvelope->releasekey();

  1893.     NoteGlobalPar.AmpEnvelope->releasekey();

  1894. }

  1895. 

  1896. /*

  1897.  * Check if the note is finished

  1898.  */

  1899. bool ADnote::finished() const

  1900. {

  1901.     if(NoteEnabled == ON)

  1902.         return 0;

  1903.     else

  1904.         return 1;

  1905. }

  1906. 

  1907. void ADnote::entomb(void)

  1908. {

  1909.     NoteGlobalPar.AmpEnvelope->forceFinish();

  1910. }

  1911. 

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

  1913. {

  1914.     if(!Enabled)

  1915.         return;

  1916.     if(AmpEnvelope)

  1917.         AmpEnvelope->releasekey();

  1918.     if(FreqEnvelope)

  1919.         FreqEnvelope->releasekey();

  1920.     if(FilterEnvelope)

  1921.         FilterEnvelope->releasekey();

  1922.     if(FMFreqEnvelope)

  1923.         FMFreqEnvelope->releasekey();

  1924.     if(FMAmpEnvelope)

  1925.         FMAmpEnvelope->releasekey();

  1926. }

  1927. 

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

  1929. {

  1930.     memory.devalloc(OscilSmp);

  1931.     memory.dealloc(FreqEnvelope);

  1932.     memory.dealloc(FreqLfo);

  1933.     memory.dealloc(AmpEnvelope);

  1934.     memory.dealloc(AmpLfo);

  1935.     memory.dealloc(Filter);

  1936.     memory.dealloc(FilterEnvelope);

  1937.     memory.dealloc(FilterLfo);

  1938.     memory.dealloc(FMFreqEnvelope);

  1939.     memory.dealloc(FMAmpEnvelope);

  1940. 

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

  1942.         memory.devalloc(FMSmp);

  1943. 

  1944.     if(VoiceOut)

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

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

  1947.     //an input to another voice

  1948. 

  1949.     Enabled = OFF;

  1950. }

  1951. 

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

  1953. {

  1954.     memory.dealloc(FreqEnvelope);

  1955.     memory.dealloc(FreqLfo);

  1956.     memory.dealloc(AmpEnvelope);

  1957.     memory.dealloc(AmpLfo);

  1958.     memory.dealloc(Filter);

  1959.     memory.dealloc(FilterEnvelope);

  1960.     memory.dealloc(FilterLfo);

  1961. }

  1962. 

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

  1964.                                     const SYNTH_T &synth,

  1965.                                     const AbsTime &time,

  1966.                                     class Allocator &memory,

  1967.                                     float basefreq, float velocity,

  1968.                                     bool stereo,

  1969.                                     WatchManager *wm,

  1970.                                     const char *prefix)

  1971. {

  1972.     ScratchString pre = prefix;

  1973.     FreqEnvelope = memory.alloc<Envelope>(*param.FreqEnvelope, basefreq,

  1974.             synth.dt(), wm, (pre+"GlobalPar/FreqEnvelope/").c_str);

  1975.     FreqLfo      = memory.alloc<LFO>(*param.FreqLfo, basefreq, time, wm,

  1976.                    (pre+"GlobalPar/FreqLfo/").c_str);

  1977. 

  1978.     AmpEnvelope = memory.alloc<Envelope>(*param.AmpEnvelope, basefreq,

  1979.             synth.dt(), wm, (pre+"GlobalPar/AmpEnvelope/").c_str);

  1980.     AmpLfo      = memory.alloc<LFO>(*param.AmpLfo, basefreq, time, wm,

  1981.                    (pre+"GlobalPar/AmpLfo/").c_str);

  1982. 

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

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

  1985. 

  1986.     Filter = memory.alloc<ModFilter>(*param.GlobalFilter, synth, time, memory, 

  1987.             stereo, basefreq);

  1988. 

  1989.     FilterEnvelope = memory.alloc<Envelope>(*param.FilterEnvelope, basefreq,

  1990.             synth.dt(), wm, (pre+"GlobalPar/FilterEnvelope/").c_str);

  1991.     FilterLfo      = memory.alloc<LFO>(*param.FilterLfo, basefreq, time, wm,

  1992.                    (pre+"GlobalPar/FilterLfo/").c_str);

  1993. 

  1994.     Filter->addMod(*FilterEnvelope);

  1995.     Filter->addMod(*FilterLfo);

  1996.     

  1997.     {

  1998.         Filter->updateSense(velocity, param.PFilterVelocityScale,

  1999.                 param.PFilterVelocityScaleFunction);

  2000.     }

  2001. }

  2002. 

  2003. }