falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
3221 Commits
17 Branches
116MB
Tree: c52413aca4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c52413aca4'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/Synth/ADnote.cpp

1938 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 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.     memory.beginTransaction();

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

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

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

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

  46. 

  47.     ADnoteParameters &pars = *pars_;

  48.     portamento  = spars.portamento;

  49.     midinote    = spars.note;

  50.     NoteEnabled = ON;

  51.     basefreq    = spars.frequency;

  52.     velocity    = spars.velocity;

  53.     stereo = pars.GlobalPar.PStereo;

  54. 

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

  56.                                      pars.GlobalPar.PCoarseDetune,

  57.                                      pars.GlobalPar.PDetune);

  58.     bandwidthDetuneMultiplier = pars.getBandwidthDetuneMultiplier();

  59. 

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

  61.         NoteGlobalPar.Panning = RND;

  62.     else

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

  64. 

  65. 

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

  67.                                       + pars.GlobalPar.PFilterVelocityScale

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

  69.                                       * (VelF(velocity,

  70.                                               pars.GlobalPar.

  71.                                               PFilterVelocityScaleFunction) - 1);

  72. 

  73.     NoteGlobalPar.Fadein_adjustment =

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

  75.     NoteGlobalPar.Fadein_adjustment *= NoteGlobalPar.Fadein_adjustment;

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

  77.         NoteGlobalPar.Punch.Enabled = 1;

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

  79.         NoteGlobalPar.Punch.initialvalue =

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

  81.              * VelF(velocity,

  82.                     pars.GlobalPar.PPunchVelocitySensing));

  83.         float time =

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

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

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

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

  88.     }

  89.     else

  90.         NoteGlobalPar.Punch.Enabled = 0;

  91. 

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

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

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

  95. 

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

  97.         NoteVoicePar[nvoice].OscilSmp = NULL;

  98.         NoteVoicePar[nvoice].FMSmp    = NULL;

  99.         NoteVoicePar[nvoice].VoiceOut = NULL;

  100. 

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

  102.         unison_size[nvoice] = 1;

  103. 

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

  105.             NoteVoicePar[nvoice].Enabled = OFF;

  106.             continue; //the voice is disabled

  107.         }

  108. 

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

  110.         if (BendAdj % 24 == 0)

  111.             NoteVoicePar[nvoice].BendAdjust = BendAdj / 24;

  112.         else

  113.             NoteVoicePar[nvoice].BendAdjust = BendAdj / 24.0f;

  114. 

  115.         float offset_val = (pars.VoicePar[nvoice].POffsetHz - 64)/64.0f;

  116.         NoteVoicePar[nvoice].OffsetHz =

  117.             15.0f*(offset_val * sqrtf(fabsf(offset_val)));

  118. 

  119.         unison_stereo_spread[nvoice] =

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

  121. 

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

  123.         if(unison < 1)

  124.             unison = 1;

  125. 

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

  127. 

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

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

  130.             if (unison > 2)

  131.                 unison = 2;

  132.         } else if (is_pwm) {

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

  134.             unison *= 2;

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

  136.             if (unison > 64)

  137.                 unison = 64;

  138.         }

  139. 

  140.         //compute unison

  141.         unison_size[nvoice] = unison;

  142. 

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

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

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

  146.         float unison_spread =

  147.             pars.getUnisonFrequencySpreadCents(nvoice);

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

  149.         float unison_vibratto_a  =

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

  151. 

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

  153.         switch(true_unison) {

  154.             case 1:

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

  156.                 break;

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

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

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

  160.             };

  161.                 break;

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

  163.                 float unison_values[true_unison];

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

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

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

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

  168.                     unison_values[k] = val;

  169.                     if (min > val) {

  170.                         min = val;

  171.                     }

  172.                     if (max < val) {

  173.                         max = val;

  174.                     }

  175.                 }

  176.                 float diff = max - min;

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

  178.                     unison_values[k] =

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

  180.                     unison_base_freq_rap[nvoice][k] =

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

  182.                 }

  183.             };

  184.         }

  185.         if (is_pwm)

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

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

  188.                     unison_base_freq_rap[nvoice][i];

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

  190.                     unison_base_freq_rap[nvoice][i];

  191.             }

  192. 

  193.         //unison vibrattos

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

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

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

  197.                                                   + (unison_base_freq_rap[

  198.                                                          nvoice][k] - 1.0f)

  199.                                                   * (1.0f - unison_vibratto_a);

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

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

  202.         unison_vibratto[nvoice].amplitude =

  203.             (unison_real_spread - 1.0f) * unison_vibratto_a;

  204. 

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

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

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

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

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

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

  211.             float vibratto_period = vibratto_base_period

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

  213. 

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

  215.             if(RND < 0.5f)

  216.                 m = -m;

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

  218. 

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

  220.             if (is_pwm)

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

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

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

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

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

  226.                 }

  227.         }

  228. 

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

  230.             if (is_pwm) {

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

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

  233.             }

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

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

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

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

  238.             }

  239.         }

  240. 

  241.         //phase invert for unison

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

  243.         if(unison != 1) {

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

  245.             switch(inv) {

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

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

  248.                     break;

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

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

  251.                     break;

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

  253.                         unison_invert_phase[nvoice][k] =

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

  255.                     break;

  256.             }

  257.         }

  258. 

  259. 

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

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

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

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

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

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

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

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

  268. 

  269.         NoteVoicePar[nvoice].Enabled     = ON;

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

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

  272. 

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

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

  275.             NoteVoicePar[nvoice].Detune = getdetune(

  276.                 pars.VoicePar[nvoice].PDetuneType,

  277.                 pars.VoicePar[nvoice].

  278.                 PCoarseDetune,

  279.                 8192); //coarse detune

  280.             NoteVoicePar[nvoice].FineDetune = getdetune(

  281.                 pars.VoicePar[nvoice].PDetuneType,

  282.                 0,

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

  284.         }

  285.         else {

  286.             NoteVoicePar[nvoice].Detune = getdetune(

  287.                 pars.GlobalPar.PDetuneType,

  288.                 pars.VoicePar[nvoice].

  289.                 PCoarseDetune,

  290.                 8192); //coarse detune

  291.             NoteVoicePar[nvoice].FineDetune = getdetune(

  292.                 pars.GlobalPar.PDetuneType,

  293.                 0,

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

  295.         }

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

  297.             NoteVoicePar[nvoice].FMDetune = getdetune(

  298.                 pars.VoicePar[nvoice].PFMDetuneType,

  299.                 pars.VoicePar[nvoice].

  300.                 PFMCoarseDetune,

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

  302.         else

  303.             NoteVoicePar[nvoice].FMDetune = getdetune(

  304.                 pars.GlobalPar.PDetuneType,

  305.                 pars.VoicePar[nvoice].

  306.                 PFMCoarseDetune,

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

  308. 

  309. 

  310. 

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

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

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

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

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

  316.         }

  317. 

  318.         //the extra points contains the first point

  319.         NoteVoicePar[nvoice].OscilSmp =

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

  321. 

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

  323.         int vc = nvoice;

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

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

  326.         if(!pars.GlobalPar.Hrandgrouping)

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

  328.         int oscposhi_start =

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

  330.                                              getvoicebasefreq(nvoice),

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

  332. 

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

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

  335.         // machines run this stuff too.

  336.         //

  337.         // //Find range of generated wave

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

  339.         // float max = min;

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

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

  342.         //     if (*smpls > max)

  343.         //         max = *smpls;

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

  345.         //         min = *smpls;

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

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

  348. 

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

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

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

  352.                                           + i] =

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

  354. 

  355.         NoteVoicePar[nvoice].phase_offset =

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

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

  358.                   + synth.oscilsize * 4);

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

  360. 

  361.         int kth_start = oscposhi_start;

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

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

  364.             //put random starting point for other subvoices

  365.             kth_start      = oscposhi_start +

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

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

  368.         }

  369. 

  370.         NoteVoicePar[nvoice].FreqLfo      = NULL;

  371.         NoteVoicePar[nvoice].FreqEnvelope = NULL;

  372. 

  373.         NoteVoicePar[nvoice].AmpLfo      = NULL;

  374.         NoteVoicePar[nvoice].AmpEnvelope = NULL;

  375. 

  376.         NoteVoicePar[nvoice].VoiceFilterL   = NULL;

  377.         NoteVoicePar[nvoice].VoiceFilterR   = NULL;

  378.         NoteVoicePar[nvoice].FilterEnvelope = NULL;

  379.         NoteVoicePar[nvoice].FilterLfo      = NULL;

  380. 

  381.         NoteVoicePar[nvoice].FilterCenterPitch =

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

  383.             + pars.VoicePar[nvoice].PFilterVelocityScale

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

  385.             * (VelF(velocity,

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

  387.         NoteVoicePar[nvoice].filterbypass =

  388.             pars.VoicePar[nvoice].Pfilterbypass;

  389. 

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

  391.             NoteVoicePar[nvoice].FMEnabled = NONE;

  392.         else

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

  394.                 case 1:

  395.                     NoteVoicePar[nvoice].FMEnabled = MORPH;

  396.                     break;

  397.                 case 2:

  398.                     NoteVoicePar[nvoice].FMEnabled = RING_MOD;

  399.                     break;

  400.                 case 3:

  401.                     NoteVoicePar[nvoice].FMEnabled = PHASE_MOD;

  402.                     break;

  403.                 case 4:

  404.                     NoteVoicePar[nvoice].FMEnabled = FREQ_MOD;

  405.                     break;

  406.                 case 5:

  407.                     NoteVoicePar[nvoice].FMEnabled = PW_MOD;

  408.                     break;

  409.                 default:

  410.                     NoteVoicePar[nvoice].FMEnabled = NONE;

  411.             }

  412. 

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

  414.         NoteVoicePar[nvoice].FMFreqEnvelope = NULL;

  415.         NoteVoicePar[nvoice].FMAmpEnvelope  = NULL;

  416.         NoteVoicePar[nvoice].FMFreqFixed  = pars.VoicePar[nvoice].PFMFixedFreq;

  417. 

  418. 

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

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

  421.                                    nvoice),

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

  423.                                - 1.0f);

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

  425.             case PHASE_MOD:

  426.             case PW_MOD:

  427.                 fmvoldamp =

  428.                     powf(440.0f / getvoicebasefreq(

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

  430.                          / 64.0f);

  431.                 NoteVoicePar[nvoice].FMVolume =

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

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

  434.                 break;

  435.             case FREQ_MOD:

  436.                 NoteVoicePar[nvoice].FMVolume =

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

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

  439.                 break;

  440.             default:

  441.                 if(fmvoldamp > 1.0f)

  442.                     fmvoldamp = 1.0f;

  443.                 NoteVoicePar[nvoice].FMVolume =

  444.                     pars.VoicePar[nvoice].PFMVolume

  445.                     / 127.0f * fmvoldamp;

  446.         }

  447. 

  448.         //Voice's modulator velocity sensing

  449.         NoteVoicePar[nvoice].FMVolume *=

  450.             VelF(velocity,

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

  452. 

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

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

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

  456. 

  457.         firsttick[nvoice] = 1;

  458.         NoteVoicePar[nvoice].DelayTicks =

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

  460.                         * logf(50.0f))

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

  462.     }

  463. 

  464.     max_unison = 1;

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

  466.         if(unison_size[nvoice] > max_unison)

  467.             max_unison = unison_size[nvoice];

  468. 

  469. 

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

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

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

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

  474.     }

  475. 

  476.     initparameters();

  477.     memory.endTransaction();

  478. }

  479. 

  480. SynthNote *ADnote::cloneLegato(void)

  481. {

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

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

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

  485. }

  486. 

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

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

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

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

  491. void ADnote::legatonote(LegatoParams lpars)

  492. {

  493.     //ADnoteParameters &pars = *partparams;

  494. 

  495.     // Manage legato stuff

  496.     if(legato.update(lpars))

  497.         return;

  498. 

  499.     portamento = lpars.portamento;

  500.     midinote   = lpars.midinote;

  501.     basefreq   = lpars.frequency;

  502. 

  503.     if(velocity > 1.0f)

  504.         velocity = 1.0f;

  505.     velocity = lpars.velocity;

  506. 

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

  508.                                      pars.GlobalPar.PCoarseDetune,

  509.                                      pars.GlobalPar.PDetune);

  510.     bandwidthDetuneMultiplier = pars.getBandwidthDetuneMultiplier();

  511. 

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

  513.         NoteGlobalPar.Panning = RND;

  514.     else

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

  516. 

  517.     //center freq

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

  519.                                       + pars.GlobalPar.PFilterVelocityScale

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

  521.                                       * (VelF(velocity,

  522.                                               pars.GlobalPar.

  523.                                               PFilterVelocityScaleFunction) - 1);

  524. 

  525. 

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

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

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

  529. 

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

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

  532. 

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

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

  535.             NoteVoicePar[nvoice].Detune = getdetune(

  536.                 pars.VoicePar[nvoice].PDetuneType,

  537.                 pars.VoicePar[nvoice].PCoarseDetune,

  538.                 8192); //coarse detune

  539.             NoteVoicePar[nvoice].FineDetune = getdetune(

  540.                 pars.VoicePar[nvoice].PDetuneType,

  541.                 0,

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

  543.         }

  544.         else {

  545.             NoteVoicePar[nvoice].Detune = getdetune(

  546.                 pars.GlobalPar.PDetuneType,

  547.                 pars.VoicePar[nvoice].PCoarseDetune,

  548.                 8192); //coarse detune

  549.             NoteVoicePar[nvoice].FineDetune = getdetune(

  550.                 pars.GlobalPar.PDetuneType,

  551.                 0,

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

  553.         }

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

  555.             NoteVoicePar[nvoice].FMDetune = getdetune(

  556.                 pars.VoicePar[nvoice].PFMDetuneType,

  557.                 pars.VoicePar[nvoice].PFMCoarseDetune,

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

  559.         else

  560.             NoteVoicePar[nvoice].FMDetune = getdetune(

  561.                 pars.GlobalPar.PDetuneType,

  562.                 pars.VoicePar[nvoice].PFMCoarseDetune,

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

  564. 

  565. 

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

  567.         int vc = nvoice;

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

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

  570.         if(!pars.GlobalPar.Hrandgrouping)

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

  572. 

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

  574.                                          getvoicebasefreq(nvoice),

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

  576. 

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

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

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

  580.                                           + i] =

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

  582. 

  583. 

  584.         NoteVoicePar[nvoice].FilterCenterPitch =

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

  586.             + pars.VoicePar[nvoice].PFilterVelocityScale

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

  588.             * (VelF(velocity,

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

  590. 

  591.         NoteVoicePar[nvoice].filterbypass =

  592.             pars.VoicePar[nvoice].Pfilterbypass;

  593. 

  594. 

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

  596. 

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

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

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

  600.                                - 1.0f);

  601. 

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

  603.             case PHASE_MOD:

  604.             case PW_MOD:

  605.                 fmvoldamp =

  606.                     powf(440.0f / getvoicebasefreq(

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

  608.                          / 64.0f);

  609.                 NoteVoicePar[nvoice].FMVolume =

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

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

  612.                 break;

  613.             case FREQ_MOD:

  614.                 NoteVoicePar[nvoice].FMVolume =

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

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

  617.                 break;

  618.             default:

  619.                 if(fmvoldamp > 1.0f)

  620.                     fmvoldamp = 1.0f;

  621.                 NoteVoicePar[nvoice].FMVolume =

  622.                     pars.VoicePar[nvoice].PFMVolume

  623.                     / 127.0f * fmvoldamp;

  624.         }

  625. 

  626.         //Voice's modulator velocity sensing

  627.         NoteVoicePar[nvoice].FMVolume *=

  628.             VelF(velocity,

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

  630. 

  631.         NoteVoicePar[nvoice].DelayTicks =

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

  633.                         * logf(50.0f))

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

  635.     }

  636. 

  637.     ///    initparameters();

  638. 

  639.     ///////////////

  640.     // Altered content of initparameters():

  641. 

  642.     int tmp[NUM_VOICES];

  643. 

  644.     NoteGlobalPar.Volume = 4.0f

  645.                            * powf(0.1f, 3.0f

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

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

  648.                            * VelF(

  649.         velocity,

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

  651. 

  652.     globalnewamplitude = NoteGlobalPar.Volume

  653.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  655. 

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

  657.     NoteGlobalPar.FilterFreqTracking =

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

  659. 

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

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

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

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

  664. 

  665.     // Voice Parameter init

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

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

  668.             continue;

  669. 

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

  671.         /* Voice Amplitude Parameters Init */

  672.         NoteVoicePar[nvoice].Volume =

  673.             powf(0.1f, 3.0f

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

  675.             * VelF(velocity,

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

  677. 

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

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

  680. 

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

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

  683.         else

  684.             NoteVoicePar[nvoice].Panning =

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

  686. 

  687.         newamplitude[nvoice] = 1.0f;

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

  689.            && NoteVoicePar[nvoice].AmpEnvelope)

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

  691. 

  692. 

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

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

  695. 

  696. 

  697. 

  698.         NoteVoicePar[nvoice].FilterFreqTracking =

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

  700. 

  701.         /* Voice Modulation Parameters Init */

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

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

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

  705. 

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

  707. 

  708.             int vc = nvoice;

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

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

  711. 

  712.             if(!pars.GlobalPar.Hrandgrouping)

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

  714. 

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

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

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

  718.         }

  719. 

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

  721.                                  * ctl.fmamp.relamp;

  722. 

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

  724.            && NoteVoicePar[nvoice].FMAmpEnvelope)

  725.             FMnewamplitude[nvoice] *=

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

  727.     }

  728. 

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

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

  731.             tmp[i] = 0;

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

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

  734.                 tmp[i] = 1;

  735.     }

  736. }

  737. 

  738. 

  739. /*

  740.  * Kill a voice of ADnote

  741.  */

  742. void ADnote::KillVoice(int nvoice)

  743. {

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

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

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

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

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

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

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

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

  752. 

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

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

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

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

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

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

  759. 

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

  761. }

  762. 

  763. /*

  764.  * Kill the note

  765.  */

  766. void ADnote::KillNote()

  767. {

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

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

  770.             KillVoice(nvoice);

  771. 

  772.         if(NoteVoicePar[nvoice].VoiceOut)

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

  774.     }

  775. 

  776.     NoteGlobalPar.kill(memory);

  777. 

  778.     NoteEnabled = OFF;

  779. }

  780. 

  781. ADnote::~ADnote()

  782. {

  783.     if(NoteEnabled == ON)

  784.         KillNote();

  785.     memory.devalloc(tmpwavel);

  786.     memory.devalloc(tmpwaver);

  787.     memory.devalloc(bypassl);

  788.     memory.devalloc(bypassr);

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

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

  791.     memory.devalloc(tmpwave_unison);

  792. }

  793. 

  794. 

  795. /*

  796.  * Init the parameters

  797.  */

  798. void ADnote::initparameters()

  799. {

  800.     int tmp[NUM_VOICES];

  801.     //ADnoteParameters &pars = *partparams;

  802. 

  803.     // Global Parameters

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

  805.                                  time,

  806.                                  memory, basefreq, velocity,

  807.                                  stereo);

  808. 

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

  810.     globalnewamplitude = NoteGlobalPar.Volume

  811.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  813. 

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

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

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

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

  818. 

  819.     // Voice Parameter init

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

  821.         Voice &vce = NoteVoicePar[nvoice];

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

  823. 

  824.         if(vce.Enabled == 0)

  825.             continue;

  826. 

  827.         vce.noisetype = param.Type;

  828.         /* Voice Amplitude Parameters Init */

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

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

  831. 

  832.         if(param.PVolumeminus)

  833.             vce.Volume = -vce.Volume;

  834. 

  835.         if(param.PPanning == 0)

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

  837.         else

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

  839. 

  840.         newamplitude[nvoice] = 1.0f;

  841.         if(param.PAmpEnvelopeEnabled) {

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

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

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

  845.         }

  846. 

  847.         if(param.PAmpLfoEnabled) {

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

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

  850.         }

  851. 

  852.         /* Voice Frequency Parameters Init */

  853.         if(param.PFreqEnvelopeEnabled)

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

  855. 

  856.         if(param.PFreqLfoEnabled)

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

  858. 

  859.         /* Voice Filter Parameters Init */

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

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

  862.                     synth.samplerate, synth.buffersize);

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

  864.                     synth.samplerate, synth.buffersize);

  865.         }

  866. 

  867.         if(param.PFilterEnvelopeEnabled)

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

  869. 

  870.         if(param.PFilterLfoEnabled)

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

  872. 

  873.         vce.FilterFreqTracking =

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

  875. 

  876.         /* Voice Modulation Parameters Init */

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

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

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

  880. 

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

  882. 

  883.             int vc = nvoice;

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

  885.                 vc = param.PextFMoscil;

  886. 

  887.             float tmp = 1.0f;

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

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

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

  891.                 tmp = getFMvoicebasefreq(nvoice);

  892. 

  893.             if(!pars.GlobalPar.Hrandgrouping)

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

  895. 

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

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

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

  899.                                              vce.FMSmp, tmp))

  900.                                         % synth.oscilsize;

  901. 

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

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

  904.             int oscposhiFM_add =

  905.                 (int)((param.PFMoscilphase

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

  907.                       + synth.oscilsize * 4);

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

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

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

  911.             }

  912.         }

  913. 

  914.         if(param.PFMFreqEnvelopeEnabled)

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

  916. 

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

  918. 

  919.         if(param.PFMAmpEnvelopeEnabled ) {

  920.             vce.FMAmpEnvelope =

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

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

  923.         }

  924.     }

  925. 

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

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

  928.             tmp[i] = 0;

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

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

  931.                 NoteVoicePar[nvoice].VoiceOut =

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

  933.                 tmp[i] = 1;

  934.             }

  935. 

  936.         if(NoteVoicePar[nvoice].VoiceOut)

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

  938.     }

  939. }

  940. 

  941. 

  942. /*

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

  944.  * This must be called before setfreq* functions

  945.  */

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

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

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

  949.         return;

  950.     }

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

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

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

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

  955.         pos += step;

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

  957.             pos  = -1.0f;

  958.             step = -step;

  959.         }

  960.         if(pos >= 1.0f) {

  961.             pos  = 1.0f;

  962.             step = -step;

  963.         }

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

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

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

  967.                                          - 1.0f) + vibratto_val

  968.                                         * unison_vibratto[nvoice].amplitude)

  969.                                      * relbw;

  970. 

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

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

  973.     }

  974. }

  975. 

  976. 

  977. /*

  978.  * Computes the frequency of an oscillator

  979.  */

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

  981. {

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

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

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

  985.         if(speed > synth.oscilsize_f)

  986.             speed = synth.oscilsize_f;

  987. 

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

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

  990.     }

  991. }

  992. 

  993. /*

  994.  * Computes the frequency of an modullator oscillator

  995.  */

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

  997. {

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

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

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

  1001.         if(speed > synth.samplerate_f)

  1002.             speed = synth.samplerate_f;

  1003. 

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

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

  1006.     }

  1007. }

  1008. 

  1009. /*

  1010.  * Get Voice base frequency

  1011.  */

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

  1013. {

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

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

  1016.                    * ctl.bandwidth.relbw * bandwidthDetuneMultiplier

  1017.                    + NoteGlobalPar.Detune / 100.0f;

  1018. 

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

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

  1021.     else { //the fixed freq is enabled

  1022.         float fixedfreq   = 440.0f;

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

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

  1025.             float tmp =

  1026.                 (midinote

  1027.                  - 69.0f) / 12.0f

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

  1029.             if(fixedfreqET <= 64)

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

  1031.             else

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

  1033.         }

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

  1035.     }

  1036. }

  1037. 

  1038. /*

  1039.  * Get Voice's Modullator base frequency

  1040.  */

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

  1042. {

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

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

  1045. }

  1046. 

  1047. /*

  1048.  * Computes all the parameters for each tick

  1049.  */

  1050. void ADnote::computecurrentparameters()

  1051. {

  1052.     int   nvoice;

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

  1054.           FMrelativepitch, globalpitch, globalfilterpitch;

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

  1056.                            + NoteGlobalPar.FreqLfo->lfoout()

  1057.                            * ctl.modwheel.relmod);

  1058.     globaloldamplitude = globalnewamplitude;

  1059.     globalnewamplitude = NoteGlobalPar.Volume

  1060.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  1062. 

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

  1064.                         + NoteGlobalPar.FilterLfo->lfoout()

  1065.                         + NoteGlobalPar.FilterCenterPitch;

  1066. 

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

  1068.                           + NoteGlobalPar.FilterFreqTracking;

  1069. 

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

  1071. 

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

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

  1074.     if(stereo != 0)

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

  1076. 

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

  1078.     float portamentofreqrap = 1.0f;

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

  1080.         portamentofreqrap = ctl.portamento.freqrap;

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

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

  1083.     }

  1084. 

  1085.     //compute parameters for all voices

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

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

  1088.             continue;

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

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

  1091.             continue;

  1092. 

  1093.         compute_unison_freq_rap(nvoice);

  1094. 

  1095.         /*******************/

  1096.         /* Voice Amplitude */

  1097.         /*******************/

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

  1099.         newamplitude[nvoice] = 1.0f;

  1100. 

  1101.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

  1103. 

  1104.         if(NoteVoicePar[nvoice].AmpLfo)

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

  1106. 

  1107.         /****************/

  1108.         /* Voice Filter */

  1109.         /****************/

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

  1111.             filterpitch = NoteVoicePar[nvoice].FilterCenterPitch;

  1112. 

  1113.             if(NoteVoicePar[nvoice].FilterEnvelope)

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

  1115. 

  1116.             if(NoteVoicePar[nvoice].FilterLfo)

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

  1118. 

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

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

  1121. 

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

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

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

  1125.         }

  1126. 

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

  1128.             /*******************/

  1129.             /* Voice Frequency */

  1130.             /*******************/

  1131.             voicepitch = 0.0f;

  1132.             if(NoteVoicePar[nvoice].FreqLfo)

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

  1134.                               * ctl.bandwidth.relbw;

  1135. 

  1136.             if(NoteVoicePar[nvoice].FreqEnvelope)

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

  1138.                               / 100.0f;

  1139.             voicefreq = getvoicebasefreq(nvoice)

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

  1141.             voicefreq *=

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

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

  1144. 

  1145.             /***************/

  1146.             /*  Modulator */

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

  1148. 

  1149. 

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

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

  1152.                 if(NoteVoicePar[nvoice].FMFreqEnvelope)

  1153.                     FMrelativepitch +=

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

  1155.                 if (NoteVoicePar[nvoice].FMFreqFixed)

  1156.                     FMfreq =

  1157.                         powf(2.0f, FMrelativepitch

  1158.                              / 12.0f) * 440.0f;

  1159.                 else

  1160.                     FMfreq =

  1161.                            powf(2.0f, FMrelativepitch

  1162.                                 / 12.0f) * voicefreq * portamentofreqrap;

  1163.                 setfreqFM(nvoice, FMfreq);

  1164. 

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

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

  1167.                                          * ctl.fmamp.relamp;

  1168.                 if(NoteVoicePar[nvoice].FMAmpEnvelope)

  1169.                     FMnewamplitude[nvoice] *=

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

  1171.             }

  1172.         }

  1173.     }

  1174. }

  1175. 

  1176. 

  1177. /*

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

  1179.  */

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

  1181. {

  1182.     int zerocrossings = 0;

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

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

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

  1186. 

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

  1188.     if(tmp < 8.0f)

  1189.         tmp = 8.0f;

  1190.     tmp *= NoteGlobalPar.Fadein_adjustment;

  1191. 

  1192.     int n;

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

  1194.     if(n > synth.buffersize)

  1195.         n = synth.buffersize;

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

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

  1198.         smps[i] *= tmp;

  1199.     }

  1200. }

  1201. 

  1202. /*

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

  1204.  */

  1205. 

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

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

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

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

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

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

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

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

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

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

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

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

  1218.  */

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

  1220. {

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

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

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

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

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

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

  1227.         float *tw     = tmpwave_unison[k];

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

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

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

  1231.             poslo += freqlo;

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

  1233.             poslo &= 0xffffff;

  1234.             poshi &= synth.oscilsize - 1;

  1235.         }

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

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

  1238.     }

  1239. }

  1240. 

  1241. 

  1242. 

  1243. /*

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

  1245.  *

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

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

  1248.     int i,poshi;

  1249.     float poslo;

  1250. 

  1251.     poshi=oscposhi[nvoice];

  1252.     poslo=oscposlo[nvoice];

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

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

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

  1256.     xm1=smps[poshi];

  1257.     x0=smps[poshi+1];

  1258.     x1=smps[poshi+2];

  1259.     x2=smps[poshi+3];

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

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

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

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

  1264.     printf("a\n");

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

  1266.     poslo+=oscfreqlo[nvoice];

  1267.     if (poslo>=1.0f) {

  1268.             poslo-=1.0f;

  1269.         poshi++;

  1270.     };

  1271.         poshi+=oscfreqhi[nvoice];

  1272.         poshi&=synth.oscilsize-1;

  1273.     };

  1274.     oscposhi[nvoice]=poshi;

  1275.     oscposlo[nvoice]=poslo;

  1276. };

  1277. */

  1278. /*

  1279.  * Computes the Oscillator (Morphing)

  1280.  */

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

  1282. {

  1283.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1285.         FMnewamplitude[nvoice] = 1.0f;

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

  1287.         FMoldamplitude[nvoice] = 1.0f;

  1288. 

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

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

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

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

  1293.             float *tw = tmpwave_unison[k];

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

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

  1296.                                             FMnewamplitude[nvoice],

  1297.                                             i,

  1298.                                             synth.buffersize);

  1299.                 tw[i] = tw[i]

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

  1301.             }

  1302.         }

  1303.     }

  1304.     else

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

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

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

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

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

  1310.             float *tw = tmpwave_unison[k];

  1311. 

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

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

  1314.                                             FMnewamplitude[nvoice],

  1315.                                             i,

  1316.                                             synth.buffersize);

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

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

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

  1320.                 posloFM += freqloFM;

  1321.                 if(posloFM >= 1.0f) {

  1322.                     posloFM -= 1.0f;

  1323.                     poshiFM++;

  1324.                 }

  1325.                 poshiFM += freqhiFM;

  1326.                 poshiFM &= synth.oscilsize - 1;

  1327.             }

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

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

  1330.         }

  1331. }

  1332. 

  1333. /*

  1334.  * Computes the Oscillator (Ring Modulation)

  1335.  */

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

  1337. {

  1338.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1340.         FMnewamplitude[nvoice] = 1.0f;

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

  1342.         FMoldamplitude[nvoice] = 1.0f;

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

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

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

  1346.             float *tw = tmpwave_unison[k];

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

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

  1349.                                             FMnewamplitude[nvoice],

  1350.                                             i,

  1351.                                             synth.buffersize);

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

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

  1354.             }

  1355.         }

  1356.     else

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

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

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

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

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

  1362.             float *tw = tmpwave_unison[k];

  1363. 

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

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

  1366.                                             FMnewamplitude[nvoice],

  1367.                                             i,

  1368.                                             synth.buffersize);

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

  1370.                           + NoteVoicePar[nvoice].FMSmp[poshiFM

  1371.                                                        + 1] * posloFM) * amp

  1372.                          + (1.0f - amp);

  1373.                 posloFM += freqloFM;

  1374.                 if(posloFM >= 1.0f) {

  1375.                     posloFM -= 1.0f;

  1376.                     poshiFM++;

  1377.                 }

  1378.                 poshiFM += freqhiFM;

  1379.                 poshiFM &= synth.oscilsize - 1;

  1380.             }

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

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

  1383.         }

  1384. }

  1385. 

  1386. /*

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

  1388.  */

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

  1390.                                                               int FMmode)

  1391. {

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

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

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

  1395.             float *tw = tmpwave_unison[k];

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

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

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

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

  1400.             else

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

  1402.         }

  1403.     } else {

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

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

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

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

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

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

  1410.             float *tw = tmpwave_unison[k];

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

  1412. 

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

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

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

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

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

  1418. 

  1419.                 posloFM += freqloFM;

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

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

  1422.                     poshiFM++;

  1423.                 }

  1424.                 poshiFM += freqhiFM;

  1425.                 poshiFM &= synth.oscilsize - 1;

  1426.             }

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

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

  1429.         }

  1430.     }

  1431.     // Amplitude interpolation

  1432.     if(ABOVE_AMPLITUDE_THRESHOLD(FMoldamplitude[nvoice],

  1433.                                  FMnewamplitude[nvoice])) {

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

  1435.             float *tw = tmpwave_unison[k];

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

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

  1438.                                                FMnewamplitude[nvoice],

  1439.                                                i,

  1440.                                                synth.buffersize);

  1441.         }

  1442.     } else {

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

  1444.             float *tw = tmpwave_unison[k];

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

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

  1447.         }

  1448.     }

  1449. 

  1450. 

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

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

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

  1454.                           / synth.samplerate_f;

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

  1456.             float *tw    = tmpwave_unison[k];

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

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

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

  1460.                 tw[i] = fmold;

  1461.             }

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

  1463.         }

  1464.     }

  1465.     else {  //Phase or PWM modulation

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

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

  1468.             float *tw = tmpwave_unison[k];

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

  1470.                 tw[i] *= normalize;

  1471.         }

  1472.     }

  1473. 

  1474.     //do the modulation

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

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

  1477.         float *tw     = tmpwave_unison[k];

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

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

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

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

  1482. 

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

  1484.             int FMmodfreqhi = 0;

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

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

  1487.             if(FMmodfreqhi < 0)

  1488.                 FMmodfreqlo++;

  1489. 

  1490.             //carrier

  1491.             int carposhi = poshi + FMmodfreqhi;

  1492.             int carposlo = poslo + FMmodfreqlo;

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

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

  1495. 

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

  1497.                 carposhi++;

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

  1499.             }

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

  1501. 

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

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

  1504. 

  1505.             poslo += freqlo;

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

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

  1508.                 poshi++;

  1509.             }

  1510. 

  1511.             poshi += freqhi;

  1512.             poshi &= synth.oscilsize - 1;

  1513.         }

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

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

  1516.     }

  1517. }

  1518. 

  1519. 

  1520. /*

  1521.  * Computes the Noise

  1522.  */

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

  1524. {

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

  1526.         float *tw = tmpwave_unison[k];

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

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

  1529.     }

  1530. }

  1531. 

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

  1533. {

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

  1535.         float *tw = tmpwave_unison[k];

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

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

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

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

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

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

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

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

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

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

  1546. 	    f[6] = white*0.115926;

  1547.         }

  1548.     }

  1549. }

  1550. 

  1551. 

  1552. 

  1553. /*

  1554.  * Compute the ADnote samples

  1555.  * Returns 0 if the note is finished

  1556.  */

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

  1558. {

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

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

  1561. 

  1562.     if(NoteEnabled == OFF)

  1563.         return 0;

  1564. 

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

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

  1567.     computecurrentparameters();

  1568. 

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

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

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

  1572.             continue;

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

  1574.             case 0: //voice mode=sound

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

  1576.                     case MORPH:

  1577.                         ComputeVoiceOscillatorMorph(nvoice);

  1578.                         break;

  1579.                     case RING_MOD:

  1580.                         ComputeVoiceOscillatorRingModulation(nvoice);

  1581.                         break;

  1582.                     case FREQ_MOD:

  1583.                     case PHASE_MOD:

  1584.                     case PW_MOD:

  1585.                         ComputeVoiceOscillatorFrequencyModulation(nvoice,

  1586.                                                                   NoteVoicePar[nvoice].FMEnabled);

  1587.                         break;

  1588.                     default:

  1589.                         ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1591.                 }

  1592.                 break;

  1593.             case 1:

  1594.                 ComputeVoiceWhiteNoise(nvoice);

  1595.                 break;

  1596.             default:

  1597.                 ComputeVoicePinkNoise(nvoice);

  1598.                 break;

  1599.         }

  1600.         // Voice Processing

  1601. 

  1602. 

  1603.         //mix subvoices into voice

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

  1605.         if(stereo)

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

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

  1608.             float *tw = tmpwave_unison[k];

  1609.             if(stereo) {

  1610.                 float stereo_pos = 0;

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

  1612.                 if (is_pwm) {

  1613.                     if(unison_size[nvoice] > 2)

  1614.                         stereo_pos = k/2

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

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

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

  1618.                     stereo_pos = k

  1619.                         / (float)(unison_size[nvoice]

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

  1621.                 }

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

  1623.                 if(stereo_spread > 1.0f) {

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

  1625.                     stereo_pos =

  1626.                         (2.0f

  1627.                          - stereo_spread) * stereo_pos

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

  1629.                 }

  1630.                 else

  1631.                     stereo_pos *= stereo_spread;

  1632. 

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

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

  1635.                     stereo_pos = 0.0f;

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

  1637. 

  1638. 

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

  1640.                 if(lvol > 1.0f)

  1641.                     lvol = 1.0f;

  1642. 

  1643.                 float rvol = panning * 2.0f;

  1644.                 if(rvol > 1.0f)

  1645.                     rvol = 1.0f;

  1646. 

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

  1648.                     lvol = -lvol;

  1649.                     rvol = -rvol;

  1650.                 }

  1651. 

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

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

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

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

  1656.             }

  1657.             else

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

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

  1660.         }

  1661. 

  1662. 

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

  1664.         // Amplitude

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

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

  1667. 

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

  1669.             int rest = synth.buffersize;

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

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

  1672.                 rest = 10;

  1673.                 if(rest > synth.buffersize)

  1674.                     rest = synth.buffersize;

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

  1676.                     tmpwavel[i] *= oldam;

  1677.                 if(stereo)

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

  1679.                         tmpwaver[i] *= oldam;

  1680.             }

  1681.             // Amplitude interpolation

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

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

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

  1685.                 if(stereo)

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

  1687.             }

  1688.         }

  1689.         else {

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

  1691.                 tmpwavel[i] *= newam;

  1692.             if(stereo)

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

  1694.                     tmpwaver[i] *= newam;

  1695.         }

  1696. 

  1697.         // Fade in

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

  1699.             fadein(&tmpwavel[0]);

  1700.             if(stereo)

  1701.                 fadein(&tmpwaver[0]);

  1702.             firsttick[nvoice] = 0;

  1703.         }

  1704. 

  1705. 

  1706.         // Filter

  1707.         if(NoteVoicePar[nvoice].VoiceFilterL)

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

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

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

  1711. 

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

  1713.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

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

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

  1717.                 if(stereo)

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

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

  1720.             }

  1721.         //the voice is killed later

  1722. 

  1723. 

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

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

  1726.             if(stereo)

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

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

  1729.                                                        + tmpwaver[i];

  1730.             else   //mono

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

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

  1733.         }

  1734. 

  1735. 

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

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

  1738.             if(stereo)

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

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

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

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

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

  1744.                 }

  1745.             else

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

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

  1748.         }

  1749.         else {  //bypass the filter

  1750.             if(stereo)

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

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

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

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

  1755.                                   * (1.0f

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

  1757.                 }

  1758.             else

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

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

  1761.         }

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

  1763.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

  1765.                 KillVoice(nvoice);

  1766.     }

  1767. 

  1768. 

  1769.     //Processing Global parameters

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

  1771. 

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

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

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

  1775.     }

  1776.     else

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

  1778. 

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

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

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

  1782.     }

  1783. 

  1784.     if(ABOVE_AMPLITUDE_THRESHOLD(globaloldamplitude, globalnewamplitude))

  1785.         // Amplitude Interpolation

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

  1787.             float tmpvol = INTERPOLATE_AMPLITUDE(globaloldamplitude,

  1788.                                                  globalnewamplitude,

  1789.                                                  i,

  1790.                                                  synth.buffersize);

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

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

  1793.         }

  1794.     else

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

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

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

  1798.         }

  1799. 

  1800.     //Apply the punch

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

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

  1803.             float punchamp = NoteGlobalPar.Punch.initialvalue

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

  1805.             outl[i] *= punchamp;

  1806.             outr[i] *= punchamp;

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

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

  1809.                 NoteGlobalPar.Punch.Enabled = 0;

  1810.                 break;

  1811.             }

  1812.         }

  1813. 

  1814. 

  1815.     // Apply legato-specific sound signal modifications

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

  1817. 

  1818. 

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

  1820.     // If it does, disable the note

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

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

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

  1824.             outl[i] *= tmp;

  1825.             outr[i] *= tmp;

  1826.         }

  1827.         KillNote();

  1828.     }

  1829.     return 1;

  1830. }

  1831. 

  1832. 

  1833. /*

  1834.  * Release the key (NoteOff)

  1835.  */

  1836. void ADnote::releasekey()

  1837. {

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

  1839.         NoteVoicePar[nvoice].releasekey();

  1840.     NoteGlobalPar.FreqEnvelope->releasekey();

  1841.     NoteGlobalPar.FilterEnvelope->releasekey();

  1842.     NoteGlobalPar.AmpEnvelope->releasekey();

  1843. }

  1844. 

  1845. /*

  1846.  * Check if the note is finished

  1847.  */

  1848. int ADnote::finished() const

  1849. {

  1850.     if(NoteEnabled == ON)

  1851.         return 0;

  1852.     else

  1853.         return 1;

  1854. }

  1855. 

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

  1857. {

  1858.     if(!Enabled)

  1859.         return;

  1860.     if(AmpEnvelope)

  1861.         AmpEnvelope->releasekey();

  1862.     if(FreqEnvelope)

  1863.         FreqEnvelope->releasekey();

  1864.     if(FilterEnvelope)

  1865.         FilterEnvelope->releasekey();

  1866.     if(FMFreqEnvelope)

  1867.         FMFreqEnvelope->releasekey();

  1868.     if(FMAmpEnvelope)

  1869.         FMAmpEnvelope->releasekey();

  1870. }

  1871. 

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

  1873. {

  1874.     memory.devalloc(OscilSmp);

  1875.     memory.dealloc(FreqEnvelope);

  1876.     memory.dealloc(FreqLfo);

  1877.     memory.dealloc(AmpEnvelope);

  1878.     memory.dealloc(AmpLfo);

  1879.     memory.dealloc(VoiceFilterL);

  1880.     memory.dealloc(VoiceFilterR);

  1881.     memory.dealloc(FilterEnvelope);

  1882.     memory.dealloc(FilterLfo);

  1883.     memory.dealloc(FMFreqEnvelope);

  1884.     memory.dealloc(FMAmpEnvelope);

  1885. 

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

  1887.         memory.devalloc(FMSmp);

  1888. 

  1889.     if(VoiceOut)

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

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

  1892.     //an input to another voice

  1893. 

  1894.     Enabled = OFF;

  1895. }

  1896. 

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

  1898. {

  1899.     memory.dealloc(FreqEnvelope);

  1900.     memory.dealloc(FreqLfo);

  1901.     memory.dealloc(AmpEnvelope);

  1902.     memory.dealloc(AmpLfo);

  1903.     memory.dealloc(GlobalFilterL);

  1904.     memory.dealloc(GlobalFilterR);

  1905.     memory.dealloc(FilterEnvelope);

  1906.     memory.dealloc(FilterLfo);

  1907. }

  1908. 

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

  1910.                                     const SYNTH_T &synth,

  1911.                                     const AbsTime &time,

  1912.                                     class Allocator &memory,

  1913.                                     float basefreq, float velocity,

  1914.                                     bool stereo)

  1915. {

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

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

  1918. 

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

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

  1921. 

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

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

  1924. 

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

  1926.             synth.samplerate, synth.buffersize);

  1927.     if(stereo)

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

  1929.                 synth.samplerate, synth.buffersize);

  1930.     else

  1931.         GlobalFilterR = NULL;

  1932. 

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

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

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

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

  1937. }