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.
3368 Commits
16 Branches
224MB
Tree: 38bcc13e2c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '38bcc13e2c'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/Synth/ADnote.cpp

1901 lines
70KB
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 "ModFilter.h"

  26. #include "OscilGen.h"

  27. #include "ADnote.h"

  28. 

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

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

  31. {

  32.     memory.beginTransaction();

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

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

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

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

  37. 

  38.     ADnoteParameters &pars = *pars_;

  39.     portamento  = spars.portamento;

  40.     midinote    = spars.note;

  41.     NoteEnabled = ON;

  42.     basefreq    = spars.frequency;

  43.     velocity    = spars.velocity;

  44.     stereo = pars.GlobalPar.PStereo;

  45. 

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

  47.                                      pars.GlobalPar.PCoarseDetune,

  48.                                      pars.GlobalPar.PDetune);

  49.     bandwidthDetuneMultiplier = pars.getBandwidthDetuneMultiplier();

  50. 

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

  52.         NoteGlobalPar.Panning = RND;

  53.     else

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

  55. 

  56. 

  57.     NoteGlobalPar.Fadein_adjustment =

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

  59.     NoteGlobalPar.Fadein_adjustment *= NoteGlobalPar.Fadein_adjustment;

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

  61.         NoteGlobalPar.Punch.Enabled = 1;

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

  63.         NoteGlobalPar.Punch.initialvalue =

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

  65.              * VelF(velocity,

  66.                     pars.GlobalPar.PPunchVelocitySensing));

  67.         float time =

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

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

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

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

  72.     }

  73.     else

  74.         NoteGlobalPar.Punch.Enabled = 0;

  75. 

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

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

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

  79. 

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

  81.         NoteVoicePar[nvoice].OscilSmp = NULL;

  82.         NoteVoicePar[nvoice].FMSmp    = NULL;

  83.         NoteVoicePar[nvoice].VoiceOut = NULL;

  84. 

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

  86.         unison_size[nvoice] = 1;

  87. 

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

  89.             NoteVoicePar[nvoice].Enabled = OFF;

  90.             continue; //the voice is disabled

  91.         }

  92. 

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

  94.         if (BendAdj % 24 == 0)

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

  96.         else

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

  98. 

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

  100.         NoteVoicePar[nvoice].OffsetHz =

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

  102. 

  103.         unison_stereo_spread[nvoice] =

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

  105. 

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

  107.         if(unison < 1)

  108.             unison = 1;

  109. 

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

  111. 

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

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

  114.             if (unison > 2)

  115.                 unison = 2;

  116.         } else if (is_pwm) {

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

  118.             unison *= 2;

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

  120.             if (unison > 64)

  121.                 unison = 64;

  122.         }

  123. 

  124.         //compute unison

  125.         unison_size[nvoice] = unison;

  126. 

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

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

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

  130.         float unison_spread =

  131.             pars.getUnisonFrequencySpreadCents(nvoice);

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

  133.         float unison_vibratto_a  =

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

  135. 

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

  137.         switch(true_unison) {

  138.             case 1:

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

  140.                 break;

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

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

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

  144.             };

  145.                 break;

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

  147.                 float unison_values[true_unison];

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

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

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

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

  152.                     unison_values[k] = val;

  153.                     if (min > val) {

  154.                         min = val;

  155.                     }

  156.                     if (max < val) {

  157.                         max = val;

  158.                     }

  159.                 }

  160.                 float diff = max - min;

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

  162.                     unison_values[k] =

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

  164.                     unison_base_freq_rap[nvoice][k] =

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

  166.                 }

  167.             };

  168.         }

  169.         if (is_pwm)

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

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

  172.                     unison_base_freq_rap[nvoice][i];

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

  174.                     unison_base_freq_rap[nvoice][i];

  175.             }

  176. 

  177.         //unison vibrattos

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

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

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

  181.                                                   + (unison_base_freq_rap[

  182.                                                          nvoice][k] - 1.0f)

  183.                                                   * (1.0f - unison_vibratto_a);

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

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

  186.         unison_vibratto[nvoice].amplitude =

  187.             (unison_real_spread - 1.0f) * unison_vibratto_a;

  188. 

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

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

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

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

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

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

  195.             float vibratto_period = vibratto_base_period

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

  197. 

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

  199.             if(RND < 0.5f)

  200.                 m = -m;

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

  202. 

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

  204.             if (is_pwm)

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

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

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

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

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

  210.                 }

  211.         }

  212. 

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

  214.             if (is_pwm) {

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

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

  217.             }

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

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

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

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

  222.             }

  223.         }

  224. 

  225.         //phase invert for unison

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

  227.         if(unison != 1) {

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

  229.             switch(inv) {

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

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

  232.                     break;

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

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

  235.                     break;

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

  237.                         unison_invert_phase[nvoice][k] =

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

  239.                     break;

  240.             }

  241.         }

  242. 

  243. 

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

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

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

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

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

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

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

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

  252. 

  253.         NoteVoicePar[nvoice].Enabled     = ON;

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

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

  256. 

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

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

  259.             NoteVoicePar[nvoice].Detune = getdetune(

  260.                 pars.VoicePar[nvoice].PDetuneType,

  261.                 pars.VoicePar[nvoice].

  262.                 PCoarseDetune,

  263.                 8192); //coarse detune

  264.             NoteVoicePar[nvoice].FineDetune = getdetune(

  265.                 pars.VoicePar[nvoice].PDetuneType,

  266.                 0,

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

  268.         }

  269.         else {

  270.             NoteVoicePar[nvoice].Detune = getdetune(

  271.                 pars.GlobalPar.PDetuneType,

  272.                 pars.VoicePar[nvoice].

  273.                 PCoarseDetune,

  274.                 8192); //coarse detune

  275.             NoteVoicePar[nvoice].FineDetune = getdetune(

  276.                 pars.GlobalPar.PDetuneType,

  277.                 0,

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

  279.         }

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

  281.             NoteVoicePar[nvoice].FMDetune = getdetune(

  282.                 pars.VoicePar[nvoice].PFMDetuneType,

  283.                 pars.VoicePar[nvoice].

  284.                 PFMCoarseDetune,

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

  286.         else

  287.             NoteVoicePar[nvoice].FMDetune = getdetune(

  288.                 pars.GlobalPar.PDetuneType,

  289.                 pars.VoicePar[nvoice].

  290.                 PFMCoarseDetune,

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

  292. 

  293. 

  294. 

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

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

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

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

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

  300.         }

  301. 

  302.         //the extra points contains the first point

  303.         NoteVoicePar[nvoice].OscilSmp =

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

  305. 

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

  307.         int vc = nvoice;

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

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

  310.         if(!pars.GlobalPar.Hrandgrouping)

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

  312.         int oscposhi_start =

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

  314.                                              getvoicebasefreq(nvoice),

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

  316. 

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

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

  319.         // machines run this stuff too.

  320.         //

  321.         // //Find range of generated wave

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

  323.         // float max = min;

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

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

  326.         //     if (*smpls > max)

  327.         //         max = *smpls;

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

  329.         //         min = *smpls;

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

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

  332. 

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

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

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

  336.                                           + i] =

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

  338. 

  339.         NoteVoicePar[nvoice].phase_offset =

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

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

  342.                   + synth.oscilsize * 4);

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

  344. 

  345.         int kth_start = oscposhi_start;

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

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

  348.             //put random starting point for other subvoices

  349.             kth_start      = oscposhi_start +

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

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

  352.         }

  353. 

  354.         NoteVoicePar[nvoice].FreqLfo      = NULL;

  355.         NoteVoicePar[nvoice].FreqEnvelope = NULL;

  356. 

  357.         NoteVoicePar[nvoice].AmpLfo      = NULL;

  358.         NoteVoicePar[nvoice].AmpEnvelope = NULL;

  359. 

  360.         NoteVoicePar[nvoice].Filter         = NULL;

  361.         NoteVoicePar[nvoice].FilterEnvelope = NULL;

  362.         NoteVoicePar[nvoice].FilterLfo      = NULL;

  363. 

  364.         NoteVoicePar[nvoice].filterbypass =

  365.             pars.VoicePar[nvoice].Pfilterbypass;

  366. 

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

  368.             NoteVoicePar[nvoice].FMEnabled = NONE;

  369.         else

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

  371.                 case 1:

  372.                     NoteVoicePar[nvoice].FMEnabled = MORPH;

  373.                     break;

  374.                 case 2:

  375.                     NoteVoicePar[nvoice].FMEnabled = RING_MOD;

  376.                     break;

  377.                 case 3:

  378.                     NoteVoicePar[nvoice].FMEnabled = PHASE_MOD;

  379.                     break;

  380.                 case 4:

  381.                     NoteVoicePar[nvoice].FMEnabled = FREQ_MOD;

  382.                     break;

  383.                 case 5:

  384.                     NoteVoicePar[nvoice].FMEnabled = PW_MOD;

  385.                     break;

  386.                 default:

  387.                     NoteVoicePar[nvoice].FMEnabled = NONE;

  388.             }

  389. 

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

  391.         NoteVoicePar[nvoice].FMFreqEnvelope = NULL;

  392.         NoteVoicePar[nvoice].FMAmpEnvelope  = NULL;

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

  394. 

  395. 

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

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

  398.                                    nvoice),

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

  400.                                - 1.0f);

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

  402.             case PHASE_MOD:

  403.             case PW_MOD:

  404.                 fmvoldamp =

  405.                     powf(440.0f / getvoicebasefreq(

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

  407.                          / 64.0f);

  408.                 NoteVoicePar[nvoice].FMVolume =

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

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

  411.                 break;

  412.             case FREQ_MOD:

  413.                 NoteVoicePar[nvoice].FMVolume =

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

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

  416.                 break;

  417.             default:

  418.                 if(fmvoldamp > 1.0f)

  419.                     fmvoldamp = 1.0f;

  420.                 NoteVoicePar[nvoice].FMVolume =

  421.                     pars.VoicePar[nvoice].PFMVolume

  422.                     / 127.0f * fmvoldamp;

  423.         }

  424. 

  425.         //Voice's modulator velocity sensing

  426.         NoteVoicePar[nvoice].FMVolume *=

  427.             VelF(velocity,

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

  429. 

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

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

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

  433. 

  434.         firsttick[nvoice] = 1;

  435.         NoteVoicePar[nvoice].DelayTicks =

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

  437.                         * logf(50.0f))

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

  439.     }

  440. 

  441.     max_unison = 1;

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

  443.         if(unison_size[nvoice] > max_unison)

  444.             max_unison = unison_size[nvoice];

  445. 

  446. 

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

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

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

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

  451.     }

  452. 

  453.     initparameters();

  454.     memory.endTransaction();

  455. }

  456. 

  457. SynthNote *ADnote::cloneLegato(void)

  458. {

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

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

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

  462. }

  463. 

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

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

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

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

  468. void ADnote::legatonote(LegatoParams lpars)

  469. {

  470.     //ADnoteParameters &pars = *partparams;

  471. 

  472.     // Manage legato stuff

  473.     if(legato.update(lpars))

  474.         return;

  475. 

  476.     portamento = lpars.portamento;

  477.     midinote   = lpars.midinote;

  478.     basefreq   = lpars.frequency;

  479. 

  480.     if(velocity > 1.0f)

  481.         velocity = 1.0f;

  482.     velocity = lpars.velocity;

  483. 

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

  485.                                      pars.GlobalPar.PCoarseDetune,

  486.                                      pars.GlobalPar.PDetune);

  487.     bandwidthDetuneMultiplier = pars.getBandwidthDetuneMultiplier();

  488. 

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

  490.         NoteGlobalPar.Panning = RND;

  491.     else

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

  493. 

  494.     NoteGlobalPar.Filter->updateSense(velocity, 

  495.                 pars.GlobalPar.PFilterVelocityScale,

  496.                 pars.GlobalPar.PFilterVelocityScaleFunction);

  497. 

  498. 

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

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

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

  502. 

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

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

  505. 

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

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

  508.             NoteVoicePar[nvoice].Detune = getdetune(

  509.                 pars.VoicePar[nvoice].PDetuneType,

  510.                 pars.VoicePar[nvoice].PCoarseDetune,

  511.                 8192); //coarse detune

  512.             NoteVoicePar[nvoice].FineDetune = getdetune(

  513.                 pars.VoicePar[nvoice].PDetuneType,

  514.                 0,

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

  516.         }

  517.         else {

  518.             NoteVoicePar[nvoice].Detune = getdetune(

  519.                 pars.GlobalPar.PDetuneType,

  520.                 pars.VoicePar[nvoice].PCoarseDetune,

  521.                 8192); //coarse detune

  522.             NoteVoicePar[nvoice].FineDetune = getdetune(

  523.                 pars.GlobalPar.PDetuneType,

  524.                 0,

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

  526.         }

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

  528.             NoteVoicePar[nvoice].FMDetune = getdetune(

  529.                 pars.VoicePar[nvoice].PFMDetuneType,

  530.                 pars.VoicePar[nvoice].PFMCoarseDetune,

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

  532.         else

  533.             NoteVoicePar[nvoice].FMDetune = getdetune(

  534.                 pars.GlobalPar.PDetuneType,

  535.                 pars.VoicePar[nvoice].PFMCoarseDetune,

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

  537. 

  538. 

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

  540.         int vc = nvoice;

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

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

  543.         if(!pars.GlobalPar.Hrandgrouping)

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

  545. 

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

  547.                                          getvoicebasefreq(nvoice),

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

  549. 

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

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

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

  553.                                           + i] =

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

  555. 

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

  557.         if(voiceFilter) {

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

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

  560.                         vce.PFilterVelocityScaleFunction);

  561.         }

  562. 

  563.         NoteVoicePar[nvoice].filterbypass =

  564.             pars.VoicePar[nvoice].Pfilterbypass;

  565. 

  566. 

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

  568. 

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

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

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

  572.                                - 1.0f);

  573. 

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

  575.             case PHASE_MOD:

  576.             case PW_MOD:

  577.                 fmvoldamp =

  578.                     powf(440.0f / getvoicebasefreq(

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

  580.                          / 64.0f);

  581.                 NoteVoicePar[nvoice].FMVolume =

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

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

  584.                 break;

  585.             case FREQ_MOD:

  586.                 NoteVoicePar[nvoice].FMVolume =

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

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

  589.                 break;

  590.             default:

  591.                 if(fmvoldamp > 1.0f)

  592.                     fmvoldamp = 1.0f;

  593.                 NoteVoicePar[nvoice].FMVolume =

  594.                     pars.VoicePar[nvoice].PFMVolume

  595.                     / 127.0f * fmvoldamp;

  596.         }

  597. 

  598.         //Voice's modulator velocity sensing

  599.         NoteVoicePar[nvoice].FMVolume *=

  600.             VelF(velocity,

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

  602. 

  603.         NoteVoicePar[nvoice].DelayTicks =

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

  605.                         * logf(50.0f))

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

  607.     }

  608. 

  609.     ///    initparameters();

  610. 

  611.     ///////////////

  612.     // Altered content of initparameters():

  613. 

  614.     int tmp[NUM_VOICES];

  615. 

  616.     NoteGlobalPar.Volume = 4.0f

  617.                            * powf(0.1f, 3.0f

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

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

  620.                            * VelF(

  621.         velocity,

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

  623. 

  624.     globalnewamplitude = NoteGlobalPar.Volume

  625.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  627. 

  628.     {

  629.         auto        *filter  = NoteGlobalPar.Filter;

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

  631.                             pars.GlobalPar.PFilterVelocityScaleFunction);

  632.         filter->updateNoteFreq(basefreq);

  633.     }

  634. 

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

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

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

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

  639. 

  640.     // Voice Parameter init

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

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

  643.             continue;

  644. 

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

  646.         /* Voice Amplitude Parameters Init */

  647.         NoteVoicePar[nvoice].Volume =

  648.             powf(0.1f, 3.0f

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

  650.             * VelF(velocity,

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

  652. 

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

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

  655. 

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

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

  658.         else

  659.             NoteVoicePar[nvoice].Panning =

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

  661. 

  662.         newamplitude[nvoice] = 1.0f;

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

  664.            && NoteVoicePar[nvoice].AmpEnvelope)

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

  666. 

  667. 

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

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

  670. 

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

  672.         if(voiceFilter) {

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

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

  675.             voiceFilter->updateNoteFreq(basefreq);

  676.         }

  677. 

  678.         /* Voice Modulation Parameters Init */

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

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

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

  682. 

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

  684. 

  685.             int vc = nvoice;

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

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

  688. 

  689.             if(!pars.GlobalPar.Hrandgrouping)

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

  691. 

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

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

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

  695.         }

  696. 

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

  698.                                  * ctl.fmamp.relamp;

  699. 

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

  701.            && NoteVoicePar[nvoice].FMAmpEnvelope)

  702.             FMnewamplitude[nvoice] *=

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

  704.     }

  705. 

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

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

  708.             tmp[i] = 0;

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

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

  711.                 tmp[i] = 1;

  712.     }

  713. }

  714. 

  715. 

  716. /*

  717.  * Kill a voice of ADnote

  718.  */

  719. void ADnote::KillVoice(int nvoice)

  720. {

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

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

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

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

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

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

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

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

  729. 

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

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

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

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

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

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

  736. 

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

  738. }

  739. 

  740. /*

  741.  * Kill the note

  742.  */

  743. void ADnote::KillNote()

  744. {

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

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

  747.             KillVoice(nvoice);

  748. 

  749.         if(NoteVoicePar[nvoice].VoiceOut)

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

  751.     }

  752. 

  753.     NoteGlobalPar.kill(memory);

  754. 

  755.     NoteEnabled = OFF;

  756. }

  757. 

  758. ADnote::~ADnote()

  759. {

  760.     if(NoteEnabled == ON)

  761.         KillNote();

  762.     memory.devalloc(tmpwavel);

  763.     memory.devalloc(tmpwaver);

  764.     memory.devalloc(bypassl);

  765.     memory.devalloc(bypassr);

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

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

  768.     memory.devalloc(tmpwave_unison);

  769. }

  770. 

  771. 

  772. /*

  773.  * Init the parameters

  774.  */

  775. void ADnote::initparameters()

  776. {

  777.     int tmp[NUM_VOICES];

  778.     //ADnoteParameters &pars = *partparams;

  779. 

  780.     // Global Parameters

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

  782.                                  time,

  783.                                  memory, basefreq, velocity,

  784.                                  stereo);

  785. 

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

  787.     globalnewamplitude = NoteGlobalPar.Volume

  788.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  790. 

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

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

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

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

  795. 

  796.     // Voice Parameter init

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

  798.         Voice &vce = NoteVoicePar[nvoice];

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

  800. 

  801.         if(vce.Enabled == 0)

  802.             continue;

  803. 

  804.         vce.noisetype = param.Type;

  805.         /* Voice Amplitude Parameters Init */

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

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

  808. 

  809.         if(param.PVolumeminus)

  810.             vce.Volume = -vce.Volume;

  811. 

  812.         if(param.PPanning == 0)

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

  814.         else

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

  816. 

  817.         newamplitude[nvoice] = 1.0f;

  818.         if(param.PAmpEnvelopeEnabled) {

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

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

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

  822.         }

  823. 

  824.         if(param.PAmpLfoEnabled) {

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

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

  827.         }

  828. 

  829.         /* Voice Frequency Parameters Init */

  830.         if(param.PFreqEnvelopeEnabled)

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

  832. 

  833.         if(param.PFreqLfoEnabled)

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

  835. 

  836.         /* Voice Filter Parameters Init */

  837.         if(param.PFilterEnabled) {

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

  839.                       basefreq);

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

  841.                     param.PFilterVelocityScaleFunction);

  842. 

  843. 

  844.             if(param.PFilterEnvelopeEnabled) {

  845.                 vce.FilterEnvelope =

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

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

  848.             }

  849. 

  850.             if(param.PFilterLfoEnabled) {

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

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

  853.             }

  854.         }

  855. 

  856.         /* Voice Modulation Parameters Init */

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

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

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

  860. 

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

  862. 

  863.             int vc = nvoice;

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

  865.                 vc = param.PextFMoscil;

  866. 

  867.             float tmp = 1.0f;

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

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

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

  871.                 tmp = getFMvoicebasefreq(nvoice);

  872. 

  873.             if(!pars.GlobalPar.Hrandgrouping)

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

  875. 

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

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

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

  879.                                              vce.FMSmp, tmp))

  880.                                         % synth.oscilsize;

  881. 

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

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

  884.             int oscposhiFM_add =

  885.                 (int)((param.PFMoscilphase

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

  887.                       + synth.oscilsize * 4);

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

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

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

  891.             }

  892.         }

  893. 

  894.         if(param.PFMFreqEnvelopeEnabled)

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

  896. 

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

  898. 

  899.         if(param.PFMAmpEnvelopeEnabled ) {

  900.             vce.FMAmpEnvelope =

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

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

  903.         }

  904.     }

  905. 

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

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

  908.             tmp[i] = 0;

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

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

  911.                 NoteVoicePar[nvoice].VoiceOut =

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

  913.                 tmp[i] = 1;

  914.             }

  915. 

  916.         if(NoteVoicePar[nvoice].VoiceOut)

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

  918.     }

  919. }

  920. 

  921. 

  922. /*

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

  924.  * This must be called before setfreq* functions

  925.  */

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

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

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

  929.         return;

  930.     }

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

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

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

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

  935.         pos += step;

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

  937.             pos  = -1.0f;

  938.             step = -step;

  939.         }

  940.         if(pos >= 1.0f) {

  941.             pos  = 1.0f;

  942.             step = -step;

  943.         }

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

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

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

  947.                                          - 1.0f) + vibratto_val

  948.                                         * unison_vibratto[nvoice].amplitude)

  949.                                      * relbw;

  950. 

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

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

  953.     }

  954. }

  955. 

  956. 

  957. /*

  958.  * Computes the frequency of an oscillator

  959.  */

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

  961. {

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

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

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

  965.         if(speed > synth.oscilsize_f)

  966.             speed = synth.oscilsize_f;

  967. 

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

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

  970.     }

  971. }

  972. 

  973. /*

  974.  * Computes the frequency of an modullator oscillator

  975.  */

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

  977. {

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

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

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

  981.         if(speed > synth.samplerate_f)

  982.             speed = synth.samplerate_f;

  983. 

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

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

  986.     }

  987. }

  988. 

  989. /*

  990.  * Get Voice base frequency

  991.  */

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

  993. {

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

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

  996.                    * ctl.bandwidth.relbw * bandwidthDetuneMultiplier

  997.                    + NoteGlobalPar.Detune / 100.0f;

  998. 

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

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

  1001.     else { //the fixed freq is enabled

  1002.         float fixedfreq   = 440.0f;

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

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

  1005.             float tmp =

  1006.                 (midinote

  1007.                  - 69.0f) / 12.0f

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

  1009.             if(fixedfreqET <= 64)

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

  1011.             else

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

  1013.         }

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

  1015.     }

  1016. }

  1017. 

  1018. /*

  1019.  * Get Voice's Modullator base frequency

  1020.  */

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

  1022. {

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

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

  1025. }

  1026. 

  1027. /*

  1028.  * Computes all the parameters for each tick

  1029.  */

  1030. void ADnote::computecurrentparameters()

  1031. {

  1032.     int   nvoice;

  1033.     float voicefreq, voicepitch, FMfreq,

  1034.           FMrelativepitch, globalpitch;

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

  1036.                            + NoteGlobalPar.FreqLfo->lfoout()

  1037.                            * ctl.modwheel.relmod);

  1038.     globaloldamplitude = globalnewamplitude;

  1039.     globalnewamplitude = NoteGlobalPar.Volume

  1040.                          * NoteGlobalPar.AmpEnvelope->envout_dB()

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

  1042. 

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

  1044.                                  ctl.filterq.relq);

  1045. 

  1046. 

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

  1048.     float portamentofreqrap = 1.0f;

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

  1050.         portamentofreqrap = ctl.portamento.freqrap;

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

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

  1053.     }

  1054. 

  1055.     //compute parameters for all voices

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

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

  1058.             continue;

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

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

  1061.             continue;

  1062. 

  1063.         compute_unison_freq_rap(nvoice);

  1064. 

  1065.         /*******************/

  1066.         /* Voice Amplitude */

  1067.         /*******************/

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

  1069.         newamplitude[nvoice] = 1.0f;

  1070. 

  1071.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

  1073. 

  1074.         if(NoteVoicePar[nvoice].AmpLfo)

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

  1076. 

  1077.         /****************/

  1078.         /* Voice Filter */

  1079.         /****************/

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

  1081.         if(voiceFilter) {

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

  1083.                                 ctl.filterq.relq);

  1084.         }

  1085. 

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

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

  1088.             /* Voice Frequency */

  1089.             /*******************/

  1090.             voicepitch = 0.0f;

  1091.             if(NoteVoicePar[nvoice].FreqLfo)

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

  1093.                               * ctl.bandwidth.relbw;

  1094. 

  1095.             if(NoteVoicePar[nvoice].FreqEnvelope)

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

  1097.                               / 100.0f;

  1098.             voicefreq = getvoicebasefreq(nvoice)

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

  1100.             voicefreq *=

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

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

  1103. 

  1104.             /***************/

  1105.             /*  Modulator */

  1106.             /***************/

  1107. 

  1108. 

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

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

  1111.                 if(NoteVoicePar[nvoice].FMFreqEnvelope)

  1112.                     FMrelativepitch +=

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

  1114.                 if (NoteVoicePar[nvoice].FMFreqFixed)

  1115.                     FMfreq =

  1116.                         powf(2.0f, FMrelativepitch

  1117.                              / 12.0f) * 440.0f;

  1118.                 else

  1119.                     FMfreq =

  1120.                            powf(2.0f, FMrelativepitch

  1121.                                 / 12.0f) * voicefreq * portamentofreqrap;

  1122.                 setfreqFM(nvoice, FMfreq);

  1123. 

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

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

  1126.                                          * ctl.fmamp.relamp;

  1127.                 if(NoteVoicePar[nvoice].FMAmpEnvelope)

  1128.                     FMnewamplitude[nvoice] *=

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

  1130.             }

  1131.         }

  1132.     }

  1133. }

  1134. 

  1135. 

  1136. /*

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

  1138.  */

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

  1140. {

  1141.     int zerocrossings = 0;

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

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

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

  1145. 

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

  1147.     if(tmp < 8.0f)

  1148.         tmp = 8.0f;

  1149.     tmp *= NoteGlobalPar.Fadein_adjustment;

  1150. 

  1151.     int n;

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

  1153.     if(n > synth.buffersize)

  1154.         n = synth.buffersize;

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

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

  1157.         smps[i] *= tmp;

  1158.     }

  1159. }

  1160. 

  1161. /*

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

  1163.  */

  1164. 

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

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

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

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

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

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

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

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

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

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

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

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

  1177.  */

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

  1179. {

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

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

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

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

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

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

  1186.         float *tw     = tmpwave_unison[k];

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

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

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

  1190.             poslo += freqlo;

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

  1192.             poslo &= 0xffffff;

  1193.             poshi &= synth.oscilsize - 1;

  1194.         }

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

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

  1197.     }

  1198. }

  1199. 

  1200. 

  1201. 

  1202. /*

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

  1204.  *

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

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

  1207.     int i,poshi;

  1208.     float poslo;

  1209. 

  1210.     poshi=oscposhi[nvoice];

  1211.     poslo=oscposlo[nvoice];

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

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

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

  1215.     xm1=smps[poshi];

  1216.     x0=smps[poshi+1];

  1217.     x1=smps[poshi+2];

  1218.     x2=smps[poshi+3];

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

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

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

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

  1223.     printf("a\n");

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

  1225.     poslo+=oscfreqlo[nvoice];

  1226.     if (poslo>=1.0f) {

  1227.             poslo-=1.0f;

  1228.         poshi++;

  1229.     };

  1230.         poshi+=oscfreqhi[nvoice];

  1231.         poshi&=synth.oscilsize-1;

  1232.     };

  1233.     oscposhi[nvoice]=poshi;

  1234.     oscposlo[nvoice]=poslo;

  1235. };

  1236. */

  1237. /*

  1238.  * Computes the Oscillator (Morphing)

  1239.  */

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

  1241. {

  1242.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1244.         FMnewamplitude[nvoice] = 1.0f;

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

  1246.         FMoldamplitude[nvoice] = 1.0f;

  1247. 

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

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

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

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

  1252.             float *tw = tmpwave_unison[k];

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

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

  1255.                                             FMnewamplitude[nvoice],

  1256.                                             i,

  1257.                                             synth.buffersize);

  1258.                 tw[i] = tw[i]

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

  1260.             }

  1261.         }

  1262.     }

  1263.     else

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

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

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

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

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

  1269.             float *tw = tmpwave_unison[k];

  1270. 

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

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

  1273.                                             FMnewamplitude[nvoice],

  1274.                                             i,

  1275.                                             synth.buffersize);

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

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

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

  1279.                 posloFM += freqloFM;

  1280.                 if(posloFM >= 1.0f) {

  1281.                     posloFM -= 1.0f;

  1282.                     poshiFM++;

  1283.                 }

  1284.                 poshiFM += freqhiFM;

  1285.                 poshiFM &= synth.oscilsize - 1;

  1286.             }

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

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

  1289.         }

  1290. }

  1291. 

  1292. /*

  1293.  * Computes the Oscillator (Ring Modulation)

  1294.  */

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

  1296. {

  1297.     ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1299.         FMnewamplitude[nvoice] = 1.0f;

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

  1301.         FMoldamplitude[nvoice] = 1.0f;

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

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

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

  1305.             float *tw = tmpwave_unison[k];

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

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

  1308.                                             FMnewamplitude[nvoice],

  1309.                                             i,

  1310.                                             synth.buffersize);

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

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

  1313.             }

  1314.         }

  1315.     else

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

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

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

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

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

  1321.             float *tw = tmpwave_unison[k];

  1322. 

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

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

  1325.                                             FMnewamplitude[nvoice],

  1326.                                             i,

  1327.                                             synth.buffersize);

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

  1329.                           + NoteVoicePar[nvoice].FMSmp[poshiFM

  1330.                                                        + 1] * posloFM) * amp

  1331.                          + (1.0f - amp);

  1332.                 posloFM += freqloFM;

  1333.                 if(posloFM >= 1.0f) {

  1334.                     posloFM -= 1.0f;

  1335.                     poshiFM++;

  1336.                 }

  1337.                 poshiFM += freqhiFM;

  1338.                 poshiFM &= synth.oscilsize - 1;

  1339.             }

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

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

  1342.         }

  1343. }

  1344. 

  1345. /*

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

  1347.  */

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

  1349.                                                               int FMmode)

  1350. {

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

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

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

  1354.             float *tw = tmpwave_unison[k];

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

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

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

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

  1359.             else

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

  1361.         }

  1362.     } else {

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

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

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

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

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

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

  1369.             float *tw = tmpwave_unison[k];

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

  1371. 

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

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

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

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

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

  1377. 

  1378.                 posloFM += freqloFM;

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

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

  1381.                     poshiFM++;

  1382.                 }

  1383.                 poshiFM += freqhiFM;

  1384.                 poshiFM &= synth.oscilsize - 1;

  1385.             }

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

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

  1388.         }

  1389.     }

  1390.     // Amplitude interpolation

  1391.     if(ABOVE_AMPLITUDE_THRESHOLD(FMoldamplitude[nvoice],

  1392.                                  FMnewamplitude[nvoice])) {

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

  1394.             float *tw = tmpwave_unison[k];

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

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

  1397.                                                FMnewamplitude[nvoice],

  1398.                                                i,

  1399.                                                synth.buffersize);

  1400.         }

  1401.     } else {

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

  1403.             float *tw = tmpwave_unison[k];

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

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

  1406.         }

  1407.     }

  1408. 

  1409. 

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

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

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

  1413.                           / synth.samplerate_f;

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

  1415.             float *tw    = tmpwave_unison[k];

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

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

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

  1419.                 tw[i] = fmold;

  1420.             }

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

  1422.         }

  1423.     }

  1424.     else {  //Phase or PWM modulation

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

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

  1427.             float *tw = tmpwave_unison[k];

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

  1429.                 tw[i] *= normalize;

  1430.         }

  1431.     }

  1432. 

  1433.     //do the modulation

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

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

  1436.         float *tw     = tmpwave_unison[k];

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

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

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

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

  1441. 

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

  1443.             int FMmodfreqhi = 0;

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

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

  1446.             if(FMmodfreqhi < 0)

  1447.                 FMmodfreqlo++;

  1448. 

  1449.             //carrier

  1450.             int carposhi = poshi + FMmodfreqhi;

  1451.             int carposlo = poslo + FMmodfreqlo;

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

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

  1454. 

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

  1456.                 carposhi++;

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

  1458.             }

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

  1460. 

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

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

  1463. 

  1464.             poslo += freqlo;

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

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

  1467.                 poshi++;

  1468.             }

  1469. 

  1470.             poshi += freqhi;

  1471.             poshi &= synth.oscilsize - 1;

  1472.         }

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

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

  1475.     }

  1476. }

  1477. 

  1478. 

  1479. /*

  1480.  * Computes the Noise

  1481.  */

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

  1483. {

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

  1485.         float *tw = tmpwave_unison[k];

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

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

  1488.     }

  1489. }

  1490. 

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

  1492. {

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

  1494.         float *tw = tmpwave_unison[k];

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

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

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

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

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

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

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

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

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

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

  1505. 	    f[6] = white*0.115926;

  1506.         }

  1507.     }

  1508. }

  1509. 

  1510. 

  1511. 

  1512. /*

  1513.  * Compute the ADnote samples

  1514.  * Returns 0 if the note is finished

  1515.  */

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

  1517. {

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

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

  1520. 

  1521.     if(NoteEnabled == OFF)

  1522.         return 0;

  1523. 

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

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

  1526.     computecurrentparameters();

  1527. 

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

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

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

  1531.             continue;

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

  1533.             case 0: //voice mode=sound

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

  1535.                     case MORPH:

  1536.                         ComputeVoiceOscillatorMorph(nvoice);

  1537.                         break;

  1538.                     case RING_MOD:

  1539.                         ComputeVoiceOscillatorRingModulation(nvoice);

  1540.                         break;

  1541.                     case FREQ_MOD:

  1542.                     case PHASE_MOD:

  1543.                     case PW_MOD:

  1544.                         ComputeVoiceOscillatorFrequencyModulation(nvoice,

  1545.                                                                   NoteVoicePar[nvoice].FMEnabled);

  1546.                         break;

  1547.                     default:

  1548.                         ComputeVoiceOscillator_LinearInterpolation(nvoice);

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

  1550.                 }

  1551.                 break;

  1552.             case 1:

  1553.                 ComputeVoiceWhiteNoise(nvoice);

  1554.                 break;

  1555.             default:

  1556.                 ComputeVoicePinkNoise(nvoice);

  1557.                 break;

  1558.         }

  1559.         // Voice Processing

  1560. 

  1561. 

  1562.         //mix subvoices into voice

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

  1564.         if(stereo)

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

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

  1567.             float *tw = tmpwave_unison[k];

  1568.             if(stereo) {

  1569.                 float stereo_pos = 0;

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

  1571.                 if (is_pwm) {

  1572.                     if(unison_size[nvoice] > 2)

  1573.                         stereo_pos = k/2

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

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

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

  1577.                     stereo_pos = k

  1578.                         / (float)(unison_size[nvoice]

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

  1580.                 }

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

  1582.                 if(stereo_spread > 1.0f) {

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

  1584.                     stereo_pos =

  1585.                         (2.0f

  1586.                          - stereo_spread) * stereo_pos

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

  1588.                 }

  1589.                 else

  1590.                     stereo_pos *= stereo_spread;

  1591. 

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

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

  1594.                     stereo_pos = 0.0f;

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

  1596. 

  1597. 

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

  1599.                 if(lvol > 1.0f)

  1600.                     lvol = 1.0f;

  1601. 

  1602.                 float rvol = panning * 2.0f;

  1603.                 if(rvol > 1.0f)

  1604.                     rvol = 1.0f;

  1605. 

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

  1607.                     lvol = -lvol;

  1608.                     rvol = -rvol;

  1609.                 }

  1610. 

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

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

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

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

  1615.             }

  1616.             else

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

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

  1619.         }

  1620. 

  1621. 

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

  1623.         // Amplitude

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

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

  1626. 

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

  1628.             int rest = synth.buffersize;

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

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

  1631.                 rest = 10;

  1632.                 if(rest > synth.buffersize)

  1633.                     rest = synth.buffersize;

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

  1635.                     tmpwavel[i] *= oldam;

  1636.                 if(stereo)

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

  1638.                         tmpwaver[i] *= oldam;

  1639.             }

  1640.             // Amplitude interpolation

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

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

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

  1644.                 if(stereo)

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

  1646.             }

  1647.         }

  1648.         else {

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

  1650.                 tmpwavel[i] *= newam;

  1651.             if(stereo)

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

  1653.                     tmpwaver[i] *= newam;

  1654.         }

  1655. 

  1656.         // Fade in

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

  1658.             fadein(&tmpwavel[0]);

  1659.             if(stereo)

  1660.                 fadein(&tmpwaver[0]);

  1661.             firsttick[nvoice] = 0;

  1662.         }

  1663. 

  1664.         // Filter

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

  1666.             if(stereo)

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

  1668.             else

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

  1670.         }

  1671. 

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

  1673.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

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

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

  1677.                 if(stereo)

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

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

  1680.             }

  1681.         //the voice is killed later

  1682. 

  1683. 

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

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

  1686.             if(stereo)

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

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

  1689.                                                        + tmpwaver[i];

  1690.             else   //mono

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

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

  1693.         }

  1694. 

  1695. 

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

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

  1698.             if(stereo)

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

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

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

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

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

  1704.                 }

  1705.             else

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

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

  1708.         }

  1709.         else {  //bypass the filter

  1710.             if(stereo)

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

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

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

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

  1715.                                   * (1.0f

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

  1717.                 }

  1718.             else

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

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

  1721.         }

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

  1723.         if(NoteVoicePar[nvoice].AmpEnvelope)

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

  1725.                 KillVoice(nvoice);

  1726.     }

  1727. 

  1728. 

  1729.     //Processing Global parameters

  1730.     if(stereo) {

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

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

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

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

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

  1736.     }

  1737. 

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

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

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

  1741.     }

  1742. 

  1743.     if(ABOVE_AMPLITUDE_THRESHOLD(globaloldamplitude, globalnewamplitude))

  1744.         // Amplitude Interpolation

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

  1746.             float tmpvol = INTERPOLATE_AMPLITUDE(globaloldamplitude,

  1747.                                                  globalnewamplitude,

  1748.                                                  i,

  1749.                                                  synth.buffersize);

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

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

  1752.         }

  1753.     else

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

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

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

  1757.         }

  1758. 

  1759.     //Apply the punch

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

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

  1762.             float punchamp = NoteGlobalPar.Punch.initialvalue

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

  1764.             outl[i] *= punchamp;

  1765.             outr[i] *= punchamp;

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

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

  1768.                 NoteGlobalPar.Punch.Enabled = 0;

  1769.                 break;

  1770.             }

  1771.         }

  1772. 

  1773. 

  1774.     // Apply legato-specific sound signal modifications

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

  1776. 

  1777. 

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

  1779.     // If it does, disable the note

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

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

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

  1783.             outl[i] *= tmp;

  1784.             outr[i] *= tmp;

  1785.         }

  1786.         KillNote();

  1787.     }

  1788.     return 1;

  1789. }

  1790. 

  1791. 

  1792. /*

  1793.  * Release the key (NoteOff)

  1794.  */

  1795. void ADnote::releasekey()

  1796. {

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

  1798.         NoteVoicePar[nvoice].releasekey();

  1799.     NoteGlobalPar.FreqEnvelope->releasekey();

  1800.     NoteGlobalPar.FilterEnvelope->releasekey();

  1801.     NoteGlobalPar.AmpEnvelope->releasekey();

  1802. }

  1803. 

  1804. /*

  1805.  * Check if the note is finished

  1806.  */

  1807. bool ADnote::finished() const

  1808. {

  1809.     if(NoteEnabled == ON)

  1810.         return 0;

  1811.     else

  1812.         return 1;

  1813. }

  1814. 

  1815. void ADnote::entomb(void)

  1816. {

  1817.     NoteGlobalPar.AmpEnvelope->forceFinish();

  1818. }

  1819. 

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

  1821. {

  1822.     if(!Enabled)

  1823.         return;

  1824.     if(AmpEnvelope)

  1825.         AmpEnvelope->releasekey();

  1826.     if(FreqEnvelope)

  1827.         FreqEnvelope->releasekey();

  1828.     if(FilterEnvelope)

  1829.         FilterEnvelope->releasekey();

  1830.     if(FMFreqEnvelope)

  1831.         FMFreqEnvelope->releasekey();

  1832.     if(FMAmpEnvelope)

  1833.         FMAmpEnvelope->releasekey();

  1834. }

  1835. 

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

  1837. {

  1838.     memory.devalloc(OscilSmp);

  1839.     memory.dealloc(FreqEnvelope);

  1840.     memory.dealloc(FreqLfo);

  1841.     memory.dealloc(AmpEnvelope);

  1842.     memory.dealloc(AmpLfo);

  1843.     memory.dealloc(Filter);

  1844.     memory.dealloc(FilterEnvelope);

  1845.     memory.dealloc(FilterLfo);

  1846.     memory.dealloc(FMFreqEnvelope);

  1847.     memory.dealloc(FMAmpEnvelope);

  1848. 

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

  1850.         memory.devalloc(FMSmp);

  1851. 

  1852.     if(VoiceOut)

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

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

  1855.     //an input to another voice

  1856. 

  1857.     Enabled = OFF;

  1858. }

  1859. 

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

  1861. {

  1862.     memory.dealloc(FreqEnvelope);

  1863.     memory.dealloc(FreqLfo);

  1864.     memory.dealloc(AmpEnvelope);

  1865.     memory.dealloc(AmpLfo);

  1866.     memory.dealloc(Filter);

  1867.     memory.dealloc(FilterEnvelope);

  1868.     memory.dealloc(FilterLfo);

  1869. }

  1870. 

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

  1872.                                     const SYNTH_T &synth,

  1873.                                     const AbsTime &time,

  1874.                                     class Allocator &memory,

  1875.                                     float basefreq, float velocity,

  1876.                                     bool stereo)

  1877. {

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

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

  1880. 

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

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

  1883. 

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

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

  1886. 

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

  1888.             stereo, basefreq);

  1889. 

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

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

  1892. 

  1893.     Filter->addMod(*FilterEnvelope);

  1894.     Filter->addMod(*FilterLfo);

  1895.     

  1896.     {

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

  1898.                 param.PFilterVelocityScaleFunction);

  1899.     }

  1900. }