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

1942 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. ADnote::ADnote(ADnoteParameters *pars_, SynthParams &spars,

  31.         WatchManager *wm, const char *prefix)

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

  33. {

  34.     memory.beginTransaction();

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

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

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

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

  39. 

  40.     ADnoteParameters &pars = *pars_;

  41.     portamento  = spars.portamento;

  42.     midinote    = spars.note;

  43.     NoteEnabled = ON;

  44.     basefreq    = spars.frequency;

  45.     velocity    = spars.velocity;

  46.     stereo = pars.GlobalPar.PStereo;

  47. 

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

  49.                                      pars.GlobalPar.PCoarseDetune,

  50.                                      pars.GlobalPar.PDetune);

  51.     bandwidthDetuneMultiplier = pars.getBandwidthDetuneMultiplier();

  52. 

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

  54.         NoteGlobalPar.Panning = RND;

  55.     else

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

  57. 

  58. 

  59.     NoteGlobalPar.Fadein_adjustment =

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

  61.     NoteGlobalPar.Fadein_adjustment *= NoteGlobalPar.Fadein_adjustment;

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

  63.         NoteGlobalPar.Punch.Enabled = 1;

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

  65.         NoteGlobalPar.Punch.initialvalue =

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

  67.              * VelF(velocity,

  68.                     pars.GlobalPar.PPunchVelocitySensing));

  69.         float time =

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

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

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

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

  74.     }

  75.     else

  76.         NoteGlobalPar.Punch.Enabled = 0;

  77. 

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

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

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

  81. 

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

  83.         NoteVoicePar[nvoice].OscilSmp = NULL;

  84.         NoteVoicePar[nvoice].FMSmp    = NULL;

  85.         NoteVoicePar[nvoice].VoiceOut = NULL;

  86. 

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

  88.         unison_size[nvoice] = 1;

  89. 

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

  91.             NoteVoicePar[nvoice].Enabled = OFF;

  92.             continue; //the voice is disabled

  93.         }

  94. 

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

  96.         if (BendAdj % 24 == 0)

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

  98.         else

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

  100. 

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

  102.         NoteVoicePar[nvoice].OffsetHz =

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

  104. 

  105.         unison_stereo_spread[nvoice] =

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

  107. 

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

  109.         if(unison < 1)

  110.             unison = 1;

  111. 

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

  113. 

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

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

  116.             if (unison > 2)

  117.                 unison = 2;

  118.         } else if (is_pwm) {

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

  120.             unison *= 2;

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

  122.             if (unison > 64)

  123.                 unison = 64;

  124.         }

  125. 

  126.         //compute unison

  127.         unison_size[nvoice] = unison;

  128. 

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

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

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

  132.         float unison_spread =

  133.             pars.getUnisonFrequencySpreadCents(nvoice);

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

  135.         float unison_vibratto_a  =

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

  137. 

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

  139.         switch(true_unison) {

  140.             case 1:

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

  142.                 break;

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

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

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

  146.             };

  147.                 break;

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

  149.                 float unison_values[true_unison];

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

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

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

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

  154.                     unison_values[k] = val;

  155.                     if (min > val) {

  156.                         min = val;

  157.                     }

  158.                     if (max < val) {

  159.                         max = val;

  160.                     }

  161.                 }

  162.                 float diff = max - min;

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

  164.                     unison_values[k] =

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

  166.                     unison_base_freq_rap[nvoice][k] =

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

  168.                 }

  169.             };

  170.         }

  171.         if (is_pwm)

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

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

  174.                     unison_base_freq_rap[nvoice][i];

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

  176.                     unison_base_freq_rap[nvoice][i];

  177.             }

  178. 

  179.         //unison vibrattos

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

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

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

  183.                                                   + (unison_base_freq_rap[

  184.                                                          nvoice][k] - 1.0f)

  185.                                                   * (1.0f - unison_vibratto_a);

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

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

  188.         unison_vibratto[nvoice].amplitude =

  189.             (unison_real_spread - 1.0f) * unison_vibratto_a;

  190. 

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

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

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

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

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

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

  197.             float vibratto_period = vibratto_base_period

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

  199. 

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

  201.             if(RND < 0.5f)

  202.                 m = -m;

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

  204. 

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

  206.             if (is_pwm)

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

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

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

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

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

  212.                 }

  213.         }

  214. 

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

  216.             if (is_pwm) {

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

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

  219.             }

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

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

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

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

  224.             }

  225.         }

  226. 

  227.         //phase invert for unison

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

  229.         if(unison != 1) {

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

  231.             switch(inv) {

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

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

  234.                     break;

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

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

  237.                     break;

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

  239.                         unison_invert_phase[nvoice][k] =

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

  241.                     break;

  242.             }

  243.         }

  244. 

  245. 

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

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

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

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

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

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

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

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

  254. 

  255.         NoteVoicePar[nvoice].Enabled     = ON;

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

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

  258. 

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

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

  261.             NoteVoicePar[nvoice].Detune = getdetune(

  262.                 pars.VoicePar[nvoice].PDetuneType,

  263.                 pars.VoicePar[nvoice].

  264.                 PCoarseDetune,

  265.                 8192); //coarse detune

  266.             NoteVoicePar[nvoice].FineDetune = getdetune(

  267.                 pars.VoicePar[nvoice].PDetuneType,

  268.                 0,

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

  270.         }

  271.         else {

  272.             NoteVoicePar[nvoice].Detune = getdetune(

  273.                 pars.GlobalPar.PDetuneType,

  274.                 pars.VoicePar[nvoice].

  275.                 PCoarseDetune,

  276.                 8192); //coarse detune

  277.             NoteVoicePar[nvoice].FineDetune = getdetune(

  278.                 pars.GlobalPar.PDetuneType,

  279.                 0,

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

  281.         }

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

  283.             NoteVoicePar[nvoice].FMDetune = getdetune(

  284.                 pars.VoicePar[nvoice].PFMDetuneType,

  285.                 pars.VoicePar[nvoice].

  286.                 PFMCoarseDetune,

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

  288.         else

  289.             NoteVoicePar[nvoice].FMDetune = getdetune(

  290.                 pars.GlobalPar.PDetuneType,

  291.                 pars.VoicePar[nvoice].

  292.                 PFMCoarseDetune,

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

  294. 

  295. 

  296. 

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

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

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

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

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

  302.         }

  303. 

  304.         //the extra points contains the first point

  305.         NoteVoicePar[nvoice].OscilSmp =

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

  307. 

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

  309.         int vc = nvoice;

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

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

  312.         if(!pars.GlobalPar.Hrandgrouping)

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

  314.         int oscposhi_start =

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

  316.                                              getvoicebasefreq(nvoice),

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

  318. 

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

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

  321.         // machines run this stuff too.

  322.         //

  323.         // //Find range of generated wave

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

  325.         // float max = min;

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

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

  328.         //     if (*smpls > max)

  329.         //         max = *smpls;

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

  331.         //         min = *smpls;

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

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

  334. 

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

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

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

  338.                                           + i] =

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

  340. 

  341.         NoteVoicePar[nvoice].phase_offset =

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

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

  344.                   + synth.oscilsize * 4);

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

  346. 

  347.         int kth_start = oscposhi_start;

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

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

  350.             //put random starting point for other subvoices

  351.             kth_start      = oscposhi_start +

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

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

  354.         }

  355. 

  356.         NoteVoicePar[nvoice].FreqLfo      = NULL;

  357.         NoteVoicePar[nvoice].FreqEnvelope = NULL;

  358. 

  359.         NoteVoicePar[nvoice].AmpLfo      = NULL;

  360.         NoteVoicePar[nvoice].AmpEnvelope = NULL;

  361. 

  362.         NoteVoicePar[nvoice].Filter         = NULL;

  363.         NoteVoicePar[nvoice].FilterEnvelope = NULL;

  364.         NoteVoicePar[nvoice].FilterLfo      = NULL;

  365. 

  366.         NoteVoicePar[nvoice].filterbypass =

  367.             pars.VoicePar[nvoice].Pfilterbypass;

  368. 

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

  370.             NoteVoicePar[nvoice].FMEnabled = NONE;

  371.         else

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

  373.                 case 1:

  374.                     NoteVoicePar[nvoice].FMEnabled = MORPH;

  375.                     break;

  376.                 case 2:

  377.                     NoteVoicePar[nvoice].FMEnabled = RING_MOD;

  378.                     break;

  379.                 case 3:

  380.                     NoteVoicePar[nvoice].FMEnabled = PHASE_MOD;

  381.                     break;

  382.                 case 4:

  383.                     NoteVoicePar[nvoice].FMEnabled = FREQ_MOD;

  384.                     break;

  385.                 case 5:

  386.                     NoteVoicePar[nvoice].FMEnabled = PW_MOD;

  387.                     break;

  388.                 default:

  389.                     NoteVoicePar[nvoice].FMEnabled = NONE;

  390.             }

  391. 

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

  393.         NoteVoicePar[nvoice].FMFreqEnvelope = NULL;

  394.         NoteVoicePar[nvoice].FMAmpEnvelope  = NULL;

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

  396. 

  397. 

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

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

  400.                                    nvoice),

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

  402.                                - 1.0f);

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

  404.             case PHASE_MOD:

  405.             case PW_MOD:

  406.                 fmvoldamp =

  407.                     powf(440.0f / getvoicebasefreq(

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

  409.                          / 64.0f);

  410.                 NoteVoicePar[nvoice].FMVolume =

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

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

  413.                 break;

  414.             case FREQ_MOD:

  415.                 NoteVoicePar[nvoice].FMVolume =

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

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

  418.                 break;

  419.             default:

  420.                 if(fmvoldamp > 1.0f)

  421.                     fmvoldamp = 1.0f;

  422.                 NoteVoicePar[nvoice].FMVolume =

  423.                     pars.VoicePar[nvoice].PFMVolume

  424.                     / 127.0f * fmvoldamp;

  425.         }

  426. 

  427.         //Voice's modulator velocity sensing

  428.         NoteVoicePar[nvoice].FMVolume *=

  429.             VelF(velocity,

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

  431. 

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

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

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

  435. 

  436.         firsttick[nvoice] = 1;

  437.         NoteVoicePar[nvoice].DelayTicks =

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

  439.                         * logf(50.0f))

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

  441.     }

  442. 

  443.     max_unison = 1;

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

  445.         if(unison_size[nvoice] > max_unison)

  446.             max_unison = unison_size[nvoice];

  447. 

  448. 

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

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

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

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

  453.     }

  454. 

  455.     initparameters(wm, prefix);

  456.     memory.endTransaction();

  457. }

  458. 

  459. SynthNote *ADnote::cloneLegato(void)

  460. {

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

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

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

  464. }

  465. 

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

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

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

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

  470. void ADnote::legatonote(LegatoParams lpars)

  471. {

  472.     //ADnoteParameters &pars = *partparams;

  473. 

  474.     // Manage legato stuff

  475.     if(legato.update(lpars))

  476.         return;

  477. 

  478.     portamento = lpars.portamento;

  479.     midinote   = lpars.midinote;

  480.     basefreq   = lpars.frequency;

  481. 

  482.     if(velocity > 1.0f)

  483.         velocity = 1.0f;

  484.     velocity = lpars.velocity;

  485. 

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

  487.                                      pars.GlobalPar.PCoarseDetune,

  488.                                      pars.GlobalPar.PDetune);

  489.     bandwidthDetuneMultiplier = pars.getBandwidthDetuneMultiplier();

  490. 

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

  492.         NoteGlobalPar.Panning = RND;

  493.     else

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

  495. 

  496.     NoteGlobalPar.Filter->updateSense(velocity, 

  497.                 pars.GlobalPar.PFilterVelocityScale,

  498.                 pars.GlobalPar.PFilterVelocityScaleFunction);

  499. 

  500. 

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

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

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

  504. 

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

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

  507. 

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

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

  510.             NoteVoicePar[nvoice].Detune = getdetune(

  511.                 pars.VoicePar[nvoice].PDetuneType,

  512.                 pars.VoicePar[nvoice].PCoarseDetune,

  513.                 8192); //coarse detune

  514.             NoteVoicePar[nvoice].FineDetune = getdetune(

  515.                 pars.VoicePar[nvoice].PDetuneType,

  516.                 0,

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

  518.         }

  519.         else {

  520.             NoteVoicePar[nvoice].Detune = getdetune(

  521.                 pars.GlobalPar.PDetuneType,

  522.                 pars.VoicePar[nvoice].PCoarseDetune,

  523.                 8192); //coarse detune

  524.             NoteVoicePar[nvoice].FineDetune = getdetune(

  525.                 pars.GlobalPar.PDetuneType,

  526.                 0,

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

  528.         }

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

  530.             NoteVoicePar[nvoice].FMDetune = getdetune(

  531.                 pars.VoicePar[nvoice].PFMDetuneType,

  532.                 pars.VoicePar[nvoice].PFMCoarseDetune,

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

  534.         else

  535.             NoteVoicePar[nvoice].FMDetune = getdetune(

  536.                 pars.GlobalPar.PDetuneType,

  537.                 pars.VoicePar[nvoice].PFMCoarseDetune,

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

  539. 

  540. 

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

  542.         int vc = nvoice;

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

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

  545.         if(!pars.GlobalPar.Hrandgrouping)

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

  547. 

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

  549.                                          getvoicebasefreq(nvoice),

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

  551. 

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

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

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

  555.                                           + i] =

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

  557. 

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

  559.         if(voiceFilter) {

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

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

  562.                         vce.PFilterVelocityScaleFunction);

  563.         }

  564. 

  565.         NoteVoicePar[nvoice].filterbypass =

  566.             pars.VoicePar[nvoice].Pfilterbypass;

  567. 

  568. 

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

  570. 

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

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

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

  574.                                - 1.0f);

  575. 

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

  577.             case PHASE_MOD:

  578.             case PW_MOD:

  579.                 fmvoldamp =

  580.                     powf(440.0f / getvoicebasefreq(

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

  582.                          / 64.0f);

  583.                 NoteVoicePar[nvoice].FMVolume =

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

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

  586.                 break;

  587.             case FREQ_MOD:

  588.                 NoteVoicePar[nvoice].FMVolume =

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

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

  591.                 break;

  592.             default:

  593.                 if(fmvoldamp > 1.0f)

  594.                     fmvoldamp = 1.0f;

  595.                 NoteVoicePar[nvoice].FMVolume =

  596.                     pars.VoicePar[nvoice].PFMVolume

  597.                     / 127.0f * fmvoldamp;

  598.         }

  599. 

  600.         //Voice's modulator velocity sensing

  601.         NoteVoicePar[nvoice].FMVolume *=

  602.             VelF(velocity,

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

  604. 

  605.         NoteVoicePar[nvoice].DelayTicks =

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

  607.                         * logf(50.0f))

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

  609.     }

  610. 

  611.     ///    initparameters();

  612. 

  613.     ///////////////

  614.     // Altered content of initparameters():

  615. 

  616.     int tmp[NUM_VOICES];

  617. 

  618.     NoteGlobalPar.Volume = 4.0f

  619.                            * powf(0.1f, 3.0f

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

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

  622.                            * VelF(

  623.         velocity,

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

  625. 

  626.     globalnewamplitude = NoteGlobalPar.Volume

  627.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  629. 

  630.     {

  631.         auto        *filter  = NoteGlobalPar.Filter;

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

  633.                             pars.GlobalPar.PFilterVelocityScaleFunction);

  634.         filter->updateNoteFreq(basefreq);

  635.     }

  636. 

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

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

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

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

  641. 

  642.     // Voice Parameter init

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

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

  645.             continue;

  646. 

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

  648.         /* Voice Amplitude Parameters Init */

  649.         NoteVoicePar[nvoice].Volume =

  650.             powf(0.1f, 3.0f

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

  652.             * VelF(velocity,

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

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

  655.             NoteVoicePar[nvoice].Volume = 0;

  656. 

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

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

  659. 

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

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

  662.         else

  663.             NoteVoicePar[nvoice].Panning =

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

  665. 

  666.         newamplitude[nvoice] = 1.0f;

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

  668.            && NoteVoicePar[nvoice].AmpEnvelope)

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

  670. 

  671. 

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

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

  674. 

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

  676.         if(voiceFilter) {

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

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

  679.             voiceFilter->updateNoteFreq(basefreq);

  680.         }

  681. 

  682.         /* Voice Modulation Parameters Init */

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

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

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

  686. 

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

  688. 

  689.             int vc = nvoice;

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

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

  692. 

  693.             if(!pars.GlobalPar.Hrandgrouping)

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

  695. 

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

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

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

  699.         }

  700. 

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

  702.                                  * ctl.fmamp.relamp;

  703. 

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

  705.            && NoteVoicePar[nvoice].FMAmpEnvelope)

  706.             FMnewamplitude[nvoice] *=

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

  708.     }

  709. 

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

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

  712.             tmp[i] = 0;

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

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

  715.                 tmp[i] = 1;

  716.     }

  717. }

  718. 

  719. 

  720. /*

  721.  * Kill a voice of ADnote

  722.  */

  723. void ADnote::KillVoice(int nvoice)

  724. {

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

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

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

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

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

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

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

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

  733. 

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

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

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

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

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

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

  740. 

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

  742. }

  743. 

  744. /*

  745.  * Kill the note

  746.  */

  747. void ADnote::KillNote()

  748. {

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

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

  751.             KillVoice(nvoice);

  752. 

  753.         if(NoteVoicePar[nvoice].VoiceOut)

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

  755.     }

  756. 

  757.     NoteGlobalPar.kill(memory);

  758. 

  759.     NoteEnabled = OFF;

  760. }

  761. 

  762. ADnote::~ADnote()

  763. {

  764.     if(NoteEnabled == ON)

  765.         KillNote();

  766.     memory.devalloc(tmpwavel);

  767.     memory.devalloc(tmpwaver);

  768.     memory.devalloc(bypassl);

  769.     memory.devalloc(bypassr);

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

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

  772.     memory.devalloc(tmpwave_unison);

  773. }

  774. 

  775. 

  776. /*

  777.  * Init the parameters

  778.  */

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

  780. {

  781.     int tmp[NUM_VOICES];

  782.     ScratchString pre = prefix;

  783.     //ADnoteParameters &pars = *partparams;

  784. 

  785.     // Global Parameters

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

  787.                                  time,

  788.                                  memory, basefreq, velocity,

  789.                                  stereo, wm, prefix);

  790. 

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

  792.     globalnewamplitude = NoteGlobalPar.Volume

  793.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  795. 

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

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

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

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

  800. 

  801.     // Voice Parameter init

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

  803.         Voice &vce = NoteVoicePar[nvoice];

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

  805. 

  806.         if(vce.Enabled == 0)

  807.             continue;

  808. 

  809.         vce.noisetype = param.Type;

  810.         /* Voice Amplitude Parameters Init */

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

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

  813.         if(param.PVolume == 0)

  814.             vce.Volume = 0;

  815. 

  816.         if(param.PVolumeminus)

  817.             vce.Volume = -vce.Volume;

  818. 

  819.         if(param.PPanning == 0)

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

  821.         else

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

  823. 

  824.         newamplitude[nvoice] = 1.0f;

  825.         if(param.PAmpEnvelopeEnabled) {

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

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

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

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

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

  831.         }

  832. 

  833.         if(param.PAmpLfoEnabled) {

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

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

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

  837.         }

  838. 

  839.         /* Voice Frequency Parameters Init */

  840.         if(param.PFreqEnvelopeEnabled)

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

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

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

  844. 

  845.         if(param.PFreqLfoEnabled)

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

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

  848. 

  849.         /* Voice Filter Parameters Init */

  850.         if(param.PFilterEnabled) {

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

  852.                       basefreq);

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

  854.                     param.PFilterVelocityScaleFunction);

  855. 

  856. 

  857.             if(param.PFilterEnvelopeEnabled) {

  858.                 vce.FilterEnvelope =

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

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

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

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

  863.             }

  864. 

  865.             if(param.PFilterLfoEnabled) {

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

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

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

  869.             }

  870.         }

  871. 

  872.         /* Voice Modulation Parameters Init */

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

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

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

  876. 

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

  878. 

  879.             int vc = nvoice;

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

  881.                 vc = param.PextFMoscil;

  882. 

  883.             float tmp = 1.0f;

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

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

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

  887.                 tmp = getFMvoicebasefreq(nvoice);

  888. 

  889.             if(!pars.GlobalPar.Hrandgrouping)

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

  891. 

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

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

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

  895.                                              vce.FMSmp, tmp))

  896.                                         % synth.oscilsize;

  897. 

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

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

  900.             int oscposhiFM_add =

  901.                 (int)((param.PFMoscilphase

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

  903.                       + synth.oscilsize * 4);

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

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

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

  907.             }

  908.         }

  909. 

  910.         if(param.PFMFreqEnvelopeEnabled)

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

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

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

  914. 

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

  916. 

  917.         if(param.PFMAmpEnvelopeEnabled ) {

  918.             vce.FMAmpEnvelope =

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

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

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

  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, FMfreq,

  1054.           FMrelativepitch, globalpitch;

  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.     NoteGlobalPar.Filter->update(ctl.filtercutoff.relfreq,

  1064.                                  ctl.filterq.relq);

  1065. 

  1066. 

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

  1068.     float portamentofreqrap = 1.0f;

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

  1070.         portamentofreqrap = ctl.portamento.freqrap;

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

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

  1073.     }

  1074. 

  1075.     //compute parameters for all voices

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

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

  1078.             continue;

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

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

  1081.             continue;

  1082. 

  1083.         compute_unison_freq_rap(nvoice);

  1084. 

  1085.         /*******************/

  1086.         /* Voice Amplitude */

  1087.         /*******************/

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

  1089.         newamplitude[nvoice] = 1.0f;

  1090. 

  1091.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

  1093. 

  1094.         if(NoteVoicePar[nvoice].AmpLfo)

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

  1096. 

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

  1098.         /* Voice Filter */

  1099.         /****************/

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

  1101.         if(voiceFilter) {

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

  1103.                                 ctl.filterq.relq);

  1104.         }

  1105. 

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

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

  1108.             /* Voice Frequency */

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

  1110.             voicepitch = 0.0f;

  1111.             if(NoteVoicePar[nvoice].FreqLfo)

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

  1113.                               * ctl.bandwidth.relbw;

  1114. 

  1115.             if(NoteVoicePar[nvoice].FreqEnvelope)

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

  1117.                               / 100.0f;

  1118.             voicefreq = getvoicebasefreq(nvoice)

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

  1120.             voicefreq *=

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

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

  1123. 

  1124.             /***************/

  1125.             /*  Modulator */

  1126.             /***************/

  1127. 

  1128. 

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

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

  1131.                 if(NoteVoicePar[nvoice].FMFreqEnvelope)

  1132.                     FMrelativepitch +=

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

  1134.                 if (NoteVoicePar[nvoice].FMFreqFixed)

  1135.                     FMfreq =

  1136.                         powf(2.0f, FMrelativepitch

  1137.                              / 12.0f) * 440.0f;

  1138.                 else

  1139.                     FMfreq =

  1140.                            powf(2.0f, FMrelativepitch

  1141.                                 / 12.0f) * voicefreq * portamentofreqrap;

  1142.                 setfreqFM(nvoice, FMfreq);

  1143. 

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

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

  1146.                                          * ctl.fmamp.relamp;

  1147.                 if(NoteVoicePar[nvoice].FMAmpEnvelope)

  1148.                     FMnewamplitude[nvoice] *=

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

  1150.             }

  1151.         }

  1152.     }

  1153. }

  1154. 

  1155. 

  1156. /*

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

  1158.  */

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

  1160. {

  1161.     int zerocrossings = 0;

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

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

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

  1165. 

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

  1167.     if(tmp < 8.0f)

  1168.         tmp = 8.0f;

  1169.     tmp *= NoteGlobalPar.Fadein_adjustment;

  1170. 

  1171.     int n;

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

  1173.     if(n > synth.buffersize)

  1174.         n = synth.buffersize;

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

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

  1177.         smps[i] *= tmp;

  1178.     }

  1179. }

  1180. 

  1181. /*

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

  1183.  */

  1184. 

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

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

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

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

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

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

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

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

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

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

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

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

  1197.  */

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

  1199. {

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

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

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

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

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

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

  1206.         float *tw     = tmpwave_unison[k];

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

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

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

  1210.             poslo += freqlo;

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

  1212.             poslo &= 0xffffff;

  1213.             poshi &= synth.oscilsize - 1;

  1214.         }

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

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

  1217.     }

  1218. }

  1219. 

  1220. 

  1221. 

  1222. /*

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

  1224.  *

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

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

  1227.     int i,poshi;

  1228.     float poslo;

  1229. 

  1230.     poshi=oscposhi[nvoice];

  1231.     poslo=oscposlo[nvoice];

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

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

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

  1235.     xm1=smps[poshi];

  1236.     x0=smps[poshi+1];

  1237.     x1=smps[poshi+2];

  1238.     x2=smps[poshi+3];

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

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

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

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

  1243.     printf("a\n");

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

  1245.     poslo+=oscfreqlo[nvoice];

  1246.     if (poslo>=1.0f) {

  1247.             poslo-=1.0f;

  1248.         poshi++;

  1249.     };

  1250.         poshi+=oscfreqhi[nvoice];

  1251.         poshi&=synth.oscilsize-1;

  1252.     };

  1253.     oscposhi[nvoice]=poshi;

  1254.     oscposlo[nvoice]=poslo;

  1255. };

  1256. */

  1257. /*

  1258.  * Computes the Oscillator (Morphing)

  1259.  */

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

  1261. {

  1262.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1264.         FMnewamplitude[nvoice] = 1.0f;

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

  1266.         FMoldamplitude[nvoice] = 1.0f;

  1267. 

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

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

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

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

  1272.             float *tw = tmpwave_unison[k];

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

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

  1275.                                             FMnewamplitude[nvoice],

  1276.                                             i,

  1277.                                             synth.buffersize);

  1278.                 tw[i] = tw[i]

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

  1280.             }

  1281.         }

  1282.     }

  1283.     else

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

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

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

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

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

  1289.             float *tw = tmpwave_unison[k];

  1290. 

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

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

  1293.                                             FMnewamplitude[nvoice],

  1294.                                             i,

  1295.                                             synth.buffersize);

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

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

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

  1299.                 posloFM += freqloFM;

  1300.                 if(posloFM >= 1.0f) {

  1301.                     posloFM -= 1.0f;

  1302.                     poshiFM++;

  1303.                 }

  1304.                 poshiFM += freqhiFM;

  1305.                 poshiFM &= synth.oscilsize - 1;

  1306.             }

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

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

  1309.         }

  1310. }

  1311. 

  1312. /*

  1313.  * Computes the Oscillator (Ring Modulation)

  1314.  */

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

  1316. {

  1317.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1319.         FMnewamplitude[nvoice] = 1.0f;

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

  1321.         FMoldamplitude[nvoice] = 1.0f;

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

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

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

  1325.             float *tw = tmpwave_unison[k];

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

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

  1328.                                             FMnewamplitude[nvoice],

  1329.                                             i,

  1330.                                             synth.buffersize);

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

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

  1333.             }

  1334.         }

  1335.     else

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

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

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

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

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

  1341.             float *tw = tmpwave_unison[k];

  1342. 

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

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

  1345.                                             FMnewamplitude[nvoice],

  1346.                                             i,

  1347.                                             synth.buffersize);

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

  1349.                           + NoteVoicePar[nvoice].FMSmp[poshiFM

  1350.                                                        + 1] * posloFM) * amp

  1351.                          + (1.0f - amp);

  1352.                 posloFM += freqloFM;

  1353.                 if(posloFM >= 1.0f) {

  1354.                     posloFM -= 1.0f;

  1355.                     poshiFM++;

  1356.                 }

  1357.                 poshiFM += freqhiFM;

  1358.                 poshiFM &= synth.oscilsize - 1;

  1359.             }

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

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

  1362.         }

  1363. }

  1364. 

  1365. /*

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

  1367.  */

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

  1369.                                                               int FMmode)

  1370. {

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

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

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

  1374.             float *tw = tmpwave_unison[k];

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

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

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

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

  1379.             else

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

  1381.         }

  1382.     } else {

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

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

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

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

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

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

  1389.             float *tw = tmpwave_unison[k];

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

  1391. 

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

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

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

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

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

  1397. 

  1398.                 posloFM += freqloFM;

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

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

  1401.                     poshiFM++;

  1402.                 }

  1403.                 poshiFM += freqhiFM;

  1404.                 poshiFM &= synth.oscilsize - 1;

  1405.             }

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

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

  1408.         }

  1409.     }

  1410.     // Amplitude interpolation

  1411.     if(ABOVE_AMPLITUDE_THRESHOLD(FMoldamplitude[nvoice],

  1412.                                  FMnewamplitude[nvoice])) {

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

  1414.             float *tw = tmpwave_unison[k];

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

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

  1417.                                                FMnewamplitude[nvoice],

  1418.                                                i,

  1419.                                                synth.buffersize);

  1420.         }

  1421.     } else {

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

  1423.             float *tw = tmpwave_unison[k];

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

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

  1426.         }

  1427.     }

  1428. 

  1429. 

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

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

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

  1433.                           / synth.samplerate_f;

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

  1435.             float *tw    = tmpwave_unison[k];

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

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

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

  1439.                 tw[i] = fmold;

  1440.             }

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

  1442.         }

  1443.     }

  1444.     else {  //Phase or PWM modulation

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

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

  1447.             float *tw = tmpwave_unison[k];

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

  1449.                 tw[i] *= normalize;

  1450.         }

  1451.     }

  1452. 

  1453.     //do the modulation

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

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

  1456.         float *tw     = tmpwave_unison[k];

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

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

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

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

  1461. 

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

  1463.             int FMmodfreqhi = 0;

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

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

  1466.             if(FMmodfreqhi < 0)

  1467.                 FMmodfreqlo++;

  1468. 

  1469.             //carrier

  1470.             int carposhi = poshi + FMmodfreqhi;

  1471.             int carposlo = poslo + FMmodfreqlo;

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

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

  1474. 

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

  1476.                 carposhi++;

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

  1478.             }

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

  1480. 

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

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

  1483. 

  1484.             poslo += freqlo;

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

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

  1487.                 poshi++;

  1488.             }

  1489. 

  1490.             poshi += freqhi;

  1491.             poshi &= synth.oscilsize - 1;

  1492.         }

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

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

  1495.     }

  1496. }

  1497. 

  1498. 

  1499. /*

  1500.  * Computes the Noise

  1501.  */

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

  1503. {

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

  1505.         float *tw = tmpwave_unison[k];

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

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

  1508.     }

  1509. }

  1510. 

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

  1512. {

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

  1514.         float *tw = tmpwave_unison[k];

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

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

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

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

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

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

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

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

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

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

  1525. 	    f[6] = white*0.115926;

  1526.         }

  1527.     }

  1528. }

  1529. 

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

  1531. {

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

  1533.         float *tw = tmpwave_unison[k];

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

  1535.             tw[i] = 1.0f;

  1536.     }

  1537. }

  1538. 

  1539. 

  1540. 

  1541. /*

  1542.  * Compute the ADnote samples

  1543.  * Returns 0 if the note is finished

  1544.  */

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

  1546. {

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

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

  1549. 

  1550.     if(NoteEnabled == OFF)

  1551.         return 0;

  1552. 

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

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

  1555.     computecurrentparameters();

  1556. 

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

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

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

  1560.             continue;

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

  1562.             case 0: //voice mode=sound

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

  1564.                     case MORPH:

  1565.                         ComputeVoiceOscillatorMorph(nvoice);

  1566.                         break;

  1567.                     case RING_MOD:

  1568.                         ComputeVoiceOscillatorRingModulation(nvoice);

  1569.                         break;

  1570.                     case FREQ_MOD:

  1571.                     case PHASE_MOD:

  1572.                     case PW_MOD:

  1573.                         ComputeVoiceOscillatorFrequencyModulation(nvoice,

  1574.                                                                   NoteVoicePar[nvoice].FMEnabled);

  1575.                         break;

  1576.                     default:

  1577.                         ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1579.                 }

  1580.                 break;

  1581.             case 1:

  1582.                 ComputeVoiceWhiteNoise(nvoice);

  1583.                 break;

  1584.             case 2:

  1585.                 ComputeVoicePinkNoise(nvoice);

  1586.                 break;

  1587.             default:

  1588.                 ComputeVoiceDC(nvoice);

  1589.                 break;

  1590.         }

  1591.         // Voice Processing

  1592. 

  1593. 

  1594.         //mix subvoices into voice

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

  1596.         if(stereo)

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

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

  1599.             float *tw = tmpwave_unison[k];

  1600.             if(stereo) {

  1601.                 float stereo_pos = 0;

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

  1603.                 if (is_pwm) {

  1604.                     if(unison_size[nvoice] > 2)

  1605.                         stereo_pos = k/2

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

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

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

  1609.                     stereo_pos = k

  1610.                         / (float)(unison_size[nvoice]

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

  1612.                 }

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

  1614.                 if(stereo_spread > 1.0f) {

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

  1616.                     stereo_pos =

  1617.                         (2.0f

  1618.                          - stereo_spread) * stereo_pos

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

  1620.                 }

  1621.                 else

  1622.                     stereo_pos *= stereo_spread;

  1623. 

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

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

  1626.                     stereo_pos = 0.0f;

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

  1628. 

  1629. 

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

  1631.                 if(lvol > 1.0f)

  1632.                     lvol = 1.0f;

  1633. 

  1634.                 float rvol = panning * 2.0f;

  1635.                 if(rvol > 1.0f)

  1636.                     rvol = 1.0f;

  1637. 

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

  1639.                     lvol = -lvol;

  1640.                     rvol = -rvol;

  1641.                 }

  1642. 

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

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

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

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

  1647.             }

  1648.             else

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

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

  1651.         }

  1652. 

  1653. 

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

  1655.         // Amplitude

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

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

  1658. 

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

  1660.             int rest = synth.buffersize;

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

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

  1663.                 rest = 10;

  1664.                 if(rest > synth.buffersize)

  1665.                     rest = synth.buffersize;

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

  1667.                     tmpwavel[i] *= oldam;

  1668.                 if(stereo)

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

  1670.                         tmpwaver[i] *= oldam;

  1671.             }

  1672.             // Amplitude interpolation

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

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

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

  1676.                 if(stereo)

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

  1678.             }

  1679.         }

  1680.         else {

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

  1682.                 tmpwavel[i] *= newam;

  1683.             if(stereo)

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

  1685.                     tmpwaver[i] *= newam;

  1686.         }

  1687. 

  1688.         // Fade in

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

  1690.             fadein(&tmpwavel[0]);

  1691.             if(stereo)

  1692.                 fadein(&tmpwaver[0]);

  1693.             firsttick[nvoice] = 0;

  1694.         }

  1695. 

  1696.         // Filter

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

  1698.             if(stereo)

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

  1700.             else

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

  1702.         }

  1703. 

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

  1705.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

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

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

  1709.                 if(stereo)

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

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

  1712.             }

  1713.         //the voice is killed later

  1714. 

  1715. 

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

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

  1718.             if(stereo)

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

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

  1721.                                                        + tmpwaver[i];

  1722.             else   //mono

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

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

  1725.         }

  1726. 

  1727. 

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

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

  1730.             if(stereo)

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

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

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

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

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

  1736.                 }

  1737.             else

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

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

  1740.         }

  1741.         else {  //bypass the filter

  1742.             if(stereo)

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

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

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

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

  1747.                                   * (1.0f

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

  1749.                 }

  1750.             else

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

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

  1753.         }

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

  1755.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

  1757.                 KillVoice(nvoice);

  1758.     }

  1759. 

  1760. 

  1761.     //Processing Global parameters

  1762.     if(stereo) {

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

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

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

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

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

  1768.     }

  1769. 

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

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

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

  1773.     }

  1774. 

  1775.     if(ABOVE_AMPLITUDE_THRESHOLD(globaloldamplitude, globalnewamplitude))

  1776.         // Amplitude Interpolation

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

  1778.             float tmpvol = INTERPOLATE_AMPLITUDE(globaloldamplitude,

  1779.                                                  globalnewamplitude,

  1780.                                                  i,

  1781.                                                  synth.buffersize);

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

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

  1784.         }

  1785.     else

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

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

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

  1789.         }

  1790. 

  1791.     //Apply the punch

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

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

  1794.             float punchamp = NoteGlobalPar.Punch.initialvalue

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

  1796.             outl[i] *= punchamp;

  1797.             outr[i] *= punchamp;

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

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

  1800.                 NoteGlobalPar.Punch.Enabled = 0;

  1801.                 break;

  1802.             }

  1803.         }

  1804. 

  1805. 

  1806.     // Apply legato-specific sound signal modifications

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

  1808. 

  1809. 

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

  1811.     // If it does, disable the note

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

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

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

  1815.             outl[i] *= tmp;

  1816.             outr[i] *= tmp;

  1817.         }

  1818.         KillNote();

  1819.     }

  1820.     return 1;

  1821. }

  1822. 

  1823. 

  1824. /*

  1825.  * Release the key (NoteOff)

  1826.  */

  1827. void ADnote::releasekey()

  1828. {

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

  1830.         NoteVoicePar[nvoice].releasekey();

  1831.     NoteGlobalPar.FreqEnvelope->releasekey();

  1832.     NoteGlobalPar.FilterEnvelope->releasekey();

  1833.     NoteGlobalPar.AmpEnvelope->releasekey();

  1834. }

  1835. 

  1836. /*

  1837.  * Check if the note is finished

  1838.  */

  1839. bool ADnote::finished() const

  1840. {

  1841.     if(NoteEnabled == ON)

  1842.         return 0;

  1843.     else

  1844.         return 1;

  1845. }

  1846. 

  1847. void ADnote::entomb(void)

  1848. {

  1849.     NoteGlobalPar.AmpEnvelope->forceFinish();

  1850. }

  1851. 

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

  1853. {

  1854.     if(!Enabled)

  1855.         return;

  1856.     if(AmpEnvelope)

  1857.         AmpEnvelope->releasekey();

  1858.     if(FreqEnvelope)

  1859.         FreqEnvelope->releasekey();

  1860.     if(FilterEnvelope)

  1861.         FilterEnvelope->releasekey();

  1862.     if(FMFreqEnvelope)

  1863.         FMFreqEnvelope->releasekey();

  1864.     if(FMAmpEnvelope)

  1865.         FMAmpEnvelope->releasekey();

  1866. }

  1867. 

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

  1869. {

  1870.     memory.devalloc(OscilSmp);

  1871.     memory.dealloc(FreqEnvelope);

  1872.     memory.dealloc(FreqLfo);

  1873.     memory.dealloc(AmpEnvelope);

  1874.     memory.dealloc(AmpLfo);

  1875.     memory.dealloc(Filter);

  1876.     memory.dealloc(FilterEnvelope);

  1877.     memory.dealloc(FilterLfo);

  1878.     memory.dealloc(FMFreqEnvelope);

  1879.     memory.dealloc(FMAmpEnvelope);

  1880. 

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

  1882.         memory.devalloc(FMSmp);

  1883. 

  1884.     if(VoiceOut)

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

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

  1887.     //an input to another voice

  1888. 

  1889.     Enabled = OFF;

  1890. }

  1891. 

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

  1893. {

  1894.     memory.dealloc(FreqEnvelope);

  1895.     memory.dealloc(FreqLfo);

  1896.     memory.dealloc(AmpEnvelope);

  1897.     memory.dealloc(AmpLfo);

  1898.     memory.dealloc(Filter);

  1899.     memory.dealloc(FilterEnvelope);

  1900.     memory.dealloc(FilterLfo);

  1901. }

  1902. 

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

  1904.                                     const SYNTH_T &synth,

  1905.                                     const AbsTime &time,

  1906.                                     class Allocator &memory,

  1907.                                     float basefreq, float velocity,

  1908.                                     bool stereo,

  1909.                                     WatchManager *wm,

  1910.                                     const char *prefix)

  1911. {

  1912.     ScratchString pre = prefix;

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

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

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

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

  1917. 

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

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

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

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

  1922. 

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

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

  1925. 

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

  1927.             stereo, basefreq);

  1928. 

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

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

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

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

  1933. 

  1934.     Filter->addMod(*FilterEnvelope);

  1935.     Filter->addMod(*FilterLfo);

  1936.     

  1937.     {

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

  1939.                 param.PFilterVelocityScaleFunction);

  1940.     }

  1941. }