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.
476 Commits
16 Branches
16GB
Tree: 6be14ec8ae
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6be14ec8ae'
${ noResults }
Carla/source/backend/native/zynaddsubfx/Params/ADnoteParameters.cpp

793 lines
23KB
Raw Blame History 

  1. /*

  2.   ZynAddSubFX - a software synthesizer

  3. 

  4.   ADnoteParameters.cpp - Parameters for ADnote (ADsynth)

  5.   Copyright (C) 2002-2005 Nasca Octavian Paul

  6.   Author: Nasca Octavian Paul

  7. 

  8.   This program is free software; you can redistribute it and/or modify

  9.   it under the terms of version 2 of the GNU General Public License

  10.   as published by the Free Software Foundation.

  11. 

  12.   This program is distributed in the hope that it will be useful,

  13.   but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  15.   GNU General Public License (version 2 or later) for more details.

  16. 

  17.   You should have received a copy of the GNU General Public License (version 2)

  18.   along with this program; if not, write to the Free Software Foundation,

  19.   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA

  20. 

  21. */

  22. 

  23. #include <stdlib.h>

  24. #include <stdio.h>

  25. #include <math.h>

  26. 

  27. #include "ADnoteParameters.h"

  28. #include "EnvelopeParams.h"

  29. #include "LFOParams.h"

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

  31. #include "../DSP/FFTwrapper.h"

  32. #include "../Synth/OscilGen.h"

  33. #include "../Synth/Resonance.h"

  34. #include "FilterParams.h"

  35. 

  36. int ADnote_unison_sizes[] =

  37. {1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 25, 30, 40, 50, 0};

  38. 

  39. ADnoteParameters::ADnoteParameters(FFTwrapper *fft_)

  40.     :PresetsArray()

  41. {

  42.     setpresettype("Padsyth");

  43.     fft = fft_;

  44. 

  45. 

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

  47.         EnableVoice(nvoice);

  48. 

  49.     defaults();

  50. }

  51. 

  52. ADnoteGlobalParam::ADnoteGlobalParam()

  53. {

  54.     FreqEnvelope = new EnvelopeParams(0, 0);

  55.     FreqEnvelope->ASRinit(64, 50, 64, 60);

  56.     FreqLfo = new LFOParams(70, 0, 64, 0, 0, 0, 0, 0);

  57. 

  58.     AmpEnvelope = new EnvelopeParams(64, 1);

  59.     AmpEnvelope->ADSRinit_dB(0, 40, 127, 25);

  60.     AmpLfo = new LFOParams(80, 0, 64, 0, 0, 0, 0, 1);

  61. 

  62.     GlobalFilter   = new FilterParams(2, 94, 40);

  63.     FilterEnvelope = new EnvelopeParams(0, 1);

  64.     FilterEnvelope->ADSRinit_filter(64, 40, 64, 70, 60, 64);

  65.     FilterLfo = new LFOParams(80, 0, 64, 0, 0, 0, 0, 2);

  66.     Reson     = new Resonance();

  67. }

  68. 

  69. void ADnoteParameters::defaults()

  70. {

  71.     //Default Parameters

  72.     GlobalPar.defaults();

  73. 

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

  75.         defaults(nvoice);

  76. 

  77.     VoicePar[0].Enabled = 1;

  78. }

  79. 

  80. void ADnoteGlobalParam::defaults()

  81. {

  82.     /* Frequency Global Parameters */

  83.     PStereo = 1; //stereo

  84.     PDetune = 8192; //zero

  85.     PCoarseDetune = 0;

  86.     PDetuneType   = 1;

  87.     FreqEnvelope->defaults();

  88.     FreqLfo->defaults();

  89.     PBandwidth = 64;

  90. 

  91.     /* Amplitude Global Parameters */

  92.     PVolume  = 90;

  93.     PPanning = 64; //center

  94.     PAmpVelocityScaleFunction = 64;

  95.     AmpEnvelope->defaults();

  96.     AmpLfo->defaults();

  97.     PPunchStrength = 0;

  98.     PPunchTime     = 60;

  99.     PPunchStretch  = 64;

  100.     PPunchVelocitySensing = 72;

  101.     Hrandgrouping = 0;

  102. 

  103.     /* Filter Global Parameters*/

  104.     PFilterVelocityScale = 64;

  105.     PFilterVelocityScaleFunction = 64;

  106.     GlobalFilter->defaults();

  107.     FilterEnvelope->defaults();

  108.     FilterLfo->defaults();

  109.     Reson->defaults();

  110. }

  111. 

  112. /*

  113.  * Defaults a voice

  114.  */

  115. void ADnoteParameters::defaults(int n)

  116. {

  117.     VoicePar[n].defaults();

  118. }

  119. 

  120. void ADnoteVoiceParam::defaults()

  121. {

  122.     Enabled = 0;

  123. 

  124.     Unison_size = 1;

  125.     Unison_frequency_spread = 60;

  126.     Unison_stereo_spread    = 64;

  127.     Unison_vibratto = 64;

  128.     Unison_vibratto_speed = 64;

  129.     Unison_invert_phase   = 0;

  130. 

  131.     Type = 0;

  132.     Pfixedfreq    = 0;

  133.     PfixedfreqET  = 0;

  134.     Presonance    = 1;

  135.     Pfilterbypass = 0;

  136.     Pextoscil     = -1;

  137.     PextFMoscil   = -1;

  138.     Poscilphase   = 64;

  139.     PFMoscilphase = 64;

  140.     PDelay                    = 0;

  141.     PVolume                   = 100;

  142.     PVolumeminus              = 0;

  143.     PPanning                  = 64; //center

  144.     PDetune                   = 8192; //8192=0

  145.     PCoarseDetune             = 0;

  146.     PDetuneType               = 0;

  147.     PFreqLfoEnabled           = 0;

  148.     PFreqEnvelopeEnabled      = 0;

  149.     PAmpEnvelopeEnabled       = 0;

  150.     PAmpLfoEnabled            = 0;

  151.     PAmpVelocityScaleFunction = 127;

  152.     PFilterEnabled            = 0;

  153.     PFilterEnvelopeEnabled    = 0;

  154.     PFilterLfoEnabled         = 0;

  155.     PFMEnabled                = 0;

  156. 

  157.     //I use the internal oscillator (-1)

  158.     PFMVoice = -1;

  159. 

  160.     PFMVolume       = 90;

  161.     PFMVolumeDamp   = 64;

  162.     PFMDetune       = 8192;

  163.     PFMCoarseDetune = 0;

  164.     PFMDetuneType   = 0;

  165.     PFMFreqEnvelopeEnabled   = 0;

  166.     PFMAmpEnvelopeEnabled    = 0;

  167.     PFMVelocityScaleFunction = 64;

  168. 

  169.     OscilSmp->defaults();

  170.     FMSmp->defaults();

  171. 

  172.     AmpEnvelope->defaults();

  173.     AmpLfo->defaults();

  174. 

  175.     FreqEnvelope->defaults();

  176.     FreqLfo->defaults();

  177. 

  178.     VoiceFilter->defaults();

  179.     FilterEnvelope->defaults();

  180.     FilterLfo->defaults();

  181. 

  182.     FMFreqEnvelope->defaults();

  183.     FMAmpEnvelope->defaults();

  184. }

  185. 

  186. 

  187. 

  188. /*

  189.  * Init the voice parameters

  190.  */

  191. void ADnoteParameters::EnableVoice(int nvoice)

  192. {

  193.     VoicePar[nvoice].enable(fft, GlobalPar.Reson);

  194. }

  195. 

  196. void ADnoteVoiceParam::enable(FFTwrapper *fft, Resonance *Reson)

  197. {

  198.     OscilSmp = new OscilGen(fft, Reson);

  199.     FMSmp    = new OscilGen(fft, NULL);

  200. 

  201.     AmpEnvelope = new EnvelopeParams(64, 1);

  202.     AmpEnvelope->ADSRinit_dB(0, 100, 127, 100);

  203.     AmpLfo = new LFOParams(90, 32, 64, 0, 0, 30, 0, 1);

  204. 

  205.     FreqEnvelope = new EnvelopeParams(0, 0);

  206.     FreqEnvelope->ASRinit(30, 40, 64, 60);

  207.     FreqLfo = new LFOParams(50, 40, 0, 0, 0, 0, 0, 0);

  208. 

  209.     VoiceFilter    = new FilterParams(2, 50, 60);

  210.     FilterEnvelope = new EnvelopeParams(0, 0);

  211.     FilterEnvelope->ADSRinit_filter(90, 70, 40, 70, 10, 40);

  212.     FilterLfo = new LFOParams(50, 20, 64, 0, 0, 0, 0, 2);

  213. 

  214.     FMFreqEnvelope = new EnvelopeParams(0, 0);

  215.     FMFreqEnvelope->ASRinit(20, 90, 40, 80);

  216.     FMAmpEnvelope = new EnvelopeParams(64, 1);

  217.     FMAmpEnvelope->ADSRinit(80, 90, 127, 100);

  218. }

  219. 

  220. /*

  221.  * Get the Multiplier of the fine detunes of the voices

  222.  */

  223. float ADnoteParameters::getBandwidthDetuneMultiplier()

  224. {

  225.     float bw = (GlobalPar.PBandwidth - 64.0f) / 64.0f;

  226.     bw = powf(2.0f, bw * powf(fabs(bw), 0.2f) * 5.0f);

  227. 

  228.     return bw;

  229. }

  230. 

  231. /*

  232.  * Get the unison spread in cents for a voice

  233.  */

  234. 

  235. float ADnoteParameters::getUnisonFrequencySpreadCents(int nvoice) {

  236.     float unison_spread = VoicePar[nvoice].Unison_frequency_spread / 127.0f;

  237.     unison_spread = powf(unison_spread * 2.0f, 2.0f) * 50.0f; //cents

  238.     return unison_spread;

  239. }

  240. 

  241. /*

  242.  * Kill the voice

  243.  */

  244. void ADnoteParameters::KillVoice(int nvoice)

  245. {

  246.     VoicePar[nvoice].kill();

  247. }

  248. 

  249. void ADnoteVoiceParam::kill()

  250. {

  251.     delete OscilSmp;

  252.     delete FMSmp;

  253. 

  254.     delete AmpEnvelope;

  255.     delete AmpLfo;

  256. 

  257.     delete FreqEnvelope;

  258.     delete FreqLfo;

  259. 

  260.     delete VoiceFilter;

  261.     delete FilterEnvelope;

  262.     delete FilterLfo;

  263. 

  264.     delete FMFreqEnvelope;

  265.     delete FMAmpEnvelope;

  266. }

  267. 

  268. 

  269. ADnoteGlobalParam::~ADnoteGlobalParam()

  270. {

  271.     delete FreqEnvelope;

  272.     delete FreqLfo;

  273.     delete AmpEnvelope;

  274.     delete AmpLfo;

  275.     delete GlobalFilter;

  276.     delete FilterEnvelope;

  277.     delete FilterLfo;

  278.     delete Reson;

  279. }

  280. 

  281. ADnoteParameters::~ADnoteParameters()

  282. {

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

  284.         KillVoice(nvoice);

  285. }

  286. 

  287. int ADnoteParameters::get_unison_size_index(int nvoice) {

  288.     int index = 0;

  289.     if(nvoice >= NUM_VOICES)

  290.         return 0;

  291.     int unison = VoicePar[nvoice].Unison_size;

  292. 

  293.     while(1) {

  294.         if(ADnote_unison_sizes[index] >= unison)

  295.             return index;

  296. 

  297.         if(ADnote_unison_sizes[index] == 0)

  298.             return index - 1;

  299. 

  300.         index++;

  301.     }

  302.     return 0;

  303. }

  304. 

  305. void ADnoteParameters::set_unison_size_index(int nvoice, int index) {

  306.     int unison = 1;

  307.     for(int i = 0; i <= index; ++i) {

  308.         unison = ADnote_unison_sizes[i];

  309.         if(unison == 0) {

  310.             unison = ADnote_unison_sizes[i - 1];

  311.             break;

  312.         }

  313.     }

  314. 

  315.     VoicePar[nvoice].Unison_size = unison;

  316. }

  317. 

  318. 

  319. 

  320. void ADnoteParameters::add2XMLsection(XMLwrapper *xml, int n)

  321. {

  322.     int nvoice = n;

  323.     if(nvoice >= NUM_VOICES)

  324.         return;

  325. 

  326.     int oscilused = 0, fmoscilused = 0; //if the oscil or fmoscil are used by another voice

  327. 

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

  329.         if(VoicePar[i].Pextoscil == nvoice)

  330.             oscilused = 1;

  331.         if(VoicePar[i].PextFMoscil == nvoice)

  332.             fmoscilused = 1;

  333.     }

  334. 

  335.     xml->addparbool("enabled", VoicePar[nvoice].Enabled);

  336.     if(((VoicePar[nvoice].Enabled == 0) && (oscilused == 0)

  337.         && (fmoscilused == 0)) && (xml->minimal))

  338.         return;

  339. 

  340.     VoicePar[nvoice].add2XML(xml, fmoscilused);

  341. }

  342. 

  343. void ADnoteVoiceParam::add2XML(XMLwrapper *xml, bool fmoscilused)

  344. {

  345.     xml->addpar("type", Type);

  346. 

  347.     xml->addpar("unison_size", Unison_size);

  348.     xml->addpar("unison_frequency_spread",

  349.                 Unison_frequency_spread);

  350.     xml->addpar("unison_stereo_spread", Unison_stereo_spread);

  351.     xml->addpar("unison_vibratto", Unison_vibratto);

  352.     xml->addpar("unison_vibratto_speed", Unison_vibratto_speed);

  353.     xml->addpar("unison_invert_phase", Unison_invert_phase);

  354. 

  355.     xml->addpar("delay", PDelay);

  356.     xml->addparbool("resonance", Presonance);

  357. 

  358.     xml->addpar("ext_oscil", Pextoscil);

  359.     xml->addpar("ext_fm_oscil", PextFMoscil);

  360. 

  361.     xml->addpar("oscil_phase", Poscilphase);

  362.     xml->addpar("oscil_fm_phase", PFMoscilphase);

  363. 

  364.     xml->addparbool("filter_enabled", PFilterEnabled);

  365.     xml->addparbool("filter_bypass", Pfilterbypass);

  366. 

  367.     xml->addpar("fm_enabled", PFMEnabled);

  368. 

  369.     xml->beginbranch("OSCIL");

  370.     OscilSmp->add2XML(xml);

  371.     xml->endbranch();

  372. 

  373. 

  374.     xml->beginbranch("AMPLITUDE_PARAMETERS");

  375.     xml->addpar("panning", PPanning);

  376.     xml->addpar("volume", PVolume);

  377.     xml->addparbool("volume_minus", PVolumeminus);

  378.     xml->addpar("velocity_sensing", PAmpVelocityScaleFunction);

  379. 

  380.     xml->addparbool("amp_envelope_enabled",

  381.                     PAmpEnvelopeEnabled);

  382.     if((PAmpEnvelopeEnabled != 0) || (!xml->minimal)) {

  383.         xml->beginbranch("AMPLITUDE_ENVELOPE");

  384.         AmpEnvelope->add2XML(xml);

  385.         xml->endbranch();

  386.     }

  387.     xml->addparbool("amp_lfo_enabled", PAmpLfoEnabled);

  388.     if((PAmpLfoEnabled != 0) || (!xml->minimal)) {

  389.         xml->beginbranch("AMPLITUDE_LFO");

  390.         AmpLfo->add2XML(xml);

  391.         xml->endbranch();

  392.     }

  393.     xml->endbranch();

  394. 

  395.     xml->beginbranch("FREQUENCY_PARAMETERS");

  396.     xml->addparbool("fixed_freq", Pfixedfreq);

  397.     xml->addpar("fixed_freq_et", PfixedfreqET);

  398.     xml->addpar("detune", PDetune);

  399.     xml->addpar("coarse_detune", PCoarseDetune);

  400.     xml->addpar("detune_type", PDetuneType);

  401. 

  402.     xml->addparbool("freq_envelope_enabled",

  403.                     PFreqEnvelopeEnabled);

  404.     if((PFreqEnvelopeEnabled != 0) || (!xml->minimal)) {

  405.         xml->beginbranch("FREQUENCY_ENVELOPE");

  406.         FreqEnvelope->add2XML(xml);

  407.         xml->endbranch();

  408.     }

  409.     xml->addparbool("freq_lfo_enabled", PFreqLfoEnabled);

  410.     if((PFreqLfoEnabled != 0) || (!xml->minimal)) {

  411.         xml->beginbranch("FREQUENCY_LFO");

  412.         FreqLfo->add2XML(xml);

  413.         xml->endbranch();

  414.     }

  415.     xml->endbranch();

  416. 

  417. 

  418.     if((PFilterEnabled != 0) || (!xml->minimal)) {

  419.         xml->beginbranch("FILTER_PARAMETERS");

  420.         xml->beginbranch("FILTER");

  421.         VoiceFilter->add2XML(xml);

  422.         xml->endbranch();

  423. 

  424.         xml->addparbool("filter_envelope_enabled",

  425.                         PFilterEnvelopeEnabled);

  426.         if((PFilterEnvelopeEnabled != 0) || (!xml->minimal)) {

  427.             xml->beginbranch("FILTER_ENVELOPE");

  428.             FilterEnvelope->add2XML(xml);

  429.             xml->endbranch();

  430.         }

  431. 

  432.         xml->addparbool("filter_lfo_enabled",

  433.                         PFilterLfoEnabled);

  434.         if((PFilterLfoEnabled != 0) || (!xml->minimal)) {

  435.             xml->beginbranch("FILTER_LFO");

  436.             FilterLfo->add2XML(xml);

  437.             xml->endbranch();

  438.         }

  439.         xml->endbranch();

  440.     }

  441. 

  442.     if((PFMEnabled != 0) || (fmoscilused != 0)

  443.        || (!xml->minimal)) {

  444.         xml->beginbranch("FM_PARAMETERS");

  445.         xml->addpar("input_voice", PFMVoice);

  446. 

  447.         xml->addpar("volume", PFMVolume);

  448.         xml->addpar("volume_damp", PFMVolumeDamp);

  449.         xml->addpar("velocity_sensing",

  450.                     PFMVelocityScaleFunction);

  451. 

  452.         xml->addparbool("amp_envelope_enabled",

  453.                         PFMAmpEnvelopeEnabled);

  454.         if((PFMAmpEnvelopeEnabled != 0) || (!xml->minimal)) {

  455.             xml->beginbranch("AMPLITUDE_ENVELOPE");

  456.             FMAmpEnvelope->add2XML(xml);

  457.             xml->endbranch();

  458.         }

  459.         xml->beginbranch("MODULATOR");

  460.         xml->addpar("detune", PFMDetune);

  461.         xml->addpar("coarse_detune", PFMCoarseDetune);

  462.         xml->addpar("detune_type", PFMDetuneType);

  463. 

  464.         xml->addparbool("freq_envelope_enabled",

  465.                         PFMFreqEnvelopeEnabled);

  466.         if((PFMFreqEnvelopeEnabled != 0) || (!xml->minimal)) {

  467.             xml->beginbranch("FREQUENCY_ENVELOPE");

  468.             FMFreqEnvelope->add2XML(xml);

  469.             xml->endbranch();

  470.         }

  471. 

  472.         xml->beginbranch("OSCIL");

  473.         FMSmp->add2XML(xml);

  474.         xml->endbranch();

  475. 

  476.         xml->endbranch();

  477.         xml->endbranch();

  478.     }

  479. }

  480. 

  481. void ADnoteGlobalParam::add2XML(XMLwrapper *xml)

  482. {

  483.     xml->addparbool("stereo", PStereo);

  484. 

  485.     xml->beginbranch("AMPLITUDE_PARAMETERS");

  486.     xml->addpar("volume", PVolume);

  487.     xml->addpar("panning", PPanning);

  488.     xml->addpar("velocity_sensing", PAmpVelocityScaleFunction);

  489.     xml->addpar("punch_strength", PPunchStrength);

  490.     xml->addpar("punch_time", PPunchTime);

  491.     xml->addpar("punch_stretch", PPunchStretch);

  492.     xml->addpar("punch_velocity_sensing", PPunchVelocitySensing);

  493.     xml->addpar("harmonic_randomness_grouping", Hrandgrouping);

  494. 

  495.     xml->beginbranch("AMPLITUDE_ENVELOPE");

  496.     AmpEnvelope->add2XML(xml);

  497.     xml->endbranch();

  498. 

  499.     xml->beginbranch("AMPLITUDE_LFO");

  500.     AmpLfo->add2XML(xml);

  501.     xml->endbranch();

  502.     xml->endbranch();

  503. 

  504.     xml->beginbranch("FREQUENCY_PARAMETERS");

  505.     xml->addpar("detune", PDetune);

  506. 

  507.     xml->addpar("coarse_detune", PCoarseDetune);

  508.     xml->addpar("detune_type", PDetuneType);

  509. 

  510.     xml->addpar("bandwidth", PBandwidth);

  511. 

  512.     xml->beginbranch("FREQUENCY_ENVELOPE");

  513.     FreqEnvelope->add2XML(xml);

  514.     xml->endbranch();

  515. 

  516.     xml->beginbranch("FREQUENCY_LFO");

  517.     FreqLfo->add2XML(xml);

  518.     xml->endbranch();

  519.     xml->endbranch();

  520. 

  521. 

  522.     xml->beginbranch("FILTER_PARAMETERS");

  523.     xml->addpar("velocity_sensing_amplitude", PFilterVelocityScale);

  524.     xml->addpar("velocity_sensing", PFilterVelocityScaleFunction);

  525. 

  526.     xml->beginbranch("FILTER");

  527.     GlobalFilter->add2XML(xml);

  528.     xml->endbranch();

  529. 

  530.     xml->beginbranch("FILTER_ENVELOPE");

  531.     FilterEnvelope->add2XML(xml);

  532.     xml->endbranch();

  533. 

  534.     xml->beginbranch("FILTER_LFO");

  535.     FilterLfo->add2XML(xml);

  536.     xml->endbranch();

  537.     xml->endbranch();

  538. 

  539.     xml->beginbranch("RESONANCE");

  540.     Reson->add2XML(xml);

  541.     xml->endbranch();

  542. }

  543. 

  544. void ADnoteParameters::add2XML(XMLwrapper *xml)

  545. {

  546.     GlobalPar.add2XML(xml);

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

  548.         xml->beginbranch("VOICE", nvoice);

  549.         add2XMLsection(xml, nvoice);

  550.         xml->endbranch();

  551.     }

  552. }

  553. 

  554. 

  555. void ADnoteGlobalParam::getfromXML(XMLwrapper *xml)

  556. {

  557.     PStereo = xml->getparbool("stereo", PStereo);

  558. 

  559.     if(xml->enterbranch("AMPLITUDE_PARAMETERS")) {

  560.         PVolume  = xml->getpar127("volume", PVolume);

  561.         PPanning = xml->getpar127("panning", PPanning);

  562.         PAmpVelocityScaleFunction = xml->getpar127("velocity_sensing",

  563.                                                    PAmpVelocityScaleFunction);

  564. 

  565.         PPunchStrength = xml->getpar127("punch_strength", PPunchStrength);

  566.         PPunchTime     = xml->getpar127("punch_time", PPunchTime);

  567.         PPunchStretch  = xml->getpar127("punch_stretch", PPunchStretch);

  568.         PPunchVelocitySensing = xml->getpar127("punch_velocity_sensing",

  569.                                                PPunchVelocitySensing);

  570.         Hrandgrouping = xml->getpar127("harmonic_randomness_grouping",

  571.                                        Hrandgrouping);

  572. 

  573.         if(xml->enterbranch("AMPLITUDE_ENVELOPE")) {

  574.             AmpEnvelope->getfromXML(xml);

  575.             xml->exitbranch();

  576.         }

  577. 

  578.         if(xml->enterbranch("AMPLITUDE_LFO")) {

  579.             AmpLfo->getfromXML(xml);

  580.             xml->exitbranch();

  581.         }

  582. 

  583.         xml->exitbranch();

  584.     }

  585. 

  586.     if(xml->enterbranch("FREQUENCY_PARAMETERS")) {

  587.         PDetune = xml->getpar("detune", PDetune, 0, 16383);

  588.         PCoarseDetune = xml->getpar("coarse_detune", PCoarseDetune, 0, 16383);

  589.         PDetuneType   = xml->getpar127("detune_type", PDetuneType);

  590.         PBandwidth    = xml->getpar127("bandwidth", PBandwidth);

  591. 

  592.         xml->enterbranch("FREQUENCY_ENVELOPE");

  593.         FreqEnvelope->getfromXML(xml);

  594.         xml->exitbranch();

  595. 

  596.         xml->enterbranch("FREQUENCY_LFO");

  597.         FreqLfo->getfromXML(xml);

  598.         xml->exitbranch();

  599. 

  600.         xml->exitbranch();

  601.     }

  602. 

  603. 

  604.     if(xml->enterbranch("FILTER_PARAMETERS")) {

  605.         PFilterVelocityScale = xml->getpar127("velocity_sensing_amplitude",

  606.                                               PFilterVelocityScale);

  607.         PFilterVelocityScaleFunction = xml->getpar127(

  608.             "velocity_sensing",

  609.             PFilterVelocityScaleFunction);

  610. 

  611.         xml->enterbranch("FILTER");

  612.         GlobalFilter->getfromXML(xml);

  613.         xml->exitbranch();

  614. 

  615.         xml->enterbranch("FILTER_ENVELOPE");

  616.         FilterEnvelope->getfromXML(xml);

  617.         xml->exitbranch();

  618. 

  619.         xml->enterbranch("FILTER_LFO");

  620.         FilterLfo->getfromXML(xml);

  621.         xml->exitbranch();

  622.         xml->exitbranch();

  623.     }

  624. 

  625.     if(xml->enterbranch("RESONANCE")) {

  626.         Reson->getfromXML(xml);

  627.         xml->exitbranch();

  628.     }

  629. }

  630. 

  631. void ADnoteParameters::getfromXML(XMLwrapper *xml)

  632. {

  633.     GlobalPar.getfromXML(xml);

  634. 

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

  636.         VoicePar[nvoice].Enabled = 0;

  637.         if(xml->enterbranch("VOICE", nvoice) == 0)

  638.             continue;

  639.         getfromXMLsection(xml, nvoice);

  640.         xml->exitbranch();

  641.     }

  642. }

  643. 

  644. void ADnoteParameters::getfromXMLsection(XMLwrapper *xml, int n)

  645. {

  646.     int nvoice = n;

  647.     if(nvoice >= NUM_VOICES)

  648.         return;

  649. 

  650.     VoicePar[nvoice].getfromXML(xml, nvoice);

  651. }

  652. 

  653. 

  654. void ADnoteVoiceParam::getfromXML(XMLwrapper *xml, unsigned nvoice)

  655. {

  656.     Enabled     = xml->getparbool("enabled", 0);

  657.     Unison_size = xml->getpar127("unison_size", Unison_size);

  658.     Unison_frequency_spread = xml->getpar127("unison_frequency_spread",

  659.                                              Unison_frequency_spread);

  660.     Unison_stereo_spread = xml->getpar127("unison_stereo_spread",

  661.                                           Unison_stereo_spread);

  662.     Unison_vibratto = xml->getpar127("unison_vibratto", Unison_vibratto);

  663.     Unison_vibratto_speed = xml->getpar127("unison_vibratto_speed",

  664.                                            Unison_vibratto_speed);

  665.     Unison_invert_phase = xml->getpar127("unison_invert_phase",

  666.                                          Unison_invert_phase);

  667. 

  668.     Type       = xml->getpar127("type", Type);

  669.     PDelay     = xml->getpar127("delay", PDelay);

  670.     Presonance = xml->getparbool("resonance", Presonance);

  671. 

  672.     Pextoscil   = xml->getpar("ext_oscil", -1, -1, nvoice - 1);

  673.     PextFMoscil = xml->getpar("ext_fm_oscil", -1, -1, nvoice - 1);

  674. 

  675.     Poscilphase    = xml->getpar127("oscil_phase", Poscilphase);

  676.     PFMoscilphase  = xml->getpar127("oscil_fm_phase", PFMoscilphase);

  677.     PFilterEnabled = xml->getparbool("filter_enabled", PFilterEnabled);

  678.     Pfilterbypass  = xml->getparbool("filter_bypass", Pfilterbypass);

  679.     PFMEnabled     = xml->getpar127("fm_enabled", PFMEnabled);

  680. 

  681.     if(xml->enterbranch("OSCIL")) {

  682.         OscilSmp->getfromXML(xml);

  683.         xml->exitbranch();

  684.     }

  685. 

  686. 

  687.     if(xml->enterbranch("AMPLITUDE_PARAMETERS")) {

  688.         PPanning     = xml->getpar127("panning", PPanning);

  689.         PVolume      = xml->getpar127("volume", PVolume);

  690.         PVolumeminus = xml->getparbool("volume_minus", PVolumeminus);

  691.         PAmpVelocityScaleFunction = xml->getpar127("velocity_sensing",

  692.                                                    PAmpVelocityScaleFunction);

  693. 

  694.         PAmpEnvelopeEnabled = xml->getparbool("amp_envelope_enabled",

  695.                                               PAmpEnvelopeEnabled);

  696.         if(xml->enterbranch("AMPLITUDE_ENVELOPE")) {

  697.             AmpEnvelope->getfromXML(xml);

  698.             xml->exitbranch();

  699.         }

  700. 

  701.         PAmpLfoEnabled = xml->getparbool("amp_lfo_enabled", PAmpLfoEnabled);

  702.         if(xml->enterbranch("AMPLITUDE_LFO")) {

  703.             AmpLfo->getfromXML(xml);

  704.             xml->exitbranch();

  705.         }

  706.         xml->exitbranch();

  707.     }

  708. 

  709.     if(xml->enterbranch("FREQUENCY_PARAMETERS")) {

  710.         Pfixedfreq    = xml->getparbool("fixed_freq", Pfixedfreq);

  711.         PfixedfreqET  = xml->getpar127("fixed_freq_et", PfixedfreqET);

  712.         PDetune       = xml->getpar("detune", PDetune, 0, 16383);

  713.         PCoarseDetune = xml->getpar("coarse_detune", PCoarseDetune, 0, 16383);

  714.         PDetuneType   = xml->getpar127("detune_type", PDetuneType);

  715.         PFreqEnvelopeEnabled = xml->getparbool("freq_envelope_enabled",

  716.                                                PFreqEnvelopeEnabled);

  717. 

  718.         if(xml->enterbranch("FREQUENCY_ENVELOPE")) {

  719.             FreqEnvelope->getfromXML(xml);

  720.             xml->exitbranch();

  721.         }

  722. 

  723.         PFreqLfoEnabled = xml->getparbool("freq_lfo_enabled", PFreqLfoEnabled);

  724. 

  725.         if(xml->enterbranch("FREQUENCY_LFO")) {

  726.             FreqLfo->getfromXML(xml);

  727.             xml->exitbranch();

  728.         }

  729.         xml->exitbranch();

  730.     }

  731. 

  732.     if(xml->enterbranch("FILTER_PARAMETERS")) {

  733.         if(xml->enterbranch("FILTER")) {

  734.             VoiceFilter->getfromXML(xml);

  735.             xml->exitbranch();

  736.         }

  737. 

  738.         PFilterEnvelopeEnabled = xml->getparbool("filter_envelope_enabled",

  739.                                                  PFilterEnvelopeEnabled);

  740.         if(xml->enterbranch("FILTER_ENVELOPE")) {

  741.             FilterEnvelope->getfromXML(xml);

  742.             xml->exitbranch();

  743.         }

  744. 

  745.         PFilterLfoEnabled = xml->getparbool("filter_lfo_enabled",

  746.                                             PFilterLfoEnabled);

  747.         if(xml->enterbranch("FILTER_LFO")) {

  748.             FilterLfo->getfromXML(xml);

  749.             xml->exitbranch();

  750.         }

  751.         xml->exitbranch();

  752.     }

  753. 

  754.     if(xml->enterbranch("FM_PARAMETERS")) {

  755.         PFMVoice      = xml->getpar("input_voice", PFMVoice, -1, nvoice - 1);

  756.         PFMVolume     = xml->getpar127("volume", PFMVolume);

  757.         PFMVolumeDamp = xml->getpar127("volume_damp", PFMVolumeDamp);

  758.         PFMVelocityScaleFunction = xml->getpar127("velocity_sensing",

  759.                                                   PFMVelocityScaleFunction);

  760. 

  761.         PFMAmpEnvelopeEnabled = xml->getparbool("amp_envelope_enabled",

  762.                                                 PFMAmpEnvelopeEnabled);

  763.         if(xml->enterbranch("AMPLITUDE_ENVELOPE")) {

  764.             FMAmpEnvelope->getfromXML(xml);

  765.             xml->exitbranch();

  766.         }

  767. 

  768.         if(xml->enterbranch("MODULATOR")) {

  769.             PFMDetune = xml->getpar("detune", PFMDetune, 0, 16383);

  770.             PFMCoarseDetune = xml->getpar("coarse_detune",

  771.                                           PFMCoarseDetune,

  772.                                           0,

  773.                                           16383);

  774.             PFMDetuneType = xml->getpar127("detune_type", PFMDetuneType);

  775. 

  776.             PFMFreqEnvelopeEnabled = xml->getparbool("freq_envelope_enabled",

  777.                                                      PFMFreqEnvelopeEnabled);

  778.             if(xml->enterbranch("FREQUENCY_ENVELOPE")) {

  779.                 FMFreqEnvelope->getfromXML(xml);

  780.                 xml->exitbranch();

  781.             }

  782. 

  783.             if(xml->enterbranch("OSCIL")) {

  784.                 FMSmp->getfromXML(xml);

  785.                 xml->exitbranch();

  786.             }

  787. 

  788.             xml->exitbranch();

  789.         }

  790.         xml->exitbranch();

  791.     }

  792. }