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.
3441 Commits
17 Branches
341MB
Tree: f9387f9a34
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f9387f9a34'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/Params/SUBnoteParameters.cpp

593 lines
19KB
Raw Blame History 

  1. /*

  2.   ZynAddSubFX - a software synthesizer

  3. 

  4.   SUBnoteParameters.cpp - Parameters for SUBnote (SUBsynth)

  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 "../globals.h"

  15. #include "SUBnoteParameters.h"

  16. #include "EnvelopeParams.h"

  17. #include "FilterParams.h"

  18. #include "../Misc/Util.h"

  19. #include "../Misc/Time.h"

  20. #include <cstdio>

  21. #include <cmath>

  22. 

  23. #include <rtosc/ports.h>

  24. #include <rtosc/port-sugar.h>

  25. 

  26. #define rObject SUBnoteParameters

  27. using namespace rtosc;

  28. 

  29. #define rBegin [](const char *msg, RtData &d) { \

  30.     SUBnoteParameters *obj = (SUBnoteParameters*) d.obj

  31. #define rEnd }

  32. 

  33. 

  34. #undef rChangeCb

  35. #define rChangeCb if (obj->time) { obj->last_update_timestamp = obj->time->time(); }

  36. static const rtosc::Ports SUBnotePorts = {

  37.     rSelf(SUBnoteParameters),

  38.     rPaste,

  39.     rToggle(Pstereo,    rShort("stereo"), "Stereo Enable"),

  40.     rParamZyn(PVolume,  rShort("volume"), "Volume"),

  41.     rParamZyn(PPanning, rShort("panning"), "Left Right Panning"),

  42.     rParamZyn(PAmpVelocityScaleFunction, rShort("sense"), "Amplitude Velocity Sensing function"),

  43.     rParamI(PDetune,       rShort("detune"), rLinear(0, 16383), "Detune in detune type units"),

  44.     rParamI(PCoarseDetune, rShort("cdetune"), "Coarse Detune"),

  45.     //Real values needed

  46.     rOption(PDetuneType,               rShort("det. scl."),

  47.             rOptions(L35 cents, L10 cents, E100 cents, E1200 cents), "Detune Scale"),

  48.     rToggle(PFreqEnvelopeEnabled,      rShort("enable"), "Enable for Frequency Envelope"),

  49.     rToggle(PBandWidthEnvelopeEnabled, rShort("enable"), "Enable for Bandwidth Envelope"),

  50.     rToggle(PGlobalFilterEnabled,                 rShort("enable"), "Enable for Global Filter"),

  51.     rParamZyn(PGlobalFilterVelocityScale,         rShort("scale"), "Filter Velocity Magnitude"),

  52.     rParamZyn(PGlobalFilterVelocityScaleFunction, rShort("sense"), "Filter Velocity Function Shape"),

  53.     //rRecur(FreqEnvelope, EnvelopeParams),

  54.     //rToggle(),//continue

  55.     rToggle(Pfixedfreq,     rShort("fixed freq"), "Base frequency fixed frequency enable"),

  56.     rParamZyn(PfixedfreqET, rShort("fixed ET"),   "Equal temeperate control for fixed frequency operation"),

  57.     rParamZyn(PBendAdjust,  rShort("bend"),       "Pitch bend adjustment"),

  58.     rParamZyn(POffsetHz,    rShort("+ Hz"),       "Voice constant offset"),

  59. #undef rChangeCb

  60. #define rChangeCb obj->updateFrequencyMultipliers(); if (obj->time) { \

  61.     obj->last_update_timestamp = obj->time->time(); }

  62.     rParamI(POvertoneSpread.type, rMap(min, 0), rMap(max, 7), rShort("spread type")

  63.             rOptions(Harmonic, ShiftU, ShiftL, PowerU, PowerL, Sine, Power, Shift),

  64.             "Spread of harmonic frequencies"),

  65.     rParamI(POvertoneSpread.par1, rMap(min, 0), rMap(max, 255), rShort("p1"),

  66.             "Overtone Parameter"),

  67.     rParamI(POvertoneSpread.par2, rMap(min, 0), rMap(max, 255), rShort("p2"),

  68.             "Overtone Parameter"),

  69.     rParamI(POvertoneSpread.par3, rMap(min, 0), rMap(max, 255), rShort("forceH"),

  70.             "Force Overtones To Harmonics"),

  71. #undef rChangeCb

  72. #define rChangeCb if (obj->time) { obj->last_update_timestamp = obj->time->time(); }

  73.     rParamI(Pnumstages, rShort("stages"), rMap(min, 1), rMap(max, 5), "Number of filter stages"),

  74.     rParamZyn(Pbandwidth, rShort("bandwidth"), "Bandwidth of filters"),

  75.     rParamZyn(Phmagtype,  rShort("mag. type"), rOptions(linear, -40dB, -60dB, -80dB, -100dB), "Magnitude scale"),

  76.     rArray(Phmag, MAX_SUB_HARMONICS, "Harmonic magnitudes"),

  77.     rArray(Phrelbw, MAX_SUB_HARMONICS, "Relative bandwidth"),

  78.     rParamZyn(Pbwscale, rShort("stretch"), "Bandwidth scaling with frequency"),

  79.     rRecurp(AmpEnvelope,          "Amplitude envelope"),

  80.     rRecurp(FreqEnvelope,         "Frequency Envelope"),

  81.     rRecurp(BandWidthEnvelope,    "Bandwidth Envelope"),

  82.     rRecurp(GlobalFilterEnvelope, "Post Filter Envelope"),

  83.     rRecurp(GlobalFilter,         "Post Filter"),

  84.     rOption(Pstart, rShort("initial"), rOptions(zero, random, ones), "How harmonics are initialized"),

  85. 

  86.     {"clear:", rDoc("Reset all harmonics to equal bandwidth/zero amplitude"), NULL,

  87.         rBegin;

  88.         for(int i=0; i<MAX_SUB_HARMONICS; ++i) {

  89.             obj->Phmag[i]   = 0;

  90.             obj->Phrelbw[i] = 64;

  91.         }

  92.         obj->Phmag[0] = 127;

  93.         rEnd},

  94.     {"detunevalue:", rDoc("Get note detune value"), NULL,

  95.         rBegin;

  96.         d.reply(d.loc, "f", getdetune(obj->PDetuneType, 0, obj->PDetune));

  97.         rEnd},

  98.     //weird stuff for PCoarseDetune

  99.     {"octave::c:i", rProp(parameter) rShort("octave") rLinear(-8,7)

  100.         rDoc("Note octave shift"), NULL,

  101.         rBegin;

  102.         if(!rtosc_narguments(msg)) {

  103.             int k=obj->PCoarseDetune/1024;

  104.             if (k>=8) k-=16;

  105.             d.reply(d.loc, "i", k);

  106.         } else {

  107.             int k=(int) rtosc_argument(msg, 0).i;

  108.             if (k<0) k+=16;

  109.             obj->PCoarseDetune = k*1024 + obj->PCoarseDetune%1024;

  110.         }

  111.         rEnd},

  112.     {"coarsedetune::c:i", rProp(parameter) rShort("coarse") rLinear(-64, 63)

  113.         rDoc("Note coarse detune"), NULL,

  114.         rBegin;

  115.         if(!rtosc_narguments(msg)) {

  116.             int k=obj->PCoarseDetune%1024;

  117.             if (k>=512) k-=1024;

  118.             d.reply(d.loc, "i", k);

  119.         } else {

  120.             int k=(int) rtosc_argument(msg, 0).i;

  121.             if (k<0) k+=1024;

  122.             obj->PCoarseDetune = k + (obj->PCoarseDetune/1024)*1024;

  123.         }

  124.         rEnd},

  125.     {"response:", rDoc("Filter response at 440Hz. with 48kHz sample rate\n\n"

  126.             "Format: stages, filter*active_filters\n"

  127.             "        filter = [frequency, bandwidth, amplitude]"),

  128.     NULL,

  129.     rBegin;

  130. 

  131.     //Identify the active harmonics

  132.     int pos[MAX_SUB_HARMONICS];

  133.     int harmonics;

  134.     obj->activeHarmonics(pos, harmonics);

  135. 

  136.     float base_freq = 440.0f;

  137. 

  138.     char        types[3*MAX_SUB_HARMONICS+2];

  139.     rtosc_arg_t args[3*MAX_SUB_HARMONICS+1];

  140. 

  141.     args[0].i = obj->Pnumstages;

  142.     types[0]  = 'i';

  143. 

  144.     for(int n=0; n<harmonics; ++n) {

  145.         const float freq = base_freq * obj->POvertoneFreqMult[pos[n]];

  146.         //the bandwidth is not absolute(Hz); it is relative to frequency

  147.         const float bw = obj->convertBandwidth(obj->Pbandwidth,

  148.                 obj->Pnumstages, freq, obj->Pbwscale, obj->Phrelbw[pos[n]]);

  149. 

  150.         //try to keep same amplitude on all freqs and bw. (empirically)

  151.         const float hgain = obj->convertHarmonicMag(obj->Phmag[pos[n]],

  152.                                                     obj->Phmagtype);

  153.         const float gain  = hgain * sqrt(1500.0f / (bw * freq));

  154. 

  155.         int base = 1+3*n;

  156.         args[base + 0].f = freq;

  157.         args[base + 1].f = bw;

  158.         args[base + 2].f = gain;

  159.         types[base + 0] = 'f';

  160.         types[base + 1] = 'f';

  161.         types[base + 2] = 'f';

  162.     }

  163. 

  164.     types[3*harmonics+1] = 0;

  165.     d.replyArray(d.loc, types, args);

  166.     rEnd},

  167. 

  168. 

  169. };

  170. #undef rChangeCb

  171. #undef rBegin

  172. #undef rEnd

  173. 

  174. const rtosc::Ports &SUBnoteParameters::ports = SUBnotePorts;

  175. 

  176. SUBnoteParameters::SUBnoteParameters(const AbsTime *time_)

  177.         : Presets(), time(time_), last_update_timestamp(0)

  178. {

  179.     setpresettype("Psubsynth");

  180.     AmpEnvelope = new EnvelopeParams(64, 1, time_);

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

  182.     FreqEnvelope = new EnvelopeParams(64, 0, time_);

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

  184.     BandWidthEnvelope = new EnvelopeParams(64, 0, time_);

  185.     BandWidthEnvelope->ASRinit_bw(100, 70, 64, 60);

  186. 

  187.     GlobalFilter = new FilterParams(2, 80, 40, time_);

  188.     GlobalFilterEnvelope = new EnvelopeParams(0, 1, time_);

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

  190. 

  191.     defaults();

  192. }

  193. 

  194. void SUBnoteParameters::activeHarmonics(int *pos, int &harmonics) const

  195. {

  196.     harmonics = 0;

  197.     for(int n = 0; n < MAX_SUB_HARMONICS; ++n) {

  198.         if(Phmag[n] == 0)

  199.             continue;

  200.         pos[harmonics++] = n;

  201.     }

  202. }

  203. 

  204. float SUBnoteParameters::convertBandwidth(int bw_, int stages, float freq,

  205.         int scale, int relbw)

  206. {

  207.     //the bandwidth is not absolute(Hz); it is relative to frequency

  208.     float bw = powf(10, (bw_ - 127.0f) / 127.0f * 4) * stages;

  209. 

  210.     //Bandwidth Scale

  211.     bw *= powf(1000 / freq, (scale - 64.0f) / 64.0f * 3.0f);

  212. 

  213.     //Relative BandWidth

  214.     bw *= powf(100, (relbw - 64.0f) / 64.0f);

  215. 

  216.     if(bw > 25.0f)

  217.         bw = 25.0f;

  218. 

  219.     return bw;

  220. }

  221. 

  222. float SUBnoteParameters::convertHarmonicMag(int mag, int type)

  223. {

  224.     const float hmagnew = 1.0f - mag / 127.0f;

  225. 

  226.     switch(type) {

  227.         case 1:

  228.             return expf(hmagnew * logf(0.01f));

  229.             break;

  230.         case 2:

  231.             return expf(hmagnew * logf(0.001f));

  232.             break;

  233.         case 3:

  234.             return expf(hmagnew * logf(0.0001f));

  235.             break;

  236.         case 4:

  237.             return expf(hmagnew * logf(0.00001f));

  238.             break;

  239.         default:

  240.             return 1.0f - hmagnew;

  241.     }

  242. }

  243. 

  244. 

  245. void SUBnoteParameters::defaults()

  246. {

  247.     PVolume  = 96;

  248.     PPanning = 64;

  249.     PAmpVelocityScaleFunction = 90;

  250. 

  251.     Pfixedfreq   = 0;

  252.     PfixedfreqET = 0;

  253.     PBendAdjust = 88; // 64 + 24

  254.     POffsetHz = 64;

  255.     Pnumstages   = 2;

  256.     Pbandwidth   = 40;

  257.     Phmagtype    = 0;

  258.     Pbwscale     = 64;

  259.     Pstereo      = 1;

  260.     Pstart = 1;

  261. 

  262.     PDetune = 8192;

  263.     PCoarseDetune = 0;

  264.     PDetuneType   = 1;

  265.     PFreqEnvelopeEnabled      = 0;

  266.     PBandWidthEnvelopeEnabled = 0;

  267. 

  268.     POvertoneSpread.type = 0;

  269.     POvertoneSpread.par1 = 0;

  270.     POvertoneSpread.par2 = 0;

  271.     POvertoneSpread.par3 = 0;

  272.     updateFrequencyMultipliers();

  273. 

  274.     for(int n = 0; n < MAX_SUB_HARMONICS; ++n) {

  275.         Phmag[n]   = 0;

  276.         Phrelbw[n] = 64;

  277.     }

  278.     Phmag[0] = 127;

  279. 

  280.     PGlobalFilterEnabled = 0;

  281.     PGlobalFilterVelocityScale = 64;

  282.     PGlobalFilterVelocityScaleFunction = 64;

  283. 

  284.     AmpEnvelope->defaults();

  285.     FreqEnvelope->defaults();

  286.     BandWidthEnvelope->defaults();

  287.     GlobalFilter->defaults();

  288.     GlobalFilterEnvelope->defaults();

  289. }

  290. 

  291. 

  292. 

  293. SUBnoteParameters::~SUBnoteParameters()

  294. {

  295.     delete (AmpEnvelope);

  296.     delete (FreqEnvelope);

  297.     delete (BandWidthEnvelope);

  298.     delete (GlobalFilter);

  299.     delete (GlobalFilterEnvelope);

  300. }

  301. 

  302. 

  303. 

  304. 

  305. void SUBnoteParameters::add2XML(XMLwrapper& xml)

  306. {

  307.     xml.addpar("num_stages", Pnumstages);

  308.     xml.addpar("harmonic_mag_type", Phmagtype);

  309.     xml.addpar("start", Pstart);

  310. 

  311.     xml.beginbranch("HARMONICS");

  312.     for(int i = 0; i < MAX_SUB_HARMONICS; ++i) {

  313.         if((Phmag[i] == 0) && (xml.minimal))

  314.             continue;

  315.         xml.beginbranch("HARMONIC", i);

  316.         xml.addpar("mag", Phmag[i]);

  317.         xml.addpar("relbw", Phrelbw[i]);

  318.         xml.endbranch();

  319.     }

  320.     xml.endbranch();

  321. 

  322.     xml.beginbranch("AMPLITUDE_PARAMETERS");

  323.     xml.addparbool("stereo", Pstereo);

  324.     xml.addpar("volume", PVolume);

  325.     xml.addpar("panning", PPanning);

  326.     xml.addpar("velocity_sensing", PAmpVelocityScaleFunction);

  327.     xml.beginbranch("AMPLITUDE_ENVELOPE");

  328.     AmpEnvelope->add2XML(xml);

  329.     xml.endbranch();

  330.     xml.endbranch();

  331. 

  332.     xml.beginbranch("FREQUENCY_PARAMETERS");

  333.     xml.addparbool("fixed_freq", Pfixedfreq);

  334.     xml.addpar("fixed_freq_et", PfixedfreqET);

  335.     xml.addpar("bend_adjust", PBendAdjust);

  336.     xml.addpar("offset_hz", POffsetHz);

  337. 

  338.     xml.addpar("detune", PDetune);

  339.     xml.addpar("coarse_detune", PCoarseDetune);

  340.     xml.addpar("overtone_spread_type", POvertoneSpread.type);

  341.     xml.addpar("overtone_spread_par1", POvertoneSpread.par1);

  342.     xml.addpar("overtone_spread_par2", POvertoneSpread.par2);

  343.     xml.addpar("overtone_spread_par3", POvertoneSpread.par3);

  344.     xml.addpar("detune_type", PDetuneType);

  345. 

  346.     xml.addpar("bandwidth", Pbandwidth);

  347.     xml.addpar("bandwidth_scale", Pbwscale);

  348. 

  349.     xml.addparbool("freq_envelope_enabled", PFreqEnvelopeEnabled);

  350.     if((PFreqEnvelopeEnabled != 0) || (!xml.minimal)) {

  351.         xml.beginbranch("FREQUENCY_ENVELOPE");

  352.         FreqEnvelope->add2XML(xml);

  353.         xml.endbranch();

  354.     }

  355. 

  356.     xml.addparbool("band_width_envelope_enabled", PBandWidthEnvelopeEnabled);

  357.     if((PBandWidthEnvelopeEnabled != 0) || (!xml.minimal)) {

  358.         xml.beginbranch("BANDWIDTH_ENVELOPE");

  359.         BandWidthEnvelope->add2XML(xml);

  360.         xml.endbranch();

  361.     }

  362.     xml.endbranch();

  363. 

  364.     xml.beginbranch("FILTER_PARAMETERS");

  365.     xml.addparbool("enabled", PGlobalFilterEnabled);

  366.     if((PGlobalFilterEnabled != 0) || (!xml.minimal)) {

  367.         xml.beginbranch("FILTER");

  368.         GlobalFilter->add2XML(xml);

  369.         xml.endbranch();

  370. 

  371.         xml.addpar("filter_velocity_sensing",

  372.                     PGlobalFilterVelocityScaleFunction);

  373.         xml.addpar("filter_velocity_sensing_amplitude",

  374.                     PGlobalFilterVelocityScale);

  375. 

  376.         xml.beginbranch("FILTER_ENVELOPE");

  377.         GlobalFilterEnvelope->add2XML(xml);

  378.         xml.endbranch();

  379.     }

  380.     xml.endbranch();

  381. }

  382. 

  383. 

  384. 

  385. void SUBnoteParameters::updateFrequencyMultipliers(void) {

  386.     float par1 = POvertoneSpread.par1 / 255.0f;

  387.     float par1pow = powf(10.0f,

  388.             -(1.0f - POvertoneSpread.par1 / 255.0f) * 3.0f);

  389.     float par2 = POvertoneSpread.par2 / 255.0f;

  390.     float par3 = 1.0f - POvertoneSpread.par3 / 255.0f;

  391.     float result;

  392.     float tmp = 0.0f;

  393.     int   thresh = 0;

  394. 

  395.     for(int n = 0; n < MAX_SUB_HARMONICS; ++n) {

  396.         float n1     = n + 1.0f;

  397.         switch(POvertoneSpread.type) {

  398.             case 1:

  399.                 thresh = (int)(100.0f * par2 * par2) + 1;

  400.                 if (n1 < thresh)

  401.                     result = n1;

  402.                 else

  403.                     result = n1 + 8.0f * (n1 - thresh) * par1pow;

  404.                 break;

  405.             case 2:

  406.                 thresh = (int)(100.0f * par2 * par2) + 1;

  407.                 if (n1 < thresh)

  408.                     result = n1;

  409.                 else

  410.                     result = n1 + 0.9f * (thresh - n1) * par1pow;

  411.                 break;

  412.             case 3:

  413.                 tmp = par1pow * 100.0f + 1.0f;

  414.                 result = powf(n / tmp, 1.0f - 0.8f * par2) * tmp + 1.0f;

  415.                 break;

  416.             case 4:

  417.                 result = n * (1.0f - par1pow) +

  418.                     powf(0.1f * n, 3.0f * par2 + 1.0f) *

  419.                     10.0f * par1pow + 1.0f;

  420.                 break;

  421. 

  422.             case 5:

  423.                 result = n1 + 2.0f * sinf(n * par2 * par2 * PI * 0.999f) *

  424.                     sqrt(par1pow);

  425.                 break;

  426.             case 6:

  427.                 tmp    = powf(2.0f * par2, 2.0f) + 0.1f;

  428.                 result = n * powf(par1 * powf(0.8f * n, tmp) + 1.0f, tmp) +

  429.                     1.0f;

  430.                 break;

  431. 

  432.             case 7:

  433.                 result = (n1 + par1) / (par1 + 1);

  434.                 break;

  435.             default:

  436.                 result = n1;

  437.         }

  438.         float iresult = floor(result + 0.5f);

  439.         POvertoneFreqMult[n] = iresult + par3 * (result - iresult);

  440.     }

  441. }

  442. 

  443. #define doPaste(x) this->x = sub.x;

  444. #define doPPaste(x) this->x->paste(*sub.x);

  445. void SUBnoteParameters::paste(SUBnoteParameters &sub)

  446. {

  447.     doPaste(Pstereo);

  448.     doPaste(PVolume);

  449.     doPaste(PPanning);

  450.     doPaste(PAmpVelocityScaleFunction);

  451.     doPPaste(AmpEnvelope);

  452. 

  453.     //Frequency Parameters

  454.     doPaste(PDetune);

  455.     doPaste(PCoarseDetune);

  456.     doPaste(PDetuneType);

  457.     doPaste(PBendAdjust);

  458.     doPaste(POffsetHz);

  459.     doPaste(PFreqEnvelopeEnabled);

  460.     doPPaste(FreqEnvelope);

  461.     doPaste(PBandWidthEnvelopeEnabled);

  462.     doPPaste(BandWidthEnvelope);

  463. 

  464.     //Filter Parameters (Global)

  465.     doPaste(PGlobalFilterEnabled);

  466.     doPPaste(GlobalFilter);

  467.     doPaste(PGlobalFilterVelocityScale);

  468.     doPaste(PGlobalFilterVelocityScaleFunction);

  469.     doPPaste(GlobalFilterEnvelope);

  470. 

  471. 

  472.     //Other Parameters

  473.     doPaste(Pfixedfreq);

  474.     doPaste(PfixedfreqET);

  475.     doPaste(POvertoneSpread.type);

  476.     doPaste(POvertoneSpread.par1);

  477.     doPaste(POvertoneSpread.par2);

  478.     doPaste(POvertoneSpread.par3);

  479. 

  480.     for(int i=0; i<MAX_SUB_HARMONICS; ++i)

  481.         doPaste(POvertoneFreqMult[i]);

  482. 

  483.     doPaste(Pnumstages);

  484.     doPaste(Pbandwidth);

  485.     doPaste(Phmagtype);

  486. 

  487.     for(int i=0; i<MAX_SUB_HARMONICS; ++i) {

  488.         doPaste(Phmag[i]);

  489.         doPaste(Phrelbw[i]);

  490.     }

  491. 

  492.     doPaste(Pbwscale);

  493.     doPaste(Pstart);

  494. 

  495.     if ( time ) {

  496.         last_update_timestamp = time->time();

  497.     }

  498. }

  499. 

  500. void SUBnoteParameters::getfromXML(XMLwrapper& xml)

  501. {

  502.     Pnumstages = xml.getpar127("num_stages", Pnumstages);

  503.     Phmagtype  = xml.getpar127("harmonic_mag_type", Phmagtype);

  504.     Pstart     = xml.getpar127("start", Pstart);

  505. 

  506.     if(xml.enterbranch("HARMONICS")) {

  507.         Phmag[0] = 0;

  508.         for(int i = 0; i < MAX_SUB_HARMONICS; ++i) {

  509.             if(xml.enterbranch("HARMONIC", i) == 0)

  510.                 continue;

  511.             Phmag[i]   = xml.getpar127("mag", Phmag[i]);

  512.             Phrelbw[i] = xml.getpar127("relbw", Phrelbw[i]);

  513.             xml.exitbranch();

  514.         }

  515.         xml.exitbranch();

  516.     }

  517. 

  518.     if(xml.enterbranch("AMPLITUDE_PARAMETERS")) {

  519.         Pstereo  = xml.getparbool("stereo", Pstereo);

  520.         PVolume  = xml.getpar127("volume", PVolume);

  521.         PPanning = xml.getpar127("panning", PPanning);

  522.         PAmpVelocityScaleFunction = xml.getpar127("velocity_sensing",

  523.                 PAmpVelocityScaleFunction);

  524.         if(xml.enterbranch("AMPLITUDE_ENVELOPE")) {

  525.             AmpEnvelope->getfromXML(xml);

  526.             xml.exitbranch();

  527.         }

  528.         xml.exitbranch();

  529.     }

  530. 

  531.     if(xml.enterbranch("FREQUENCY_PARAMETERS")) {

  532.         Pfixedfreq   = xml.getparbool("fixed_freq", Pfixedfreq);

  533.         PfixedfreqET = xml.getpar127("fixed_freq_et", PfixedfreqET);

  534.         PBendAdjust  = xml.getpar127("bend_adjust", PBendAdjust);

  535.         POffsetHz  = xml.getpar127("offset_hz", POffsetHz);

  536. 

  537.         PDetune = xml.getpar("detune", PDetune, 0, 16383);

  538.         PCoarseDetune = xml.getpar("coarse_detune", PCoarseDetune, 0, 16383);

  539.         POvertoneSpread.type =

  540.             xml.getpar127("overtone_spread_type", POvertoneSpread.type);

  541.         POvertoneSpread.par1 =

  542.             xml.getpar("overtone_spread_par1", POvertoneSpread.par1, 0, 255);

  543.         POvertoneSpread.par2 =

  544.             xml.getpar("overtone_spread_par2", POvertoneSpread.par2, 0, 255);

  545.         POvertoneSpread.par3 =

  546.             xml.getpar("overtone_spread_par3", POvertoneSpread.par3, 0, 255);

  547.         updateFrequencyMultipliers();

  548.         PDetuneType   = xml.getpar127("detune_type", PDetuneType);

  549. 

  550.         Pbandwidth = xml.getpar127("bandwidth", Pbandwidth);

  551.         Pbwscale   = xml.getpar127("bandwidth_scale", Pbwscale);

  552. 

  553.         PFreqEnvelopeEnabled = xml.getparbool("freq_envelope_enabled",

  554.                 PFreqEnvelopeEnabled);

  555.         if(xml.enterbranch("FREQUENCY_ENVELOPE")) {

  556.             FreqEnvelope->getfromXML(xml);

  557.             xml.exitbranch();

  558.         }

  559. 

  560.         PBandWidthEnvelopeEnabled = xml.getparbool(

  561.                 "band_width_envelope_enabled",

  562.                 PBandWidthEnvelopeEnabled);

  563.         if(xml.enterbranch("BANDWIDTH_ENVELOPE")) {

  564.             BandWidthEnvelope->getfromXML(xml);

  565.             xml.exitbranch();

  566.         }

  567. 

  568.         xml.exitbranch();

  569.     }

  570. 

  571.     if(xml.enterbranch("FILTER_PARAMETERS")) {

  572.         PGlobalFilterEnabled = xml.getparbool("enabled", PGlobalFilterEnabled);

  573.         if(xml.enterbranch("FILTER")) {

  574.             GlobalFilter->getfromXML(xml);

  575.             xml.exitbranch();

  576.         }

  577. 

  578.         PGlobalFilterVelocityScaleFunction = xml.getpar127(

  579.                 "filter_velocity_sensing",

  580.                 PGlobalFilterVelocityScaleFunction);

  581.         PGlobalFilterVelocityScale = xml.getpar127(

  582.                 "filter_velocity_sensing_amplitude",

  583.                 PGlobalFilterVelocityScale);

  584. 

  585.         if(xml.enterbranch("FILTER_ENVELOPE")) {

  586.             GlobalFilterEnvelope->getfromXML(xml);

  587.             xml.exitbranch();

  588.         }

  589. 

  590.         xml.exitbranch();

  591.     }

  592. }