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.
1383 Commits
17 Branches
263MB
Tree: e2d2434ea6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e2d2434ea6'
${ noResults }
Carla/source/modules/native-plugins/zynaddsubfx/Misc/Microtonal.cpp

695 lines
19KB
Raw Blame History 

  1. /*

  2.   ZynAddSubFX - a software synthesizer

  3. 

  4.   Microtonal.cpp - Tuning settings and microtonal capabilities

  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 <math.h>

  24. #include <string.h>

  25. #include "Microtonal.h"

  26. 

  27. #define MAX_LINE_SIZE 80

  28. 

  29. Microtonal::Microtonal()

  30. {

  31.     Pname    = new unsigned char[MICROTONAL_MAX_NAME_LEN];

  32.     Pcomment = new unsigned char[MICROTONAL_MAX_NAME_LEN];

  33.     defaults();

  34. }

  35. 

  36. void Microtonal::defaults()

  37. {

  38.     Pinvertupdown = 0;

  39.     Pinvertupdowncenter = 60;

  40.     octavesize  = 12;

  41.     Penabled    = 0;

  42.     PAnote      = 69;

  43.     PAfreq      = 440.0f;

  44.     Pscaleshift = 64;

  45. 

  46.     Pfirstkey       = 0;

  47.     Plastkey        = 127;

  48.     Pmiddlenote     = 60;

  49.     Pmapsize        = 12;

  50.     Pmappingenabled = 0;

  51. 

  52.     for(int i = 0; i < 128; ++i)

  53.         Pmapping[i] = i;

  54. 

  55.     for(int i = 0; i < MAX_OCTAVE_SIZE; ++i) {

  56.         octave[i].tuning = tmpoctave[i].tuning = powf(

  57.                                2,

  58.                                (i % octavesize

  59.                                 + 1) / 12.0f);

  60.         octave[i].type = tmpoctave[i].type = 1;

  61.         octave[i].x1   = tmpoctave[i].x1 = (i % octavesize + 1) * 100;

  62.         octave[i].x2   = tmpoctave[i].x2 = 0;

  63.     }

  64.     octave[11].type = 2;

  65.     octave[11].x1   = 2;

  66.     octave[11].x2   = 1;

  67.     for(int i = 0; i < MICROTONAL_MAX_NAME_LEN; ++i) {

  68.         Pname[i]    = '\0';

  69.         Pcomment[i] = '\0';

  70.     }

  71.     snprintf((char *) Pname, MICROTONAL_MAX_NAME_LEN, "12tET");

  72.     snprintf((char *) Pcomment,

  73.              MICROTONAL_MAX_NAME_LEN,

  74.              "Equal Temperament 12 notes per octave");

  75.     Pglobalfinedetune = 64;

  76. }

  77. 

  78. Microtonal::~Microtonal()

  79. {

  80.     delete [] Pname;

  81.     delete [] Pcomment;

  82. }

  83. 

  84. /*

  85.  * Get the size of the octave

  86.  */

  87. unsigned char Microtonal::getoctavesize() const

  88. {

  89.     if(Penabled != 0)

  90.         return octavesize;

  91.     else

  92.         return 12;

  93. }

  94. 

  95. /*

  96.  * Get the frequency according the note number

  97.  */

  98. float Microtonal::getnotefreq(int note, int keyshift) const

  99. {

  100.     // in this function will appears many times things like this:

  101.     // var=(a+b*100)%b

  102.     // I had written this way because if I use var=a%b gives unwanted results when a<0

  103.     // This is the same with divisions.

  104. 

  105.     if((Pinvertupdown != 0) && ((Pmappingenabled == 0) || (Penabled == 0)))

  106.         note = (int) Pinvertupdowncenter * 2 - note;

  107. 

  108.     //compute global fine detune

  109.     float globalfinedetunerap = powf(2.0f,

  110.                                      (Pglobalfinedetune - 64.0f) / 1200.0f);       //-64.0f .. 63.0f cents

  111. 

  112.     if(Penabled == 0)

  113.         return powf(2.0f,

  114.                     (note - PAnote

  115.                      + keyshift) / 12.0f) * PAfreq * globalfinedetunerap;                     //12tET

  116. 

  117.     int scaleshift =

  118.         ((int)Pscaleshift - 64 + (int) octavesize * 100) % octavesize;

  119. 

  120.     //compute the keyshift

  121.     float rap_keyshift = 1.0f;

  122.     if(keyshift != 0) {

  123.         int kskey = (keyshift + (int)octavesize * 100) % octavesize;

  124.         int ksoct = (keyshift + (int)octavesize * 100) / octavesize - 100;

  125.         rap_keyshift  = (kskey == 0) ? (1.0f) : (octave[kskey - 1].tuning);

  126.         rap_keyshift *= powf(octave[octavesize - 1].tuning, ksoct);

  127.     }

  128. 

  129.     //if the mapping is enabled

  130.     if(Pmappingenabled != 0) {

  131.         if((note < Pfirstkey) || (note > Plastkey))

  132.             return -1.0f;

  133.         //Compute how many mapped keys are from middle note to reference note

  134.         //and find out the proportion between the freq. of middle note and "A" note

  135.         int tmp = PAnote - Pmiddlenote, minus = 0;

  136.         if(tmp < 0) {

  137.             tmp   = -tmp;

  138.             minus = 1;

  139.         }

  140.         int deltanote = 0;

  141.         for(int i = 0; i < tmp; ++i)

  142.             if(Pmapping[i % Pmapsize] >= 0)

  143.                 deltanote++;

  144.         float rap_anote_middlenote =

  145.             (deltanote ==

  146.              0) ? (1.0f) : (octave[(deltanote - 1) % octavesize].tuning);

  147.         if(deltanote != 0)

  148.             rap_anote_middlenote *=

  149.                 powf(octave[octavesize - 1].tuning,

  150.                      (deltanote - 1) / octavesize);

  151.         if(minus != 0)

  152.             rap_anote_middlenote = 1.0f / rap_anote_middlenote;

  153. 

  154.         //Convert from note (midi) to degree (note from the tunning)

  155.         int degoct =

  156.             (note - (int)Pmiddlenote + (int) Pmapsize

  157.              * 200) / (int)Pmapsize - 200;

  158.         int degkey = (note - Pmiddlenote + (int)Pmapsize * 100) % Pmapsize;

  159.         degkey = Pmapping[degkey];

  160.         if(degkey < 0)

  161.             return -1.0f;           //this key is not mapped

  162. 

  163.         //invert the keyboard upside-down if it is asked for

  164.         //TODO: do the right way by using Pinvertupdowncenter

  165.         if(Pinvertupdown != 0) {

  166.             degkey = octavesize - degkey - 1;

  167.             degoct = -degoct;

  168.         }

  169.         //compute the frequency of the note

  170.         degkey  = degkey + scaleshift;

  171.         degoct += degkey / octavesize;

  172.         degkey %= octavesize;

  173. 

  174.         float freq = (degkey == 0) ? (1.0f) : octave[degkey - 1].tuning;

  175.         freq *= powf(octave[octavesize - 1].tuning, degoct);

  176.         freq *= PAfreq / rap_anote_middlenote;

  177.         freq *= globalfinedetunerap;

  178.         if(scaleshift != 0)

  179.             freq /= octave[scaleshift - 1].tuning;

  180.         return freq * rap_keyshift;

  181.     }

  182.     else {  //if the mapping is disabled

  183.         int nt    = note - PAnote + scaleshift;

  184.         int ntkey = (nt + (int)octavesize * 100) % octavesize;

  185.         int ntoct = (nt - ntkey) / octavesize;

  186. 

  187.         float oct  = octave[octavesize - 1].tuning;

  188.         float freq =

  189.             octave[(ntkey + octavesize - 1) % octavesize].tuning * powf(oct,

  190.                                                                         ntoct)

  191.             * PAfreq;

  192.         if(ntkey == 0)

  193.             freq /= oct;

  194.         if(scaleshift != 0)

  195.             freq /= octave[scaleshift - 1].tuning;

  196. //	fprintf(stderr,"note=%d freq=%.3f cents=%d\n",note,freq,(int)floor(logf(freq/PAfreq)/logf(2.0f)*1200.0f+0.5f));

  197.         freq *= globalfinedetunerap;

  198.         return freq * rap_keyshift;

  199.     }

  200. }

  201. 

  202. bool Microtonal::operator==(const Microtonal &micro) const

  203. {

  204.     return !(*this != micro);

  205. }

  206. 

  207. bool Microtonal::operator!=(const Microtonal &micro) const

  208. {

  209.     //A simple macro to test equality MiCRotonal EQuals (not the perfect

  210.     //approach, but good enough)

  211. #define MCREQ(x) if(x != micro.x) \

  212.         return true

  213. 

  214.     //for floats

  215. #define FMCREQ(x) if(!((x < micro.x + 0.0001f) && (x > micro.x - 0.0001f))) \

  216.         return true

  217. 

  218.     MCREQ(Pinvertupdown);

  219.     MCREQ(Pinvertupdowncenter);

  220.     MCREQ(octavesize);

  221.     MCREQ(Penabled);

  222.     MCREQ(PAnote);

  223.     FMCREQ(PAfreq);

  224.     MCREQ(Pscaleshift);

  225. 

  226.     MCREQ(Pfirstkey);

  227.     MCREQ(Plastkey);

  228.     MCREQ(Pmiddlenote);

  229.     MCREQ(Pmapsize);

  230.     MCREQ(Pmappingenabled);

  231. 

  232.     for(int i = 0; i < 128; ++i)

  233.         MCREQ(Pmapping[i]);

  234. 

  235.     for(int i = 0; i < octavesize; ++i) {

  236.         FMCREQ(octave[i].tuning);

  237.         MCREQ(octave[i].type);

  238.         MCREQ(octave[i].x1);

  239.         MCREQ(octave[i].x2);

  240.     }

  241.     if(strcmp((const char *)this->Pname, (const char *)micro.Pname))

  242.         return true;

  243.     if(strcmp((const char *)this->Pcomment, (const char *)micro.Pcomment))

  244.         return true;

  245.     MCREQ(Pglobalfinedetune);

  246.     return false;

  247. 

  248.     //undefine macros, as they are no longer needed

  249. #undef MCREQ

  250. #undef FMCREQ

  251. }

  252. 

  253. 

  254. /*

  255.  * Convert a line to tunings; returns -1 if it ok

  256.  */

  257. int Microtonal::linetotunings(unsigned int nline, const char *line)

  258. {

  259.     int   x1 = -1, x2 = -1, type = -1;

  260.     float x  = -1.0f, tmp, tuning = 1.0f;

  261.     if(strstr(line, "/") == NULL) {

  262.         if(strstr(line, ".") == NULL) { // M case (M=M/1)

  263.             sscanf(line, "%d", &x1);

  264.             x2   = 1;

  265.             type = 2; //division

  266.         }

  267.         else {  // float number case

  268.             sscanf(line, "%f", &x);

  269.             if(x < 0.000001f)

  270.                 return 1;

  271.             type = 1; //float type(cents)

  272.         }

  273.     }

  274.     else {  // M/N case

  275.         sscanf(line, "%d/%d", &x1, &x2);

  276.         if((x1 < 0) || (x2 < 0))

  277.             return 1;

  278.         if(x2 == 0)

  279.             x2 = 1;

  280.         type = 2; //division

  281.     }

  282. 

  283.     if(x1 <= 0)

  284.         x1 = 1;     //not allow zero frequency sounds (consider 0 as 1)

  285. 

  286.     //convert to float if the number are too big

  287.     if((type == 2)

  288.        && ((x1 > (128 * 128 * 128 - 1)) || (x2 > (128 * 128 * 128 - 1)))) {

  289.         type = 1;

  290.         x    = ((float) x1) / x2;

  291.     }

  292.     switch(type) {

  293.         case 1:

  294.             x1     = (int) floor(x);

  295.             tmp    = fmod(x, 1.0f);

  296.             x2     = (int) (floor(tmp * 1e6));

  297.             tuning = powf(2.0f, x / 1200.0f);

  298.             break;

  299.         case 2:

  300.             x      = ((float)x1) / x2;

  301.             tuning = x;

  302.             break;

  303.     }

  304. 

  305.     tmpoctave[nline].tuning = tuning;

  306.     tmpoctave[nline].type   = type;

  307.     tmpoctave[nline].x1     = x1;

  308.     tmpoctave[nline].x2     = x2;

  309. 

  310.     return -1; //ok

  311. }

  312. 

  313. /*

  314.  * Convert the text to tunnings

  315.  */

  316. int Microtonal::texttotunings(const char *text)

  317. {

  318.     unsigned int i, k = 0, nl = 0;

  319.     char *lin;

  320.     lin = new char[MAX_LINE_SIZE + 1];

  321.     while(k < strlen(text)) {

  322.         for(i = 0; i < MAX_LINE_SIZE; ++i) {

  323.             lin[i] = text[k++];

  324.             if(lin[i] < 0x20)

  325.                 break;

  326.         }

  327.         lin[i] = '\0';

  328.         if(strlen(lin) == 0)

  329.             continue;

  330.         int err = linetotunings(nl, lin);

  331.         if(err != -1) {

  332.             delete [] lin;

  333.             return nl; //Parse error

  334.         }

  335.         nl++;

  336.     }

  337.     delete [] lin;

  338.     if(nl > MAX_OCTAVE_SIZE)

  339.         nl = MAX_OCTAVE_SIZE;

  340.     if(nl == 0)

  341.         return -2;        //the input is empty

  342.     octavesize = nl;

  343.     for(i = 0; i < octavesize; ++i) {

  344.         octave[i].tuning = tmpoctave[i].tuning;

  345.         octave[i].type   = tmpoctave[i].type;

  346.         octave[i].x1     = tmpoctave[i].x1;

  347.         octave[i].x2     = tmpoctave[i].x2;

  348.     }

  349.     return -1; //ok

  350. }

  351. 

  352. /*

  353.  * Convert the text to mapping

  354.  */

  355. void Microtonal::texttomapping(const char *text)

  356. {

  357.     unsigned int i, k = 0;

  358.     char *lin;

  359.     lin = new char[MAX_LINE_SIZE + 1];

  360.     for(i = 0; i < 128; ++i)

  361.         Pmapping[i] = -1;

  362.     int tx = 0;

  363.     while(k < strlen(text)) {

  364.         for(i = 0; i < MAX_LINE_SIZE; ++i) {

  365.             lin[i] = text[k++];

  366.             if(lin[i] < 0x20)

  367.                 break;

  368.         }

  369.         lin[i] = '\0';

  370.         if(strlen(lin) == 0)

  371.             continue;

  372. 

  373.         int tmp = 0;

  374.         if(sscanf(lin, "%d", &tmp) == 0)

  375.             tmp = -1;

  376.         if(tmp < -1)

  377.             tmp = -1;

  378.         Pmapping[tx] = tmp;

  379. 

  380.         if((tx++) > 127)

  381.             break;

  382.     }

  383.     delete [] lin;

  384. 

  385.     if(tx == 0)

  386.         tx = 1;

  387.     Pmapsize = tx;

  388. }

  389. 

  390. /*

  391.  * Convert tunning to text line

  392.  */

  393. void Microtonal::tuningtoline(int n, char *line, int maxn)

  394. {

  395.     if((n > octavesize) || (n > MAX_OCTAVE_SIZE)) {

  396.         line[0] = '\0';

  397.         return;

  398.     }

  399.     if(octave[n].type == 1)

  400.         snprintf(line, maxn, "%d.%06d", octave[n].x1, octave[n].x2);

  401.     if(octave[n].type == 2)

  402.         snprintf(line, maxn, "%d/%d", octave[n].x1, octave[n].x2);

  403. }

  404. 

  405. 

  406. int Microtonal::loadline(FILE *file, char *line)

  407. {

  408.     do {

  409.         if(fgets(line, 500, file) == 0)

  410.             return 1;

  411.     } while(line[0] == '!');

  412.     return 0;

  413. }

  414. /*

  415.  * Loads the tunnings from a scl file

  416.  */

  417. int Microtonal::loadscl(const char *filename)

  418. {

  419.     FILE *file = fopen(filename, "r");

  420.     char  tmp[500];

  421.     fseek(file, 0, SEEK_SET);

  422.     //loads the short description

  423.     if(loadline(file, &tmp[0]) != 0)

  424.         return 2;

  425.     for(int i = 0; i < 500; ++i)

  426.         if(tmp[i] < 32)

  427.             tmp[i] = 0;

  428.     snprintf((char *) Pname, MICROTONAL_MAX_NAME_LEN, "%s", tmp);

  429.     snprintf((char *) Pcomment, MICROTONAL_MAX_NAME_LEN, "%s", tmp);

  430.     //loads the number of the notes

  431.     if(loadline(file, &tmp[0]) != 0)

  432.         return 2;

  433.     int nnotes = MAX_OCTAVE_SIZE;

  434.     sscanf(&tmp[0], "%d", &nnotes);

  435.     if(nnotes > MAX_OCTAVE_SIZE)

  436.         return 2;

  437.     //load the tunnings

  438.     for(int nline = 0; nline < nnotes; ++nline) {

  439.         if(loadline(file, &tmp[0]) != 0)

  440.             return 2;

  441.         linetotunings(nline, &tmp[0]);

  442.     }

  443.     fclose(file);

  444. 

  445.     octavesize = nnotes;

  446.     for(int i = 0; i < octavesize; ++i) {

  447.         octave[i].tuning = tmpoctave[i].tuning;

  448.         octave[i].type   = tmpoctave[i].type;

  449.         octave[i].x1     = tmpoctave[i].x1;

  450.         octave[i].x2     = tmpoctave[i].x2;

  451.     }

  452. 

  453.     return 0;

  454. }

  455. 

  456. /*

  457.  * Loads the mapping from a kbm file

  458.  */

  459. int Microtonal::loadkbm(const char *filename)

  460. {

  461.     FILE *file = fopen(filename, "r");

  462.     int   x;

  463.     char  tmp[500];

  464. 

  465.     fseek(file, 0, SEEK_SET);

  466.     //loads the mapsize

  467.     if(loadline(file, &tmp[0]) != 0)

  468.         return 2;

  469.     if(sscanf(&tmp[0], "%d", &x) == 0)

  470.         return 2;

  471.     if(x < 1)

  472.         x = 0;

  473.     if(x > 127)

  474.         x = 127;     //just in case...

  475.     Pmapsize = x;

  476.     //loads first MIDI note to retune

  477.     if(loadline(file, &tmp[0]) != 0)

  478.         return 2;

  479.     if(sscanf(&tmp[0], "%d", &x) == 0)

  480.         return 2;

  481.     if(x < 1)

  482.         x = 0;

  483.     if(x > 127)

  484.         x = 127;     //just in case...

  485.     Pfirstkey = x;

  486.     //loads last MIDI note to retune

  487.     if(loadline(file, &tmp[0]) != 0)

  488.         return 2;

  489.     if(sscanf(&tmp[0], "%d", &x) == 0)

  490.         return 2;

  491.     if(x < 1)

  492.         x = 0;

  493.     if(x > 127)

  494.         x = 127;     //just in case...

  495.     Plastkey = x;

  496.     //loads last the middle note where scale fro scale degree=0

  497.     if(loadline(file, &tmp[0]) != 0)

  498.         return 2;

  499.     if(sscanf(&tmp[0], "%d", &x) == 0)

  500.         return 2;

  501.     if(x < 1)

  502.         x = 0;

  503.     if(x > 127)

  504.         x = 127;     //just in case...

  505.     Pmiddlenote = x;

  506.     //loads the reference note

  507.     if(loadline(file, &tmp[0]) != 0)

  508.         return 2;

  509.     if(sscanf(&tmp[0], "%d", &x) == 0)

  510.         return 2;

  511.     if(x < 1)

  512.         x = 0;

  513.     if(x > 127)

  514.         x = 127;     //just in case...

  515.     PAnote = x;

  516.     //loads the reference freq.

  517.     if(loadline(file, &tmp[0]) != 0)

  518.         return 2;

  519.     float tmpPAfreq = 440.0f;

  520.     if(sscanf(&tmp[0], "%f", &tmpPAfreq) == 0)

  521.         return 2;

  522.     PAfreq = tmpPAfreq;

  523. 

  524.     //the scale degree(which is the octave) is not loaded, it is obtained by the tunnings with getoctavesize() method

  525.     if(loadline(file, &tmp[0]) != 0)

  526.         return 2;

  527. 

  528.     //load the mappings

  529.     if(Pmapsize != 0) {

  530.         for(int nline = 0; nline < Pmapsize; ++nline) {

  531.             if(loadline(file, &tmp[0]) != 0)

  532.                 return 2;

  533.             if(sscanf(&tmp[0], "%d", &x) == 0)

  534.                 x = -1;

  535.             Pmapping[nline] = x;

  536.         }

  537.         Pmappingenabled = 1;

  538.     }

  539.     else {

  540.         Pmappingenabled = 0;

  541.         Pmapping[0]     = 0;

  542.         Pmapsize = 1;

  543.     }

  544.     fclose(file);

  545. 

  546.     return 0;

  547. }

  548. 

  549. 

  550. 

  551. void Microtonal::add2XML(XMLwrapper *xml) const

  552. {

  553.     xml->addparstr("name", (char *) Pname);

  554.     xml->addparstr("comment", (char *) Pcomment);

  555. 

  556.     xml->addparbool("invert_up_down", Pinvertupdown);

  557.     xml->addpar("invert_up_down_center", Pinvertupdowncenter);

  558. 

  559.     xml->addparbool("enabled", Penabled);

  560.     xml->addpar("global_fine_detune", Pglobalfinedetune);

  561. 

  562.     xml->addpar("a_note", PAnote);

  563.     xml->addparreal("a_freq", PAfreq);

  564. 

  565.     if((Penabled == 0) && (xml->minimal))

  566.         return;

  567. 

  568.     xml->beginbranch("SCALE");

  569.     xml->addpar("scale_shift", Pscaleshift);

  570.     xml->addpar("first_key", Pfirstkey);

  571.     xml->addpar("last_key", Plastkey);

  572.     xml->addpar("middle_note", Pmiddlenote);

  573. 

  574.     xml->beginbranch("OCTAVE");

  575.     xml->addpar("octave_size", octavesize);

  576.     for(int i = 0; i < octavesize; ++i) {

  577.         xml->beginbranch("DEGREE", i);

  578.         if(octave[i].type == 1)

  579.             xml->addparreal("cents", octave[i].tuning);

  580.         ;

  581.         if(octave[i].type == 2) {

  582.             xml->addpar("numerator", octave[i].x1);

  583.             xml->addpar("denominator", octave[i].x2);

  584.         }

  585.         xml->endbranch();

  586.     }

  587.     xml->endbranch();

  588. 

  589.     xml->beginbranch("KEYBOARD_MAPPING");

  590.     xml->addpar("map_size", Pmapsize);

  591.     xml->addpar("mapping_enabled", Pmappingenabled);

  592.     for(int i = 0; i < Pmapsize; ++i) {

  593.         xml->beginbranch("KEYMAP", i);

  594.         xml->addpar("degree", Pmapping[i]);

  595.         xml->endbranch();

  596.     }

  597. 

  598.     xml->endbranch();

  599.     xml->endbranch();

  600. }

  601. 

  602. void Microtonal::getfromXML(XMLwrapper *xml)

  603. {

  604.     xml->getparstr("name", (char *) Pname, MICROTONAL_MAX_NAME_LEN);

  605.     xml->getparstr("comment", (char *) Pcomment, MICROTONAL_MAX_NAME_LEN);

  606. 

  607.     Pinvertupdown = xml->getparbool("invert_up_down", Pinvertupdown);

  608.     Pinvertupdowncenter = xml->getpar127("invert_up_down_center",

  609.                                          Pinvertupdowncenter);

  610. 

  611.     Penabled = xml->getparbool("enabled", Penabled);

  612.     Pglobalfinedetune = xml->getpar127("global_fine_detune", Pglobalfinedetune);

  613. 

  614.     PAnote = xml->getpar127("a_note", PAnote);

  615.     PAfreq = xml->getparreal("a_freq", PAfreq, 1.0f, 10000.0f);

  616. 

  617.     if(xml->enterbranch("SCALE")) {

  618.         Pscaleshift = xml->getpar127("scale_shift", Pscaleshift);

  619.         Pfirstkey   = xml->getpar127("first_key", Pfirstkey);

  620.         Plastkey    = xml->getpar127("last_key", Plastkey);

  621.         Pmiddlenote = xml->getpar127("middle_note", Pmiddlenote);

  622. 

  623.         if(xml->enterbranch("OCTAVE")) {

  624.             octavesize = xml->getpar127("octave_size", octavesize);

  625.             for(int i = 0; i < octavesize; ++i) {

  626.                 if(xml->enterbranch("DEGREE", i) == 0)

  627.                     continue;

  628.                 octave[i].x2     = 0;

  629.                 octave[i].tuning = xml->getparreal("cents", octave[i].tuning);

  630.                 octave[i].x1     = xml->getpar127("numerator", octave[i].x1);

  631.                 octave[i].x2     = xml->getpar127("denominator", octave[i].x2);

  632. 

  633.                 if(octave[i].x2 != 0)

  634.                     octave[i].type = 2;

  635.                 else {

  636.                     octave[i].type = 1;

  637.                     //populate fields for display

  638.                     float x = logf(octave[i].tuning) / LOG_2 * 1200.0f;

  639.                     octave[i].x1 = (int) floor(x);

  640.                     octave[i].x2 = (int) (floor(fmodf(x, 1.0f) * 1e6));

  641.                 }

  642. 

  643. 

  644.                 xml->exitbranch();

  645.             }

  646.             xml->exitbranch();

  647.         }

  648. 

  649.         if(xml->enterbranch("KEYBOARD_MAPPING")) {

  650.             Pmapsize = xml->getpar127("map_size", Pmapsize);

  651.             Pmappingenabled = xml->getpar127("mapping_enabled", Pmappingenabled);

  652.             for(int i = 0; i < Pmapsize; ++i) {

  653.                 if(xml->enterbranch("KEYMAP", i) == 0)

  654.                     continue;

  655.                 Pmapping[i] = xml->getpar127("degree", Pmapping[i]);

  656.                 xml->exitbranch();

  657.             }

  658.             xml->exitbranch();

  659.         }

  660.         xml->exitbranch();

  661.     }

  662. }

  663. 

  664. 

  665. 

  666. int Microtonal::saveXML(const char *filename) const

  667. {

  668.     XMLwrapper *xml = new XMLwrapper();

  669. 

  670.     xml->beginbranch("MICROTONAL");

  671.     add2XML(xml);

  672.     xml->endbranch();

  673. 

  674.     int result = xml->saveXMLfile(filename);

  675.     delete (xml);

  676.     return result;

  677. }

  678. 

  679. int Microtonal::loadXML(const char *filename)

  680. {

  681.     XMLwrapper *xml = new XMLwrapper();

  682.     if(xml->loadXMLfile(filename) < 0) {

  683.         delete (xml);

  684.         return -1;

  685.     }

  686. 

  687.     if(xml->enterbranch("MICROTONAL") == 0)

  688.         return -10;

  689.     getfromXML(xml);

  690.     xml->exitbranch();

  691. 

  692.     delete (xml);

  693.     return 0;

  694. }