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

797 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("Padsynth");

  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.     Unison_phase_randomness = 127;

  131. 

  132.     Type = 0;

  133.     Pfixedfreq    = 0;

  134.     PfixedfreqET  = 0;

  135.     Presonance    = 1;

  136.     Pfilterbypass = 0;

  137.     Pextoscil     = -1;

  138.     PextFMoscil   = -1;

  139.     Poscilphase   = 64;

  140.     PFMoscilphase = 64;

  141.     PDelay                    = 0;

  142.     PVolume                   = 100;

  143.     PVolumeminus              = 0;

  144.     PPanning                  = 64; //center

  145.     PDetune                   = 8192; //8192=0

  146.     PCoarseDetune             = 0;

  147.     PDetuneType               = 0;

  148.     PFreqLfoEnabled           = 0;

  149.     PFreqEnvelopeEnabled      = 0;

  150.     PAmpEnvelopeEnabled       = 0;

  151.     PAmpLfoEnabled            = 0;

  152.     PAmpVelocityScaleFunction = 127;

  153.     PFilterEnabled            = 0;

  154.     PFilterEnvelopeEnabled    = 0;

  155.     PFilterLfoEnabled         = 0;

  156.     PFMEnabled                = 0;

  157. 

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

  159.     PFMVoice = -1;

  160. 

  161.     PFMVolume       = 90;

  162.     PFMVolumeDamp   = 64;

  163.     PFMDetune       = 8192;

  164.     PFMCoarseDetune = 0;

  165.     PFMDetuneType   = 0;

  166.     PFMFreqEnvelopeEnabled   = 0;

  167.     PFMAmpEnvelopeEnabled    = 0;

  168.     PFMVelocityScaleFunction = 64;

  169. 

  170.     OscilSmp->defaults();

  171.     FMSmp->defaults();

  172. 

  173.     AmpEnvelope->defaults();

  174.     AmpLfo->defaults();

  175. 

  176.     FreqEnvelope->defaults();

  177.     FreqLfo->defaults();

  178. 

  179.     VoiceFilter->defaults();

  180.     FilterEnvelope->defaults();

  181.     FilterLfo->defaults();

  182. 

  183.     FMFreqEnvelope->defaults();

  184.     FMAmpEnvelope->defaults();

  185. }

  186. 

  187. 

  188. 

  189. /*

  190.  * Init the voice parameters

  191.  */

  192. void ADnoteParameters::EnableVoice(int nvoice)

  193. {

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

  195. }

  196. 

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

  198. {

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

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

  201. 

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

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

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

  205. 

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

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

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

  209. 

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

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

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

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

  214. 

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

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

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

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

  219. }

  220. 

  221. /*

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

  223.  */

  224. float ADnoteParameters::getBandwidthDetuneMultiplier()

  225. {

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

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

  228. 

  229.     return bw;

  230. }

  231. 

  232. /*

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

  234.  */

  235. 

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

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

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

  239.     return unison_spread;

  240. }

  241. 

  242. /*

  243.  * Kill the voice

  244.  */

  245. void ADnoteParameters::KillVoice(int nvoice)

  246. {

  247.     VoicePar[nvoice].kill();

  248. }

  249. 

  250. void ADnoteVoiceParam::kill()

  251. {

  252.     delete OscilSmp;

  253.     delete FMSmp;

  254. 

  255.     delete AmpEnvelope;

  256.     delete AmpLfo;

  257. 

  258.     delete FreqEnvelope;

  259.     delete FreqLfo;

  260. 

  261.     delete VoiceFilter;

  262.     delete FilterEnvelope;

  263.     delete FilterLfo;

  264. 

  265.     delete FMFreqEnvelope;

  266.     delete FMAmpEnvelope;

  267. }

  268. 

  269. 

  270. ADnoteGlobalParam::~ADnoteGlobalParam()

  271. {

  272.     delete FreqEnvelope;

  273.     delete FreqLfo;

  274.     delete AmpEnvelope;

  275.     delete AmpLfo;

  276.     delete GlobalFilter;

  277.     delete FilterEnvelope;

  278.     delete FilterLfo;

  279.     delete Reson;

  280. }

  281. 

  282. ADnoteParameters::~ADnoteParameters()

  283. {

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

  285.         KillVoice(nvoice);

  286. }

  287. 

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

  289.     int index = 0;

  290.     if(nvoice >= NUM_VOICES)

  291.         return 0;

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

  293. 

  294.     while(1) {

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

  296.             return index;

  297. 

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

  299.             return index - 1;

  300. 

  301.         index++;

  302.     }

  303.     return 0;

  304. }

  305. 

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

  307.     int unison = 1;

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

  309.         unison = ADnote_unison_sizes[i];

  310.         if(unison == 0) {

  311.             unison = ADnote_unison_sizes[i - 1];

  312.             break;

  313.         }

  314.     }

  315. 

  316.     VoicePar[nvoice].Unison_size = unison;

  317. }

  318. 

  319. 

  320. 

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

  322. {

  323.     int nvoice = n;

  324.     if(nvoice >= NUM_VOICES)

  325.         return;

  326. 

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

  328. 

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

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

  331.             oscilused = 1;

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

  333.             fmoscilused = 1;

  334.     }

  335. 

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

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

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

  339.         return;

  340. 

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

  342. }

  343. 

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

  345. {

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

  347. 

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

  349.     xml->addpar("unison_frequency_spread",

  350.                 Unison_frequency_spread);

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

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

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

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

  355.     xml->addpar("unison_phase_randomness", Unison_phase_randomness);

  356. 

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

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

  359. 

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

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

  362. 

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

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

  365. 

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

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

  368. 

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

  370. 

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

  372.     OscilSmp->add2XML(xml);

  373.     xml->endbranch();

  374. 

  375. 

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

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

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

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

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

  381. 

  382.     xml->addparbool("amp_envelope_enabled",

  383.                     PAmpEnvelopeEnabled);

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

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

  386.         AmpEnvelope->add2XML(xml);

  387.         xml->endbranch();

  388.     }

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

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

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

  392.         AmpLfo->add2XML(xml);

  393.         xml->endbranch();

  394.     }

  395.     xml->endbranch();

  396. 

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

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

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

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

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

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

  403. 

  404.     xml->addparbool("freq_envelope_enabled",

  405.                     PFreqEnvelopeEnabled);

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

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

  408.         FreqEnvelope->add2XML(xml);

  409.         xml->endbranch();

  410.     }

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

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

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

  414.         FreqLfo->add2XML(xml);

  415.         xml->endbranch();

  416.     }

  417.     xml->endbranch();

  418. 

  419. 

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

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

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

  423.         VoiceFilter->add2XML(xml);

  424.         xml->endbranch();

  425. 

  426.         xml->addparbool("filter_envelope_enabled",

  427.                         PFilterEnvelopeEnabled);

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

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

  430.             FilterEnvelope->add2XML(xml);

  431.             xml->endbranch();

  432.         }

  433. 

  434.         xml->addparbool("filter_lfo_enabled",

  435.                         PFilterLfoEnabled);

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

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

  438.             FilterLfo->add2XML(xml);

  439.             xml->endbranch();

  440.         }

  441.         xml->endbranch();

  442.     }

  443. 

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

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

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

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

  448. 

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

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

  451.         xml->addpar("velocity_sensing",

  452.                     PFMVelocityScaleFunction);

  453. 

  454.         xml->addparbool("amp_envelope_enabled",

  455.                         PFMAmpEnvelopeEnabled);

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

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

  458.             FMAmpEnvelope->add2XML(xml);

  459.             xml->endbranch();

  460.         }

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

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

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

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

  465. 

  466.         xml->addparbool("freq_envelope_enabled",

  467.                         PFMFreqEnvelopeEnabled);

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

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

  470.             FMFreqEnvelope->add2XML(xml);

  471.             xml->endbranch();

  472.         }

  473. 

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

  475.         FMSmp->add2XML(xml);

  476.         xml->endbranch();

  477. 

  478.         xml->endbranch();

  479.         xml->endbranch();

  480.     }

  481. }

  482. 

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

  484. {

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

  486. 

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

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

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

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

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

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

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

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

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

  496. 

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

  498.     AmpEnvelope->add2XML(xml);

  499.     xml->endbranch();

  500. 

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

  502.     AmpLfo->add2XML(xml);

  503.     xml->endbranch();

  504.     xml->endbranch();

  505. 

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

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

  508. 

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

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

  511. 

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

  513. 

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

  515.     FreqEnvelope->add2XML(xml);

  516.     xml->endbranch();

  517. 

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

  519.     FreqLfo->add2XML(xml);

  520.     xml->endbranch();

  521.     xml->endbranch();

  522. 

  523. 

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

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

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

  527. 

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

  529.     GlobalFilter->add2XML(xml);

  530.     xml->endbranch();

  531. 

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

  533.     FilterEnvelope->add2XML(xml);

  534.     xml->endbranch();

  535. 

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

  537.     FilterLfo->add2XML(xml);

  538.     xml->endbranch();

  539.     xml->endbranch();

  540. 

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

  542.     Reson->add2XML(xml);

  543.     xml->endbranch();

  544. }

  545. 

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

  547. {

  548.     GlobalPar.add2XML(xml);

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

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

  551.         add2XMLsection(xml, nvoice);

  552.         xml->endbranch();

  553.     }

  554. }

  555. 

  556. 

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

  558. {

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

  560. 

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

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

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

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

  565.                                                    PAmpVelocityScaleFunction);

  566. 

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

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

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

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

  571.                                                PPunchVelocitySensing);

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

  573.                                        Hrandgrouping);

  574. 

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

  576.             AmpEnvelope->getfromXML(xml);

  577.             xml->exitbranch();

  578.         }

  579. 

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

  581.             AmpLfo->getfromXML(xml);

  582.             xml->exitbranch();

  583.         }

  584. 

  585.         xml->exitbranch();

  586.     }

  587. 

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

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

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

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

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

  593. 

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

  595.         FreqEnvelope->getfromXML(xml);

  596.         xml->exitbranch();

  597. 

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

  599.         FreqLfo->getfromXML(xml);

  600.         xml->exitbranch();

  601. 

  602.         xml->exitbranch();

  603.     }

  604. 

  605. 

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

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

  608.                                               PFilterVelocityScale);

  609.         PFilterVelocityScaleFunction = xml->getpar127(

  610.             "velocity_sensing",

  611.             PFilterVelocityScaleFunction);

  612. 

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

  614.         GlobalFilter->getfromXML(xml);

  615.         xml->exitbranch();

  616. 

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

  618.         FilterEnvelope->getfromXML(xml);

  619.         xml->exitbranch();

  620. 

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

  622.         FilterLfo->getfromXML(xml);

  623.         xml->exitbranch();

  624.         xml->exitbranch();

  625.     }

  626. 

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

  628.         Reson->getfromXML(xml);

  629.         xml->exitbranch();

  630.     }

  631. }

  632. 

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

  634. {

  635.     GlobalPar.getfromXML(xml);

  636. 

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

  638.         VoicePar[nvoice].Enabled = 0;

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

  640.             continue;

  641.         getfromXMLsection(xml, nvoice);

  642.         xml->exitbranch();

  643.     }

  644. }

  645. 

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

  647. {

  648.     int nvoice = n;

  649.     if(nvoice >= NUM_VOICES)

  650.         return;

  651. 

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

  653. }

  654. 

  655. 

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

  657. {

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

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

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

  661.                                              Unison_frequency_spread);

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

  663.                                           Unison_stereo_spread);

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

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

  666.                                            Unison_vibratto_speed);

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

  668.                                          Unison_invert_phase);

  669.     Unison_phase_randomness = xml->getpar127("unison_phase_randomness",

  670. 						Unison_phase_randomness);

  671. 

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

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

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

  675. 

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

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

  678. 

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

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

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

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

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

  684. 

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

  686.         OscilSmp->getfromXML(xml);

  687.         xml->exitbranch();

  688.     }

  689. 

  690. 

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

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

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

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

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

  696.                                                    PAmpVelocityScaleFunction);

  697. 

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

  699.                                               PAmpEnvelopeEnabled);

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

  701.             AmpEnvelope->getfromXML(xml);

  702.             xml->exitbranch();

  703.         }

  704. 

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

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

  707.             AmpLfo->getfromXML(xml);

  708.             xml->exitbranch();

  709.         }

  710.         xml->exitbranch();

  711.     }

  712. 

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

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

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

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

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

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

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

  720.                                                PFreqEnvelopeEnabled);

  721. 

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

  723.             FreqEnvelope->getfromXML(xml);

  724.             xml->exitbranch();

  725.         }

  726. 

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

  728. 

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

  730.             FreqLfo->getfromXML(xml);

  731.             xml->exitbranch();

  732.         }

  733.         xml->exitbranch();

  734.     }

  735. 

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

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

  738.             VoiceFilter->getfromXML(xml);

  739.             xml->exitbranch();

  740.         }

  741. 

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

  743.                                                  PFilterEnvelopeEnabled);

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

  745.             FilterEnvelope->getfromXML(xml);

  746.             xml->exitbranch();

  747.         }

  748. 

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

  750.                                             PFilterLfoEnabled);

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

  752.             FilterLfo->getfromXML(xml);

  753.             xml->exitbranch();

  754.         }

  755.         xml->exitbranch();

  756.     }

  757. 

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

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

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

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

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

  763.                                                   PFMVelocityScaleFunction);

  764. 

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

  766.                                                 PFMAmpEnvelopeEnabled);

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

  768.             FMAmpEnvelope->getfromXML(xml);

  769.             xml->exitbranch();

  770.         }

  771. 

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

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

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

  775.                                           PFMCoarseDetune,

  776.                                           0,

  777.                                           16383);

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

  779. 

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

  781.                                                      PFMFreqEnvelopeEnabled);

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

  783.                 FMFreqEnvelope->getfromXML(xml);

  784.                 xml->exitbranch();

  785.             }

  786. 

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

  788.                 FMSmp->getfromXML(xml);

  789.                 xml->exitbranch();

  790.             }

  791. 

  792.             xml->exitbranch();

  793.         }

  794.         xml->exitbranch();

  795.     }

  796. }